the effective model is attributed on the response as always, so the answer

  still says what produced it.

The thread API's local lane is not an exception to this law, because no

selection happens there. Amended 2026-08-25 (issue #243): `POST

/api/v1/threads` with `"lane": "local"` records a bounded free-form vendor

string as the thread's model without catalog admission — and mints nothing.

No grant ever carries that string, the proxy never pins it, and no provider

is ever asked to serve it; `OpenAgents.Threads.mint_grant/1` refuses the

thread outright (THREAD-001). Every path that mints authority still admits

only the catalog, so a non-catalog model can be recorded but never granted,

and no turn is ever answered by it.

The chat lane keeps the same law through `OpenAgents.Chat.Backends`: an

unsupported `model` on `POST /api/v1/chat/turns` is a typed `422`, and

`GET /api/v1` publishes the supported enum from the same list.

  thread's active grants inside the transaction that writes the terminal row,

  and `mint_grant/1` refuses a thread that is not open. Deleting a thread — or

  the account, under the DATA-004 cascade — deletes its grants with it.

- **A local-lane thread holds no authority, ever.** Added 2026-08-25 (issue

  #243). `threads.lane` admits `thread` and `local` by check constraint,

  defaulting to `thread` — the granted lane every earlier thread came

  through. `POST /api/v1/threads` with `"lane": "local"` opens a

  transcript-only thread: its `model` is the bounded vendor string a local

  runtime serves (`ollama:...`), admitted against no catalog and no provider,

  and the open mints nothing — the response carries no grant and no token,

  and the fence never moves off generation 0.

  `OpenAgents.Threads.mint_grant/1` refuses a local-lane thread with

  `:thread_local_lane` — rendered as the stable code `thread_lane_local` —

  the way it refuses a terminal one, so the no-provider-key and metering

  invariants hold by construction: a thread that can never be granted can

  never spend the account's credit or reach a provider. Everything else about

  it is an ordinary thread: the transcript appends and broadcasts, the

  transparency tier governs its readers, the admission cap counts it, and

  `DELETE` ends it. Its `thread.opened` event records `"lane": "local"`, so

  the transcript itself says no authority backs it.

  `test/openagents/threads/local_lane_test.exs` proves both halves.

- **A thread is bounded where a bound means something.** The objective is

  capped at 32 KB and the terminal report at 32 KB, both by check constraint;

  every transcript entry is pinned to `openagents.thread.event.v1` with no

`OpenAgentsWeb.ThreadController`,

`priv/repo/migrations/20260823221415_create_threads_and_thread_events.exs`,

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

`priv/repo/migrations/20260825120000_add_lane_to_threads.exs`,

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

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

`test/openagents/threads/local_lane_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`.

| WORK-001 | `test/openagents/work_job_test.exs`, `test/openagents/deep_work_tool_loop_test.exs` |

| SELF-EDIT-001 | `test/openagents/tools/repository_mutation_tools_test.exs`, `test/openagents/coding_job_test.exs`, `test/openagents/dependency_boundary_test.exs` |

| SCV-001 | `test/openagents/scv/deployments_test.exs`, `test/openagents/dependency_boundary_test.exs` |

| THREAD-001 | `test/openagents/threads/grant_fence_test.exs`, `test/openagents/threads/grant_token_reach_test.exs`, `test/openagents/threads_test.exs`, `test/openagents/threads/credit_race_test.exs` |

| THREAD-001 | `test/openagents/threads/grant_fence_test.exs`, `test/openagents/threads/grant_token_reach_test.exs`, `test/openagents/threads_test.exs`, `test/openagents/threads/credit_race_test.exs`, `test/openagents/threads/local_lane_test.exs` |

| THREAD-002 | `test/openagents/threads/visibility_test.exs`, `test/openagents_web/thread_visibility_test.exs`, `test/openagents/threads/grant_token_reach_test.exs` |

| THREAD-003 | `test/openagents/threads_test.exs`, `test/openagents/threads/visibility_test.exs` |

| OUTCOME-001 | `test/openagents/accepted_outcome_test.exs`, `test/openagents/issues/completion_claims_test.exs`, `test/openagents_web/controllers/issue_completion_claim_controller_test.exs` |

`OpenAgents.Threads.Event`. A caller opens one with `POST /api/v1/threads`,

reads what it has spent with `GET /api/v1/threads/{thread_id}`, and revokes it

with `DELETE /api/v1/threads/{thread_id}`, all behind the `chat:account` scope

and served by `OpenAgentsWeb.ThreadController`. The CLI that stops writing to

and served by `OpenAgentsWeb.ThreadController`. A thread opened with

`"lane": "local"` is transcript-only: its model is the vendor string a local

runtime serves, and it is never granted authority — the server records the run

without paying for it (THREAD-001, issue #243). The CLI that stops writing to

the conversation is still to come; see the audit in

`docs/2026-08-23-thread-primitive-audit.md`.

  `OpenAgents.Threads.Thread.default_visibility/0`, owner-only. A wider tier

  given here is recorded in the transcript as `thread.visibility_set`

  (THREAD-002).

  `:lane` defaults to the granted `thread` lane. The `local` lane admits a

  transcript-only thread: its `:model` is the bounded vendor string a local

  runtime serves rather than a catalog id, its `thread.opened` event names the

  lane, and no grant is ever minted for it — `mint_grant/1` refuses it with

  `:thread_local_lane`. It still counts against the open-thread cap, because

  an open thread holds an admission slot whether or not it holds authority

  (issue #243).

  """

  @spec open(User.t() | Visitor.t(), String.t(), keyword()) ::

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

          | {:error,

             :thread_quota_reached

             | :thread_terminal

             | :thread_local_lane

             | :credit_exhausted

             | :parent_authority_exhausted

             | Ecto.Changeset.t()}

      objective: objective,

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

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

      lane: Keyword.get(options, :lane, Thread.default_lane()),

      reasoning_effort:

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

      permission_profile: Keyword.get(options, :permission_profile, @default_permission_profile),

      Thread.open_changeset(attributes, visitor_id, now)

    end)

    |> Multi.run(:opened_event, fn _repo, %{thread: thread} ->

      insert_event(

        thread,

        "thread.opened",

        %{"objective_bytes" => byte_size(objective), "visibility" => thread.visibility},

        now

      )

      # The lane rides in the record only when it is the exceptional one: a

      # granted thread's opened event is byte-for-byte what it always was, and

      # a local thread's transcript says up front that no authority backs it.

      payload = %{"objective_bytes" => byte_size(objective), "visibility" => thread.visibility}

      payload = if Thread.local?(thread), do: Map.put(payload, "lane", thread.lane), else: payload

      insert_event(thread, "thread.opened", payload, now)

    end)

    |> Multi.run(:spawn_event, fn _repo, %{admission: parent, thread: thread} ->

      if parent do

  tokens, or cost, is refused `:parent_authority_exhausted` rather than minted

  authority it cannot use.

  A local-lane thread is refused `:thread_local_lane` the way a terminal

  thread is refused `:thread_terminal`. Its model is a vendor string a local

  runtime serves, not an admitted catalog id, so a grant naming it would be

  authority no provider here can honor — and the lane's whole contract is that

  it holds none (issue #243). The refusal is what keeps the no-provider-key

  and metering invariants true by construction rather than by review.

  This is the fence. In one transaction: the thread is locked and refused

  unless it is open, every active grant naming it is revoked, `generation` is

  bumped, and a fresh grant is minted against the thread — never against a

          {:ok, Thread.t(), Grant.t(), String.t()}

          | {:error,

             :thread_terminal

             | :thread_local_lane

             | :credit_exhausted

             | :parent_authority_exhausted

             | Ecto.Changeset.t()}

  def mint_grant(%Thread{} = thread) do

    Repo.transaction(fn ->

      case locked(thread.id) do

        %Thread{status: "open", lane: "local"} ->

          Repo.rollback(:thread_local_lane)

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

          # Concurrent mints for one account serialize on the owner row

          # (locked after the thread row, always in that order), so each mint

  @objective_bytes 32_768

  @repository_bytes 200

  # Which lane opened the thread. `thread` is the granted lane: the model is a

  # catalog id and the open mints a grant. `local` is the transcript-only lane:

  # the model is the vendor string a local runtime serves, and no grant is ever

  # minted (issue #243).

  @lanes ~w(thread local)

  @default_lane "thread"

  @local_lane "local"

  # The disclosure vocabulary is `OpenAgents.Transparency`'s — `dark`, `pulse`,

  # `ledger`, `glass` (`docs/taxonomy.md`) — and a thread offers the two rungs

  # this surface can enforce, not a fifth word of its own.

    field :objective, :string, redact: true

    field :repository, :string

    field :visibility, :string, default: "dark"

    field :lane, :string, default: "thread"

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

    field :model, :string

    field :reasoning_effort, :string

  @doc "The tier a thread takes when its opener names none: owner-only."

  def default_visibility, do: @default_visibility

  @doc """

  The lanes a thread may be opened on.

  `thread` is the granted lane — the model is admitted against the catalog and

  the open mints a grant. `local` is the transcript-only lane — the model is a

  bounded vendor string and no grant is ever minted, so the thread records a

  run whose model calls never touch this server (issue #243).

  """

  def lanes, do: @lanes

  @doc "The lane a thread takes when its opener names none: the granted one."

  def default_lane, do: @default_lane

  @doc "Whether `thread` is on the transcript-only local lane."

  @spec local?(t()) :: boolean()

  def local?(%__MODULE__{lane: lane}), do: lane == @local_lane

  @doc """

  The tiers that admit a reader who is not the account that opened the thread.

      :permission_profile,

      :repository,

      :visibility,

      :lane,

      :parent_thread_id,

      :issue_id

    ])

    |> validate_inclusion(:reasoning_effort, @reasoning_efforts)

    |> validate_inclusion(:permission_profile, @permission_profiles)

    |> validate_inclusion(:visibility, @visibilities)

    |> validate_inclusion(:lane, @lanes)

    |> foreign_key_constraint(:owner_visitor_id)

    |> foreign_key_constraint(:parent_thread_id)

    |> foreign_key_constraint(:issue_id)

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

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

    |> check_constraint(:visibility, name: :threads_visibility_check)

    |> check_constraint(:lane, name: :threads_lane_check)

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

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

  end

    # and its own code — never a silent substitution.

    "model_unavailable" => {503, "The model's provider is not configured on this deployment"},

    "thread_terminal" => {422, "This thread is terminal and its transcript is closed"},

    # The local lane (THREAD-001, issue #243). A local-lane thread is

    # transcript-only by contract: its model runs on the caller's own machine,

    # so there is no authority to mint and no amount of waiting changes that.

    # Its own code, like `thread_terminal`, because a client that asked for a

    # grant must learn the thread can never hold one, not that it should retry.

    "thread_lane_local" => {422, "This thread is on the local lane and holds no model authority"},

    # Thread disclosure (THREAD-002). Widening a transcript is a consent

    # decision, so a tier that did not take is its own code rather than a field

    # message inside the generic 422: a client that meant to publish and did

  a coding session run its own turns on one model and its delegated children on

  another: it opens a second thread on `ox-alpha` and gets authority for

  `ox-alpha`, with its own budget, rather than borrowing the first thread's.

  The exception is the `local` lane, and it is an exception to the grant, not

  to the record. `"lane": "local"` opens a transcript-only thread: the model is

  the bounded vendor string a local runtime serves (`ollama:...`), checked

  against no catalog and no provider, and the open mints nothing — the response

  carries no grant, and `POST /grants` on the thread is refused with

  `thread_lane_local`. Everything else is an ordinary thread: events append,

  the transcript streams, the tier governs its readers, the open-thread cap

  counts it, `DELETE` ends it. The lane exists so a run whose model calls never

  touch this server still leaves the durable transcript everything rehydrates

  from (issue #243).

  """

  use OpenAgentsWeb, :controller

  @extension "thread.openagents"

  def create(conn, params) do

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

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

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

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

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

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

      open(conn, objective, options ++ repository ++ visibility)

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

      case lane do

        "local" -> open_local(conn, objective, options ++ repository ++ visibility)

        _granted -> open(conn, objective, options ++ repository ++ visibility)

      end

    else

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

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

            errors: %{"thread" => [sentence]}

          )

        {:error, :thread_local_lane} ->

          sentence =

            "This thread is on the local lane and holds no model authority to mint: " <>

              "its model runs on the caller's own machine, and this server only " <>

              "records the transcript. Open a thread without \"lane\": \"local\" " <>

              "for a grant."

          ApiError.refuse(conn, "thread_lane_local",

            message: sentence,

            errors: %{"thread" => [sentence]}

          )

        {:error, :credit_exhausted} ->

          credit_exhausted(conn)

    end

  end

  # The transcript-only open. No mint, so no token, no grant key, and no

  # `credit_exhausted` — an account with nothing left can still record a run

  # its own machine paid for. The quota refusal is the same one the granted

  # lane gets, because the cap counts open threads, not granted ones.

  defp open_local(conn, objective, options) do

    case Threads.open(conn.assigns.current_user, objective, options) do

      {:ok, thread} ->

        conn

        |> put_extension_header()

        |> put_status(:created)

        |> json(%{"thread" => thread_view(thread)})

      {:error, :thread_quota_reached} ->

        quota_reached(conn)

      {:error, %Ecto.Changeset{} = changeset} ->

        ApiError.changeset(conn, changeset)

    end

  end

  # The refusal names the ceiling and the account's own count, so a client that

  # scripts several checkouts learns what to close rather than what to retry.

  defp quota_reached(conn) do

    )

  end

  # The lane decides which door the model goes through. Absent means the

  # granted lane, exactly as every create before the field existed; a value

  # outside the admitted pair is refused rather than folded into a default,

  # because a caller that asked for a transcript-only thread and was minted a

  # grant — or the reverse — has no way to tell.

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

    trimmed = String.trim(value)

    if trimmed in Thread.lanes() do

      {:ok, trimmed}

    else

      {:refused, "lane",

       "#{inspect(trimmed)} is not an admitted lane. " <>

         "Admitted: #{Enum.join(Thread.lanes(), ", ")}."}

    end

  end

  defp lane(%{"lane" => value}) when not is_nil(value) do

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

  end

  defp lane(_params), do: {:ok, Thread.default_lane()}

  defp shape_for("local", params), do: local_execution_shape(params)

  defp shape_for(_granted, params), do: execution_shape(params)

  # The local lane's model is the vendor string a local runtime serves —

  # `ollama:qwen3.8:27b-mtp-q8_0` — so it is bounded, not admitted: no catalog

  # membership and no provider availability, because no grant will ever carry

  # it to a provider (issue #243). It is required rather than defaulted: the

  # catalog default is a model this thread deliberately does not use, and

  # recording it would put a lie at the top of the transcript. The 200-byte

  # bound is the changeset's, the same one every thread's model column holds.

  defp local_execution_shape(params) do

    with {:ok, model} <- local_model(params),

         {:ok, reasoning} <-

           admitted(params, "reasoning", Thread.reasoning_efforts(), Threads.default_reasoning()),

         {:ok, profile} <-

           admitted(

             params,

             "permission_profile",

             Thread.permission_profiles(),

             Threads.default_permission_profile()

           ) do

      {:ok, [lane: "local", model: model, reasoning: reasoning, permission_profile: profile]}

    end

  end

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

    case String.trim(model) do

      "" ->

        {:refused, "model",

         "A local-lane thread records the model its local runtime serves, " <>

           "and the string cannot be blank."}

      trimmed ->

        {:ok, trimmed}

    end

  end

  defp local_model(%{"model" => model}) do

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

  end

  defp local_model(_params) do

    {:refused, "model",

     "A local-lane thread requires a model: the vendor string its local " <>

       "runtime serves, for example ollama:qwen3.8:27b-mtp-q8_0."}

  end

  defp execution_shape(params) do

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

         :ok <- serving(model),

    20260825101934,

    20260825102408,

    20260825113454,

    20260825113459

    20260825113459,

    20260825120000

  ],

  "required_tables": [

    "users",

defmodule OpenAgents.Repo.Migrations.AddLaneToThreads do

  @moduledoc """

  Which lane opened the thread, and therefore whether it can hold authority.

  Two lanes, by check constraint:

    * `thread` — the granted lane. The model is an admitted catalog id and the

      open mints a grant against the account's credit. Default.

    * `local`  — the transcript-only lane. The model is the vendor string a

      local runtime serves (`ollama:...`), bounded but never admitted against

      the catalog, and no grant is ever minted: the thread exists so a local

      run leaves the same durable transcript a granted run does.

  The default is `thread` rather than `NULL` because it is the honest history:

  every thread written before this column existed came through the granted

  lane — its model was catalog-admitted and its open minted a grant — so

  backfilling `thread` records what actually happened rather than an absence

  (issue #243).

  """

  use Ecto.Migration

  def change do

    alter table(:threads) do

      add :lane, :text, null: false, default: "thread"

    end

    create constraint(:threads, :threads_lane_check, check: "lane IN ('thread', 'local')")

  end

end

defmodule OpenAgents.Threads.LocalLaneTest do

  @moduledoc """

  The transcript-only local lane (THREAD-001, issue #243).

  A local-lane thread records a run whose model calls never touch this server:

  its model is the vendor string a local runtime serves, and it holds no

  authority, ever — `mint_grant/1` refuses it the way it refuses a terminal

  thread. Everything else about it is an ordinary thread: the transcript

  appends and broadcasts, the open-thread cap counts it, and cancelling ends

  it. Both halves are proved here, because the lane's contract is exactly that

  pair.

  """

  use OpenAgents.DataCase, async: false

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

  alias OpenAgents.Threads

  alias OpenAgents.Threads.Event

  alias OpenAgents.Threads.Thread

  @vendor_model "ollama:qwen3.8:27b-mtp-q8_0"

  defp owner(key), do: github_user("local-lane-#{key}")

  defp open_local(user, objective) do

    Threads.open(user, objective, lane: "local", model: @vendor_model)

  end

  describe "open/3 on the local lane" do

    test "records the vendor model string and mints nothing" do

      user = owner("open")

      assert {:ok, thread} = open_local(user, "Record a local run")

      assert thread.lane == "local"

      assert thread.status == "open"

      assert thread.model == @vendor_model

      # No mint means no fence bump and no grant row: the thread has never

      # held authority, not merely lost it.

      assert thread.generation == 0

      assert Threads.active_grants(thread) == []

      assert Threads.latest_grant(thread) == nil

    end

    test "the opened event names the lane" do

      user = owner("opened-event")

      {:ok, thread} = open_local(user, "Name the lane up front")

      assert [%Event{event_type: "thread.opened", payload: payload}] = Threads.list_events(thread)

      assert payload["lane"] == "local"

    end

    test "a thread-lane open records no lane in its opened event" do

      user = owner("granted-event")

      {:ok, thread} = Threads.open(user, "The granted lane is unmarked")

      assert thread.lane == Thread.default_lane()

      assert [%Event{event_type: "thread.opened", payload: payload}] = Threads.list_events(thread)

      refute Map.has_key?(payload, "lane")

    end

    test "a lane outside the admitted pair is refused" do

      user = owner("unknown")

      assert {:error, changeset} = Threads.open(user, "Objective", lane: "gym")

      assert %{lane: _} = errors_on(changeset)

    end

    test "the model string is bounded like every thread's model column" do

      user = owner("bound")

      assert {:error, changeset} =

               Threads.open(user, "Objective",

                 lane: "local",

                 model: String.duplicate("a", 201)

               )

      assert %{model: _} = errors_on(changeset)

    end

  end

  describe "mint_grant/1" do

    test "refuses a local-lane thread with :thread_local_lane" do

      user = owner("mint")

      {:ok, thread} = open_local(user, "Ask for authority the lane forbids")

      assert {:error, :thread_local_lane} = Threads.mint_grant(thread)

      # The refusal leaves no trace of an attempt: no fence bump, no grant.

      refused = Threads.get_for_user(user, thread.id)

      assert refused.generation == 0

      assert Threads.active_grants(refused) == []

    end

  end

  describe "the transcript" do

    test "events record and broadcast exactly as thread-lane events do" do

      user = owner("transcript")

      {:ok, thread} = open_local(user, "Stream the local run")

      :ok = Threads.subscribe(thread)

      assert {:ok, updated} =

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

      assert updated.event_count == 2

      assert_receive {:thread_event,

                      %Event{event_type: "turn.user", payload: %{"text" => "Fix the bug"}}}

    end

  end

  describe "admission and the reaper" do

    test "a local-lane thread counts against the open-thread cap" do

      user = owner("cap")

      previous = Application.get_env(:openagents, :maximum_open_threads_per_account)

      Application.put_env(:openagents, :maximum_open_threads_per_account, 1)

      on_exit(fn ->

        Application.put_env(:openagents, :maximum_open_threads_per_account, previous)

      end)

      {:ok, _local} = open_local(user, "Hold the one slot")

      assert {:error, :thread_quota_reached} = Threads.open(user, "One too many")

    end

    test "the reaper leaves an open local-lane thread open" do

      user = owner("reap")

      {:ok, thread} = open_local(user, "Nothing to spend, nothing to reap")

      # The authority-spent sweep closes threads that minted and hold nothing.

      # A local thread never minted, so it is not abandoned authority — it is

      # a transcript still being written.

      _reaped = Threads.reap_expired(user)

      assert Threads.get_for_user(user, thread.id).status == "open"

    end

  end

  test "cancelling ends a local-lane thread like any other" do

    user = owner("cancel")

    {:ok, thread} = open_local(user, "End the record")

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

    assert cancelled.status == "cancelled"

    assert {:error, :thread_terminal} =

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

  end

end

      assert stranger |> post(~p"/api/v1/threads/#{id}/grants") |> json_response(404)

    end

  end

  describe "the local lane" do

    # The transcript-only lane (THREAD-001, issue #243): the model is the

    # vendor string a local runtime serves, checked against no catalog and no

    # provider, and no grant is ever minted. The other half of the contract is

    # below: a create that names no lane is byte-for-byte the granted create

    # it always was.

    @vendor_model "ollama:qwen3.8:27b-mtp-q8_0"

    test "opens a transcript-only thread: no grant, no token, no catalog check",

         %{conn: conn} do

      body =

        conn

        |> put_chat_api_token("thread-local-open")

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

          "objective" => "Record a local run.",

          "lane" => "local",

          "model" => @vendor_model

        })

        |> json_response(201)

      # The response carries the thread and nothing that spends: no grant key,

      # no token anywhere in the body.

      assert Map.keys(body) == ["thread"]

      refute inspect(body) =~ "sig_"

      thread = body["thread"]

      assert thread["status"] == "open"

      # Never minted, so the fence never moved: generation 0, where a granted

      # create returns 1.

      assert thread["generation"] == 0

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

      assert stored.lane == "local"

      assert stored.model == @vendor_model

      assert Repo.get_by(Grant, thread_id: thread["id"]) == nil

    end

    test "a local-lane thread requires a model, and a blank one is refused", %{conn: conn} do

      authenticated = put_chat_api_token(conn, "thread-local-no-model")

      absent =

        authenticated

        |> post(~p"/api/v1/threads", %{"objective" => "No model named.", "lane" => "local"})

        |> json_response(422)

      assert absent["code"] == "validation_failed"

      assert Map.has_key?(absent["errors"], "model")

      blank =

        authenticated

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

          "objective" => "Blank model.",

          "lane" => "local",

          "model" => "   "

        })

        |> json_response(422)

      assert Map.has_key?(blank["errors"], "model")

    end

    test "the vendor string is bounded, not admitted", %{conn: conn} do

      body =

        conn

        |> put_chat_api_token("thread-local-model-bound")

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

          "objective" => "Bound the vendor string.",

          "lane" => "local",

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

        })

        |> json_response(422)

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

    end

    test "a lane outside the admitted pair is refused with a validation error", %{conn: conn} do

      body =

        conn

        |> put_chat_api_token("thread-local-unknown-lane")

        |> post(~p"/api/v1/threads", %{"objective" => "Wrong lane.", "lane" => "gym"})

        |> json_response(422)

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

      assert [message] = body["errors"]["lane"]

      assert message =~ "thread, local"

      not_a_string =

        conn

        |> put_chat_api_token("thread-local-lane-shape")

        |> post(~p"/api/v1/threads", %{"objective" => "Wrong shape.", "lane" => 7})

        |> json_response(422)

      assert Map.has_key?(not_a_string["errors"], "lane")

    end

    test "requesting a grant for a local-lane thread is refused", %{conn: conn} do

      authenticated = put_chat_api_token(conn, "thread-local-mint")

      created =

        authenticated

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

          "objective" => "Ask for authority the lane forbids.",

          "lane" => "local",

          "model" => @vendor_model

        })

        |> json_response(201)

      id = created["thread"]["id"]

      refused = authenticated |> post(~p"/api/v1/threads/#{id}/grants") |> json_response(422)

      assert refused["code"] == "thread_lane_local"

      refute inspect(refused) =~ "sig_"

      # The refusal changed nothing: still open, still ungranted.

      assert Repo.get!(OpenAgents.Threads.Thread, id).status == "open"

      assert Repo.get_by(Grant, thread_id: id) == nil

    end

    test "events record and read back exactly as thread-lane events do", %{conn: conn} do

      authenticated = put_chat_api_token(conn, "thread-local-events")

      created =

        authenticated

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

          "objective" => "Write the transcript here.",

          "lane" => "local",

          "model" => @vendor_model

        })

        |> json_response(201)

      id = created["thread"]["id"]

      recorded =

        authenticated

        |> post(~p"/api/v1/threads/#{id}/events", %{

          "event_type" => "turn.user",

          "payload" => %{"text" => "Fix the bug"}

        })

        |> json_response(201)

      assert recorded["event"]["event_type"] == "turn.user"

      body = authenticated |> get(~p"/api/v1/threads/#{id}/events") |> json_response(200)

      assert Enum.map(body["events"], & &1["event_type"]) == ["thread.opened", "turn.user"]

      # The transcript itself says no authority backs it.

      assert [opened | _rest] = body["events"]

      assert opened["payload"]["lane"] == "local"

    end

    test "DELETE ends a local-lane thread like any other", %{conn: conn} do

      authenticated = put_chat_api_token(conn, "thread-local-delete")

      created =

        authenticated

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

          "objective" => "End the record.",

          "lane" => "local",

          "model" => @vendor_model

        })

        |> json_response(201)

      id = created["thread"]["id"]

      ended = authenticated |> delete(~p"/api/v1/threads/#{id}") |> json_response(200)

      assert ended["thread"]["status"] == "cancelled"

    end

    test "a create without a lane is the granted create it always was", %{conn: conn} do

      authenticated = put_chat_api_token(conn, "thread-local-regression")

      body =

        authenticated

        |> post(~p"/api/v1/threads", %{"objective" => "Unchanged for existing callers."})

        |> json_response(201)

      # The same two keys, the same mint: a grant with a plaintext token, the

      # fence at 1, and the stored lane is the granted one.

      assert Map.keys(body) == ["grant", "thread"]

      assert String.starts_with?(body["grant"]["token"], "sig_")

      assert body["thread"]["generation"] == 1

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

      # And the lane-less create still admits only the catalog: a vendor

      # string that opens a local-lane thread is refused here (PROVIDER-002).

      refused =

        authenticated

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

          "objective" => "A vendor string without the lane.",

          "model" => @vendor_model

        })

        |> json_response(422)

      assert Map.has_key?(refused["errors"], "model")

    end

    test "naming the thread lane explicitly is the granted create too", %{conn: conn} do

      body =

        conn

        |> put_chat_api_token("thread-local-explicit")

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

          "objective" => "The default lane, spelled out.",

          "lane" => "thread"

        })

        |> json_response(201)

      assert String.starts_with?(body["grant"]["token"], "sig_")

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

    end

  end

end