OpenAgents.Tools.WorkspaceWrite,

    OpenAgents.Tools.WorkspaceEdit,

    OpenAgents.Tools.PublishChanges,

    OpenAgents.Tools.OpenPullRequest,

    OpenAgents.Tools.ConversationSearch,

    OpenAgents.Tools.ConversationRead,

    OpenAgents.Tools.MemoryList,

  OpenAgents.Tools.WorkspaceWrite,

  OpenAgents.Tools.WorkspaceEdit,

  OpenAgents.Tools.PublishChanges,

  OpenAgents.Tools.OpenPullRequest,

  OpenAgents.Tools.ConversationSearch,

  OpenAgents.Tools.ConversationRead,

  OpenAgents.Tools.MemoryList,

Merging remains a separate publication operation. Creating or closing a pull request does not update a forge ref.

## Chat tool

The `open_pull_request` chat tool opens a pull request from an accepted repository publication receipt. The tool uses the same shared registry for text, voice, and account API turns.

The tool requires a separate, explicit person approval for opening the pull request. Approval for `publish_changes` does not approve `open_pull_request`. The server also verifies all of the following conditions before it creates or updates a pull request:

- The publication belongs to the same account, conversation, repository workspace, and workspace reference as the tool call.

- The publication state is `accepted`.

- The current forge WAL entry still maps the published branch to the exact published commit.

- The branch uses the `openagents/chat/` namespace and differs from the default branch.

- The repository allows pull requests, and the account can write to the repository.

The tool creates a draft pull request by default. Repeating the tool call for the same open source and base branches returns the existing pull request. If a later accepted publication advances the same source branch, the tool updates the existing pull request with the new publication receipt and commit.

The result includes the pull request number, state, draft state, source and base refs, commit IDs, and receipt references. It does not include access tokens, workspace host paths, or other secrets.

## Browser views

Open `/{owner}/{repo}/pulls` to list a repository's pull requests. Select a pull request to open `/{owner}/{repo}/pulls/{pull_number}` and review its source and target refs, description, and state.

  alias OpenAgents.Accounts.User

  alias OpenAgents.Forge.Browse

  alias OpenAgents.Forge.WAL

  alias OpenAgents.Issues

  alias OpenAgents.PullRequests.PullRequest

  alias OpenAgents.Repo

  alias OpenAgents.Repositories

  alias OpenAgents.Repositories.Repository

  alias OpenAgents.Repositories.RepositoryPublication

  def list(%Repository{id: id}) do

    Repo.all(

           {:ok, head_sha} <- resolve(source, head_ref),

           {:ok, base_sha} <- resolve(target, base_ref),

           {:ok, issue} <- Issues.create_issue(target, attrs, actor),

           {:ok, pr} <- insert(target, source, issue, head_ref, head_sha, base_ref, base_sha) do

           {:ok, pr} <-

             insert(target, source, issue, head_ref, head_sha, base_ref, base_sha, attrs) do

        Repo.preload(pr, [:issue, :head_repository])

      else

        false -> Repo.rollback(:forbidden)

                 actor

               ),

             {:ok, updated} <-

               pr |> PullRequest.changeset(%{state: issue.state}) |> Repo.update() do

               pr

               |> PullRequest.changeset(pull_request_update_attrs(attrs, issue.state))

               |> Repo.update() do

          %{updated | issue: issue}

        else

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

    end

  end

  @doc "Opens or refreshes the draft pull request for an accepted Forge publication."

  def open_from_publication(%RepositoryPublication{} = publication, attrs, %User{} = actor) do

    publication = Repo.preload(publication, :repository)

    repository = publication.repository

    with :ok <- validate_publication(publication, actor),

         :ok <- validate_pull_request_policy(repository, actor),

         {:ok, head_sha, base_sha} <- validate_wal_authority(publication) do

      Repo.transaction(fn ->

        lock_open_head(repository.id, publication.branch, repository.default_branch)

        case open_for_head(repository.id, publication.branch, repository.default_branch) do

          nil ->

            create_from_publication(publication, attrs, actor, head_sha, base_sha)

          %PullRequest{repository_publication_id: id} = pull_request

          when id == publication.id ->

            Repo.preload(pull_request, [:issue, :head_repository, :repository_publication])

          %PullRequest{} = pull_request ->

            refresh_from_publication(pull_request, publication, attrs, actor, head_sha, base_sha)

        end

      end)

    end

  end

  defp validate_publication(%RepositoryPublication{} = publication, %User{} = actor) do

    cond do

      publication.owner_user_id != actor.id ->

        {:error, :publication_scope_mismatch}

      publication.state != "accepted" ->

        {:error, :publication_not_accepted}

      not is_binary(publication.published_oid) ->

        {:error, :publication_not_accepted}

      not is_integer(publication.wal_seq) or publication.wal_seq < 0 ->

        {:error, :publication_receipt_invalid}

      publication.branch == publication.repository.default_branch ->

        {:error, :publication_branch_refused}

      not String.starts_with?(publication.branch || "", "openagents/chat/") ->

        {:error, :publication_branch_refused}

      true ->

        :ok

    end

  end

  defp validate_pull_request_policy(%Repository{pull_requests_enabled: false}, _actor),

    do: {:error, :pull_requests_disabled}

  defp validate_pull_request_policy(repository, actor) do

    if Repositories.writable?(repository, actor), do: :ok, else: {:error, :forbidden}

  end

  defp validate_wal_authority(publication) do

    repository = publication.repository

    published_oid = publication.published_oid

    head_ref = "refs/heads/#{publication.branch}"

    base_ref = "refs/heads/#{repository.default_branch}"

    with {:ok, _generation, index} <- WAL.read_index(repository.storage_key),

         ^published_oid <- WAL.refs(index)[head_ref],

         base_sha when is_binary(base_sha) <- WAL.refs(index)[base_ref],

         %{"refs" => receipt_refs} <- Enum.at(WAL.entries(index), publication.wal_seq),

         ^published_oid <- receipt_refs[head_ref] do

      {:ok, published_oid, base_sha}

    else

      {:error, _reason} -> {:error, :forge_authority_unavailable}

      _ -> {:error, :publication_receipt_stale}

    end

  end

  defp open_for_head(repository_id, head_ref, base_ref) do

    Repo.one(

      from pr in PullRequest,

        where:

          pr.repository_id == ^repository_id and pr.head_repository_id == ^repository_id and

            pr.head_ref == ^head_ref and pr.base_ref == ^base_ref and pr.state == "open",

        lock: "FOR UPDATE"

    )

  end

  defp lock_open_head(repository_id, head_ref, base_ref) do

    key = Enum.join([repository_id, head_ref, base_ref], ":")

    Repo.query!("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", [key])

    :ok

  end

  defp create_from_publication(publication, attrs, actor, head_sha, base_sha) do

    repository = publication.repository

    with {:ok, issue} <- Issues.create_issue(repository, issue_attrs(attrs), actor),

         {:ok, pull_request} <-

           %PullRequest{}

           |> PullRequest.changeset(%{

             repository_id: repository.id,

             issue_id: issue.id,

             head_repository_id: repository.id,

             repository_publication_id: publication.id,

             opened_by_user_id: actor.id,

             conversation_id: publication.conversation_id,

             head_ref: publication.branch,

             head_sha: head_sha,

             base_ref: repository.default_branch,

             base_sha: base_sha,

             draft: Map.get(attrs, "draft", true)

           })

           |> Repo.insert() do

      Repo.preload(pull_request, [:issue, :head_repository, :repository_publication])

    else

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

    end

  end

  defp refresh_from_publication(pull_request, publication, attrs, actor, head_sha, base_sha) do

    pull_request = Repo.preload(pull_request, [:issue, :repository_publication])

    with :ok <- validate_existing_publication_scope(pull_request, publication, actor),

         {:ok, issue} <- Issues.update_issue(pull_request.issue, issue_attrs(attrs), actor),

         {:ok, updated} <-

           pull_request

           |> PullRequest.changeset(%{

             repository_publication_id: publication.id,

             head_sha: head_sha,

             base_sha: base_sha,

             draft: Map.get(attrs, "draft", true),

             conversation_id: publication.conversation_id

           })

           |> Repo.update() do

      %{Repo.preload(updated, [:head_repository, :repository_publication]) | issue: issue}

    else

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

    end

  end

  defp validate_existing_publication_scope(pull_request, publication, actor) do

    previous_publication = pull_request.repository_publication

    cond do

      pull_request.opened_by_user_id != actor.id ->

        {:error, :publication_scope_mismatch}

      pull_request.conversation_id != publication.conversation_id ->

        {:error, :publication_scope_mismatch}

      is_nil(previous_publication) or

          previous_publication.workspace_ref != publication.workspace_ref ->

        {:error, :publication_workspace_mismatch}

      true ->

        :ok

    end

  end

  defp issue_attrs(attrs), do: Map.take(attrs, ["title", "body"])

  defp pull_request_update_attrs(attrs, state) do

    %{state: state}

    |> maybe_put(:draft, Map.fetch(attrs, "draft"))

  end

  defp maybe_put(attrs, _key, :error), do: attrs

  defp maybe_put(attrs, key, {:ok, value}), do: Map.put(attrs, key, value)

  defp source_repository(attrs, actor) do

    case Map.get(attrs, "head_repository") do

      value when is_binary(value) ->

    end

  end

  defp insert(target, source, issue, head_ref, head_sha, base_ref, base_sha) do

  defp insert(target, source, issue, head_ref, head_sha, base_ref, base_sha, attrs) do

    %PullRequest{}

    |> PullRequest.changeset(%{

      repository_id: target.id,

      head_ref: head_ref,

      head_sha: head_sha,

      base_ref: base_ref,

      base_sha: base_sha

      base_sha: base_sha,

      draft: Map.get(attrs, "draft", true)

    })

    |> Repo.insert()

  end

    field :base_ref, :string

    field :base_sha, :string

    field :state, :string, default: "open"

    field :draft, :boolean, default: true

    belongs_to :repository_publication, OpenAgents.Repositories.RepositoryPublication

    belongs_to :opened_by_user, OpenAgents.Accounts.User

    field :conversation_id, :binary_id

    field :merged_at, :utc_datetime_usec

    belongs_to :merged_by_user, OpenAgents.Accounts.User

    field :merge_commit_sha, :string

      :head_sha,

      :base_ref,

      :base_sha,

      :state

      :state,

      :draft,

      :conversation_id

    ])

    |> put_programmatic_change(attrs, :repository_id)

    |> put_programmatic_change(attrs, :issue_id)

    |> put_programmatic_change(attrs, :head_repository_id)

    |> put_programmatic_change(attrs, :repository_publication_id)

    |> put_programmatic_change(attrs, :opened_by_user_id)

    |> validate_required([

      :repository_id,

      :issue_id,

    |> validate_length(:base_ref, min: 1, max: 255)

    |> validate_inclusion(:state, ~w(open closed))

    |> unique_constraint(:issue_id)

    |> unique_constraint(:repository_publication_id)

    |> unique_constraint([:repository_id, :head_repository_id, :head_ref, :base_ref],

      name: :pull_requests_one_open_head_base_index

    )

                 "memory.write",

                 "module.discover",

                 "repository.read",

                 "repository.write",

                 "scv.deploy",

                 "work.delegate"

               ])

defmodule OpenAgents.Tools.OpenPullRequest do

  @moduledoc "Opens an approved draft pull request from a Forge publication receipt."

  @behaviour OpenAgents.Tools.Tool

  alias OpenAgents.Accounts.User

  alias OpenAgents.Modules.Metadata

  alias OpenAgents.PullRequests

  alias OpenAgents.Repositories.RepositoryPublication

  alias OpenAgents.Repo

  alias OpenAgents.Tools.{ExecutionResult, Tool}

  @impl true

  def specification do

    %Tool{

      module_id: "openagents.tool.open_pull_request.v1",

      name: "open_pull_request",

      version: 1,

      description:

        "Open or refresh a draft pull request from an accepted repository publication receipt. " <>

          "The server loads and validates the receipt, repository policy, branch, commit, and Forge WAL authority.",

      input_schema: %{

        "type" => "object",

        "properties" => %{

          "publication_receipt_ref" => %{

            "type" => "string",

            "pattern" => "^repository-publication:[0-9a-f-]{36}$"

          },

          "title" => %{"type" => "string", "minLength" => 1, "maxLength" => 256},

          "body" => %{"type" => "string", "maxLength" => 65_536},

          "draft" => %{"type" => "boolean", "default" => true}

        },

        "required" => ["publication_receipt_ref", "title", "body"],

        "additionalProperties" => false

      },

      output_schema: %{"type" => "object", "properties" => %{}, "additionalProperties" => true},

      side_effect: :external_effect,

      required_scope: "browser_conversation",

      required_authority: "repository.write",

      executor: %{

        id: "openagents.forge.pull_requests",

        disclosure: "the OpenAgents pull request service, using an accepted Forge publication"

      },

      maintainer: "OpenAgents",

      attribution: ["OpenAgentsInc/openagents.com"],

      policy_facets: %{

        "privacy" => "browser_conversation",

        "residency" => "host",

        "consent" => "approved_publication_pull_request"

      },

      module_metadata:

        Metadata.first_party("repository.write", "browser_conversation",

          effect: :external_effect,

          privacy: "browser_conversation",

          residency: "host",

          surfaces: ["text", "voice"],

          approval_class: "external_confirmation",

          approval_enforcement: "host_receipt"

        ),

      timeout_ms: 30_000,

      maximum_input_bytes: 72_000,

      maximum_output_bytes: 16_384,

      implementation: __MODULE__

    }

  end

  @doc "Builds the separate person approval required to open a pull request."

  def approval_receipt(scope_ref, approval_ref)

      when is_binary(scope_ref) and is_binary(approval_ref) do

    %{

      "schema" => "sarah.module_approval.v1",

      "approval_class" => "external_confirmation",

      "module_id" => specification().module_id,

      "version" => specification().version,

      "scope_ref" => scope_ref,

      "explicit" => true,

      "actor_type" => "person",

      "receipt_ref" => approval_ref

    }

  end

  @impl true

  def execute(%{"publication_receipt_ref" => receipt_ref} = arguments, context) do

    with {:ok, publication_id} <- parse_receipt_ref(receipt_ref),

         %RepositoryPublication{} = publication <- Repo.get(RepositoryPublication, publication_id),

         :ok <- validate_context(publication, context),

         %User{} = actor <- Repo.get(User, context.owner_user_id),

         {:ok, pull_request} <- PullRequests.open_from_publication(publication, arguments, actor) do

      result = result(pull_request)

      {:ok,

       %ExecutionResult{

         result: result,

         target_receipt_refs: [

           receipt_ref,

           "pull-request:#{pull_request.id}",

           "issue:#{pull_request.repository_id}:#{pull_request.issue.number}"

         ]

       }}

    else

      nil -> {:error, :publication_receipt_not_found}

      {:error, reason} -> {:error, reason}

      _ -> {:error, :publication_scope_mismatch}

    end

  end

  defp parse_receipt_ref("repository-publication:" <> publication_id) do

    case Ecto.UUID.cast(publication_id) do

      {:ok, id} -> {:ok, id}

      :error -> {:error, :publication_receipt_invalid}

    end

  end

  defp parse_receipt_ref(_receipt_ref), do: {:error, :publication_receipt_invalid}

  defp validate_context(publication, context) do

    workspace = context.workspace || %{}

    cond do

      publication.owner_user_id != context.owner_user_id ->

        {:error, :publication_scope_mismatch}

      publication.conversation_id != context.conversation_id ->

        {:error, :publication_scope_mismatch}

      workspace["repository_id"] != publication.repository_id ->

        {:error, :publication_workspace_mismatch}

      workspace["workspace_ref"] != publication.workspace_ref ->

        {:error, :publication_workspace_mismatch}

      true ->

        :ok

    end

  end

  defp result(pull_request) do

    %{

      "schema" => "openagents.pull_request_opened.v1",

      "id" => pull_request.id,

      "number" => pull_request.issue.number,

      "state" => pull_request.state,

      "draft" => pull_request.draft,

      "title" => pull_request.issue.title,

      "head" => %{"ref" => pull_request.head_ref, "oid" => pull_request.head_sha},

      "base" => %{"ref" => pull_request.base_ref, "oid" => pull_request.base_sha},

      "publication_receipt_ref" =>

        "repository-publication:#{pull_request.repository_publication_id}",

      "receipt" => %{

        "schema" => "openagents.pull_request_receipt.v1",

        "receipt_ref" => "pull-request:#{pull_request.id}"

      }

    }

  end

end

              :module_approval_required,

              :memory_consent_required,

              :memory_consent_mismatch,

              :memory_policy_refused

              :memory_policy_refused,

              :publication_scope_mismatch,

              :publication_workspace_mismatch,

              :publication_not_accepted,

              :publication_receipt_invalid,

              :publication_receipt_stale,

              :publication_branch_refused,

              :pull_requests_disabled,

              :forbidden

            ],

       do: "refused"

  defp error_message(:forge_push_unconfigured),

    do: "This deployment has no forge push endpoint configured."

  defp error_message(:publication_receipt_invalid),

    do: "The repository publication receipt is invalid."

  defp error_message(:publication_receipt_not_found),

    do: "The repository publication receipt does not exist."

  defp error_message(:publication_scope_mismatch),

    do: "The repository publication does not belong to this account and conversation."

  defp error_message(:publication_workspace_mismatch),

    do: "The repository publication does not belong to this conversation workspace."

  defp error_message(:publication_not_accepted),

    do: "The repository publication has not been accepted by Forge."

  defp error_message(:publication_receipt_stale),

    do: "The published branch no longer matches the exact Forge publication receipt."

  defp error_message(:publication_branch_refused),

    do: "A pull request must use an OpenAgents chat publication branch."

  defp error_message(:forge_authority_unavailable),

    do: "Forge could not verify the authoritative branch state."

  defp error_message(:pull_requests_disabled),

    do: "Pull requests are disabled for this repository."

  defp error_message(:forbidden),

    do: "Your account cannot open a pull request in this repository."

  defp error_message({:workspace_clone_failed, _detail}),

    do: "Cloning the job workspace from the forge failed."

      title: pr.issue.title,

      body: pr.issue.body,

      state: pr.issue.state,

      draft: pr.draft,

      user: pr.issue.user,

      merged: not is_nil(pr.merged_at),

      head: %{

    20260822234211,

    20260823000143,

    20260823010819,

    20260823013135

    20260823013135,

    20260823021021

  ],

  "required_tables": [

    "users",

defmodule OpenAgents.Repo.Migrations.AddWorkspacePublicationToPullRequests do

  use Ecto.Migration

  def change do

    alter table(:pull_requests) do

      add :draft, :boolean, null: false, default: true

      add :repository_publication_id,

          references(:repository_publications, type: :binary_id, on_delete: :restrict)

      add :opened_by_user_id, references(:users, type: :binary_id, on_delete: :restrict)

      add :conversation_id, :binary_id

    end

    create unique_index(:pull_requests, [:repository_publication_id],

             where: "repository_publication_id IS NOT NULL"

           )

  end

end

defmodule OpenAgents.Tools.OpenPullRequestTest do

  use OpenAgents.DataCase, async: false

  alias OpenAgents.Forge.WAL

  alias OpenAgents.PullRequests.PullRequest

  alias OpenAgents.Repositories.RepositoryPublication

  alias OpenAgents.Tools.{ExecutionContext, OpenPullRequest, Registry, Runner}

  setup do

    wal_dir =

      Path.join(System.tmp_dir!(), "open-pull-request-wal-#{System.unique_integer([:positive])}")

    previous_wal_dir = Application.get_env(:openagents, :forge_wal_dir)

    Application.put_env(:openagents, :forge_wal_dir, wal_dir)

    user = repository_user_fixture("pull-request-tool-owner")

    repository = repository_with_member_fixture(user)

    conversation_id = Ecto.UUID.generate()

    workspace_ref = "workspace:#{Ecto.UUID.generate()}"

    branch = "openagents/chat/#{conversation_id}"

    base_oid = String.duplicate("a", 40)

    head_oid = String.duplicate("b", 40)

    write_wal(repository.storage_key, [

      %{"refs/heads/main" => base_oid, "refs/heads/#{branch}" => head_oid}

    ])

    publication =

      publication_fixture(repository, user, conversation_id, workspace_ref, branch, head_oid, 0)

    context = %ExecutionContext{

      scope: "browser_conversation",

      scope_ref: "conversation:#{conversation_id}",

      authorities: MapSet.new(["repository.write"]),

      surface: "text",

      owner_user_id: user.id,

      owner_visitor_id: user.id,

      conversation_id: conversation_id,

      workspace: %{

        "type" => "repository_workspace",

        "repository_id" => repository.id,

        "workspace_ref" => workspace_ref

      }

    }

    on_exit(fn ->

      if previous_wal_dir,

        do: Application.put_env(:openagents, :forge_wal_dir, previous_wal_dir),

        else: Application.delete_env(:openagents, :forge_wal_dir)

      File.rm_rf!(wal_dir)

    end)

    %{

      branch: branch,

      context: context,

      head_oid: head_oid,

      publication: publication,

      repository: repository,

      user: user

    }

  end

  test "requires a separate exact approval and opens one draft pull request", %{context: context} do

    {:ok, snapshot} = Registry.build([OpenPullRequest])

    call = call("open-1", context)

    assert {:ok, refused} = Runner.run(snapshot, call, context)

    assert refused["status"] == "refused"

    assert refused["error"]["code"] == "module_approval_required"

    publication_approval = %{

      "schema" => "sarah.module_approval.v1",

      "approval_class" => "external_confirmation",

      "module_id" => "openagents.tool.publish_changes.v1",

      "version" => 1,

      "scope_ref" => context.scope_ref,

      "explicit" => true,

      "actor_type" => "person",

      "receipt_ref" => "approval:publication"

    }

    assert {:ok, still_refused} =

             Runner.run(snapshot, call, %{context | approval_receipts: [publication_approval]})

    assert still_refused["error"]["code"] == "module_approval_required"

    context = approve(context)

    assert {:ok, opened} = Runner.run(snapshot, call, context)

    assert opened["status"] == "succeeded"

    assert opened["result"]["state"] == "open"

    assert opened["result"]["draft"]

    assert opened["result"]["head"]["ref"] =~ "openagents/chat/"

    assert length(Repo.all(PullRequest)) == 1

    retry_call = %{call | call_id: "open-2"}

    assert {:ok, retried} = Runner.run(snapshot, retry_call, context)

    assert retried["result"]["id"] == opened["result"]["id"]

    assert length(Repo.all(PullRequest)) == 1

  end

  test "refreshes the existing open pull request from a later exact WAL publication", %{

    branch: branch,

    context: context,

    publication: publication,

    repository: repository,

    user: user

  } do

    {:ok, snapshot} = Registry.build([OpenPullRequest])

    context = approve(context)

    assert {:ok, first} = Runner.run(snapshot, call("open-first", context), context)

    next_oid = String.duplicate("c", 40)

    base_oid = String.duplicate("a", 40)

    write_wal(repository.storage_key, [

      %{"refs/heads/main" => base_oid, "refs/heads/#{branch}" => publication.published_oid},

      %{"refs/heads/main" => base_oid, "refs/heads/#{branch}" => next_oid}

    ])

    later =

      publication_fixture(

        repository,

        user,

        context.conversation_id,

        publication.workspace_ref,

        branch,

        next_oid,

        1

      )

    second_call =

      call("open-later", context, later)

      |> put_in(

        [:raw_arguments],

        Jason.encode!(%{

          "publication_receipt_ref" => "repository-publication:#{later.id}",

          "title" => "Updated pull request",

          "body" => "Updated body",

          "draft" => false

        })

      )

    assert {:ok, refreshed} = Runner.run(snapshot, second_call, context)

    assert refreshed["result"]["id"] == first["result"]["id"]

    assert refreshed["result"]["head"]["oid"] == next_oid

    refute refreshed["result"]["draft"]

    stored = Repo.one!(PullRequest) |> Repo.preload(:issue)

    assert stored.head_sha == next_oid

    assert stored.repository_publication_id == later.id

    assert stored.issue.title == "Updated pull request"

  end

  test "refuses another account, conversation, or workspace", %{

    context: context

  } do

    {:ok, snapshot} = Registry.build([OpenPullRequest])

    call = call("open-wrong-scope", context)

    another_user = repository_user_fixture("pull-request-tool-other-account")

    wrong_account =

      context

      |> Map.put(:owner_user_id, another_user.id)

      |> approve()

    assert {:ok, account_refused} = Runner.run(snapshot, call, wrong_account)

    assert account_refused["status"] == "refused"

    assert account_refused["error"]["code"] == "publication_scope_mismatch"

    conversation_id = Ecto.UUID.generate()

    wrong_conversation =

      context

      |> Map.put(:conversation_id, conversation_id)

      |> Map.put(:scope_ref, "conversation:#{conversation_id}")

      |> approve()

    assert {:ok, conversation_refused} = Runner.run(snapshot, call, wrong_conversation)

    assert conversation_refused["status"] == "refused"

    assert conversation_refused["error"]["code"] == "publication_scope_mismatch"

    wrong_workspace =

      context

      |> put_in([Access.key(:workspace), "workspace_ref"], "workspace:other")

      |> approve()

    assert {:ok, workspace_refused} = Runner.run(snapshot, call, wrong_workspace)

    assert workspace_refused["status"] == "refused"

    assert workspace_refused["error"]["code"] == "publication_workspace_mismatch"

  end

  test "refuses disabled policy and stale WAL receipts", %{

    context: context,

    publication: publication,

    repository: repository

  } do

    {:ok, snapshot} = Registry.build([OpenPullRequest])

    context = approve(context)

    call = call("open-refused", context)

    repository

    |> Ecto.Changeset.change(pull_requests_enabled: false)

    |> Repo.update!()

    assert {:ok, disabled} = Runner.run(snapshot, call, context)

    assert disabled["status"] == "refused"

    assert disabled["error"]["code"] == "pull_requests_disabled"

    repository

    |> then(&Repo.get!(OpenAgents.Repositories.Repository, &1.id))

    |> Ecto.Changeset.change(pull_requests_enabled: true)

    |> Repo.update!()

    stale_oid = String.duplicate("d", 40)

    write_wal(repository.storage_key, [

      %{

        "refs/heads/main" => String.duplicate("a", 40),

        "refs/heads/#{publication.branch}" => stale_oid

      }

    ])

    assert {:ok, stale} = Runner.run(snapshot, call, context)

    assert stale["status"] == "refused"

    assert stale["error"]["code"] == "publication_receipt_stale"

  end

  defp approve(context) do

    receipt = OpenPullRequest.approval_receipt(context.scope_ref, "approval:open-pull-request")

    %{context | approval_receipts: [receipt]}

  end

  defp call(call_id, context, publication \\ nil) do

    publication = publication || publication_for(context)

    %{

      call_id: call_id,

      name: "open_pull_request",

      version: 1,

      raw_arguments:

        Jason.encode!(%{

          "publication_receipt_ref" => "repository-publication:#{publication.id}",

          "title" => "Open a draft pull request",

          "body" => "Review the published chat workspace."

        })

    }

  end

  defp publication_for(context) do

    Repo.one!(

      from publication in RepositoryPublication,

        where: publication.conversation_id == ^context.conversation_id,

        order_by: [asc: publication.inserted_at],

        limit: 1

    )

  end

  defp publication_fixture(repository, user, conversation_id, workspace_ref, branch, oid, wal_seq) do

    digest = :crypto.hash(:sha256, "#{conversation_id}:#{wal_seq}") |> Base.encode16(case: :lower)

    %RepositoryPublication{}

    |> RepositoryPublication.changeset(%{

      repository_id: repository.id,

      owner_user_id: user.id,

      conversation_id: conversation_id,

      workspace_ref: workspace_ref,

      idempotency_key: digest,

      argument_digest: digest,

      message: "Publish chat workspace",

      branch: branch,

      published_oid: oid,

      state: "accepted",

      wal_seq: wal_seq,

      result: %{"receipt" => %{"wal_seq" => wal_seq, "oid" => oid}}

    })

    |> Repo.insert!()

  end

  defp write_wal(storage_key, refs_by_sequence) do

    WAL.delete_repo(storage_key)

    index =

      Enum.with_index(refs_by_sequence)

      |> Enum.reduce(WAL.new_index(), fn {refs, sequence}, index ->

        WAL.append_entry(index, %{

          "seq" => sequence,

          "object" =>

            "entries/#{String.pad_leading(Integer.to_string(sequence), 8, "0")}-000000000000",

          "refs" => refs,

          "principal" => "test",

          "pushed_at" => "2026-08-23T00:00:00Z"

        })

      end)

    assert {:ok, _generation} = WAL.cas_index(storage_key, :none, index)

  end

end

             "number" => number,

             "title" => "Add pull request support",

             "state" => "open",

             "draft" => true,

             "head" => %{"ref" => "main"},

             "base" => %{"ref" => "main"}

           } = json_response(create_conn, 201)

    update_conn =

      patch(conn, "/api/v3/repos/#{target.owner}/#{target.name}/pulls/#{number}", %{

        title: "Ship pull request support",

        state: "closed"

        state: "closed",

        draft: false

      })

    assert %{

             "number" => ^number,

             "title" => "Ship pull request support",

             "state" => "closed"

             "state" => "closed",

             "draft" => false

           } = json_response(update_conn, 200)

  end