generators: [timestamp_type: :utc_datetime],

  runtime_environment: :development,

  staging_gate: 0,

  staging_cleanup_enabled: false,

  production_deploy_enabled: false,

  build_revision: "image",

  image_digest: nil,

  staging_gate = parse_integer.("OPENAGENTS_STAGING_GATE", 0..16)

  production_deploy_enabled = parse_boolean.("OPENAGENTS_PRODUCTION_DEPLOY_ENABLED")

  staging_cleanup_enabled = parse_boolean.("OPENAGENTS_STAGING_CLEANUP_ENABLED")

  secure_cookies = parse_boolean.("OPENAGENTS_SECURE_COOKIES")

  migrate_on_boot = parse_boolean.("OPENAGENTS_MIGRATE_ON_BOOT")

  host = required_text.("PHX_HOST")

  config :openagents,

    runtime_environment: runtime_environment,

    staging_gate: staging_gate,

    staging_cleanup_enabled: staging_cleanup_enabled,

    production_deploy_enabled: production_deploy_enabled,

    build_revision: OpenAgents.BuildInfo.revision(),

    image_digest: optional_text.("OPENAGENTS_IMAGE_DIGEST"),

Date: 2026-08-20

Status: In progress; Gates 0–11 complete locally, Gate 12 cloud isolation proof pending

Status: In progress; Gates 0–11 complete locally, Gate 12 cloud and live cleanup proof pending

## Outcome

  minimal private deployer BEAM node performs exact instance metadata updates

  and resets under the only identity that holds those permissions; it does not

  start the application, join Ra, open HTTP, or connect to PostgreSQL.

- Added an immutable, manifest-scoped staging cleanup registry and one operator

  command. The harness must register each disposable account, repository,

  recording, and product machine before use. Cleanup refuses canonical or

  administrator resources, online machines, active work or conversations, and

  account-owned resources outside the manifest. It deletes one run in a

  transaction and reports only bounded counts.

The local infrastructure definition and mocked safety tests pass. The cloud

apply, isolation receipt, and one-command disposable-run cleanup proof remain

open; cloud work is blocked until the operator refreshes the expired Google

Cloud CLI and Application Default Credentials. No staging or production cloud

resource changed during this implementation step. See the [isolated staging

apply, isolation receipt, and live disposable-run cleanup proof remain open;

cloud work is blocked until the operator refreshes the expired Google Cloud CLI

and Application Default Credentials. No staging or production cloud resource

changed during this implementation step. See the [isolated staging

infrastructure](../infra/staging/README.md) for the exact bootstrap, plan,

apply, and validation procedure.

apply, validation, and cleanup procedures.

## Gate 13: Deploy to staging reproducibly

| --- | --- | --- |

| Release | `OPENAGENTS_ENVIRONMENT` | `staging`; `production` remains separately locked |

| Release | `OPENAGENTS_STAGING_GATE` | Integer `0` through `16`; feature admission is tied to it |

| Release | `OPENAGENTS_STAGING_CLEANUP_ENABLED` | `true` only at staging Gate 12 or later; always `false` elsewhere |

| Release | `OPENAGENTS_PRODUCTION_DEPLOY_ENABLED` | `false` until a later production decision |

| Release | `OPENAGENTS_IMAGE_DIGEST` | Exact `sha256:` image digest at staging Gate 12 and later; empty before that gate |

| Endpoint | `PHX_HOST` | Exactly `stage.openagents.com` in staging |

`.git/openagents/staging-isolation/<full-sha>.json`. Do not commit Terraform

plans, state, credentials, project inventory, IP addresses, or secret values.

## Clean up a disposable test run

Give each staging test run a unique lowercase identifier with 8 through 64

letters, numbers, and hyphens. Before the test harness uses a disposable

resource, register its database ID under that run:

```elixir

OpenAgents.StagingCleanup.register(run_id, :account, user.id)

OpenAgents.StagingCleanup.register(run_id, :repository, repository.id)

OpenAgents.StagingCleanup.register(run_id, :recording, recording.id)

OpenAgents.StagingCleanup.register(run_id, :machine, machine.id)

```

Set `OPENAGENTS_STAGING_CLEANUP_ENABLED=true` only for the staging release at

Gate 12 or later. The registration manifest is immutable. A resource can

belong to only one run, and the cleanup command does not infer targets from

names, timestamps, owners, or labels.

Preview content-free counts before deletion:

```sh

ops/staging/cleanup-run.sh gate14-20260820-0001 check

```

Apply the same bounded manifest once you confirm the counts:

```sh

ops/staging/cleanup-run.sh gate14-20260820-0001 --apply

```

The command targets a fixed staging fleet node through Identity-Aware Proxy.

It refuses the canonical repository, administrator accounts, online machines,

machines with queued or running work, active text turns or voice sessions, and

accounts that own an unregistered project, machine, or recording. It performs

all database deletions in one transaction and removes the manifest only after

the transaction succeeds. An interrupted or refused cleanup remains safe to

preview and retry.

The `repository` and `machine` kinds refer to product database records. This

command never deletes Compute Engine fleet instances, Cloud SQL, Artifact

Registry images, Terraform resources, or production data. Quiesce the test

harness before you apply cleanup so it cannot create new run data concurrently.

## Complete Gate 12

Gate 12 remains incomplete until the cloud apply, isolation validator, and

manifest-scoped disposable-run cleanup command are proven. Do not populate

Gate 12 remains incomplete until the cloud apply, isolation validator, and a

live execution of the manifest-scoped disposable-run cleanup command are

proven. Do not populate

secrets, push an image, change DNS for `stage.openagents.com`, or deploy a

candidate as part of the infrastructure apply. Gate 13 performs those steps on

one exact, locally gated SHA after a separate review.

         :ok <- validate_database(settings, environment),

         :ok <- validate_github(settings, environment),

         {:ok, features} <- validate_features(settings, environment, staging_gate),

         :ok <- validate_staging_cleanup(settings, environment, staging_gate),

         :ok <- validate_providers(settings, features),

         :ok <- validate_release_identity(settings, environment, staging_gate),

         {:ok, allowlist, examples} <- validate_forge(settings, environment, features),

  defp validate_production_lock(_settings, _environment), do: :ok

  defp validate_staging_cleanup(settings, environment, staging_gate) do

    case Map.get(settings, :staging_cleanup_enabled) do

      false ->

        :ok

      true when environment == :staging and staging_gate >= 12 ->

        :ok

      true ->

        error(:staging_cleanup_enabled, "is admitted only in staging at Gate 12 or later")

      _invalid ->

        error(:staging_cleanup_enabled, "must be a boolean")

    end

  end

  defp validate_release_identity(settings, environment, staging_gate) do

    required? = environment == :production or (environment == :staging and staging_gate >= 12)

    revision = Map.get(settings, :build_revision)

defmodule OpenAgents.Staging.DisposableResource do

  @moduledoc false

  use Ecto.Schema

  import Ecto.Changeset

  @primary_key {:id, :binary_id, autogenerate: true}

  @timestamps_opts [type: :utc_datetime_usec, updated_at: false]

  @kinds ~w(account machine recording repository)

  schema "staging_disposable_resources" do

    field :run_id, :string

    field :kind, :string

    field :resource_id, Ecto.UUID

    timestamps()

  end

  @type t :: %__MODULE__{

          id: Ecto.UUID.t(),

          run_id: String.t(),

          kind: String.t(),

          resource_id: Ecto.UUID.t(),

          inserted_at: DateTime.t()

        }

  def create_changeset(resource, attributes) do

    resource

    |> cast(attributes, [:run_id, :kind, :resource_id])

    |> validate_required([:run_id, :kind, :resource_id])

    |> validate_format(:run_id, ~r/\A[a-z0-9][a-z0-9-]{7,63}\z/)

    |> validate_inclusion(:kind, @kinds)

    |> unique_constraint([:kind, :resource_id])

    |> check_constraint(:run_id, name: :staging_disposable_run_id_check)

    |> check_constraint(:kind, name: :staging_disposable_kind_check)

  end

end

defmodule OpenAgents.StagingCleanup do

  @moduledoc """

  Registers and removes resources created by one isolated staging test run.

  Cleanup can touch only resources that a harness registered under a bounded

  run ID. Registration is immutable, and cleanup fails closed for the canonical

  repository, administrator accounts, online machines, active work, and account

  data that still has an active turn or voice session.

  """

  import Ecto.Query

  alias OpenAgents.Accounts

  alias OpenAgents.Accounts.User

  alias OpenAgents.Conversations

  alias OpenAgents.Conversations.{Conversation, Visitor}

  alias OpenAgents.DataRights

  alias OpenAgents.Machines.Machine

  alias OpenAgents.ProjectFields.ProjectField

  alias OpenAgents.ProjectItems.ProjectItem

  alias OpenAgents.Projects.Project

  alias OpenAgents.Repo

  alias OpenAgents.Repositories.Repository

  alias OpenAgents.Staging.DisposableResource

  alias OpenAgents.Voice.{Recording, Session}

  alias OpenAgents.Work.Job

  @run_id_pattern ~r/\A[a-z0-9][a-z0-9-]{7,63}\z/

  @kinds [:account, :machine, :recording, :repository]

  @kind_names Map.new(@kinds, &{&1, Atom.to_string(&1)})

  @schemas %{

    account: User,

    machine: Machine,

    recording: Recording,

    repository: Repository

  }

  @type kind :: :account | :machine | :recording | :repository

  @doc "Registers one disposable resource before a staging harness uses it."

  @spec register(String.t(), kind(), Ecto.UUID.t()) ::

          {:ok, DisposableResource.t()} | {:error, atom() | Ecto.Changeset.t()}

  def register(run_id, kind, resource_id)

      when kind in @kinds and is_binary(run_id) and is_binary(resource_id) do

    with :ok <- ensure_admitted(),

         :ok <- validate_run_id(run_id),

         {:ok, cast_id} <- cast_resource_id(resource_id),

         {:ok, resource} <- fetch_resource(kind, cast_id),

         :ok <- validate_resource(kind, resource) do

      Repo.transaction(fn ->

        lock_run(run_id)

        %DisposableResource{}

        |> DisposableResource.create_changeset(%{

          run_id: run_id,

          kind: Map.fetch!(@kind_names, kind),

          resource_id: cast_id

        })

        |> Repo.insert()

        |> case do

          {:ok, registration} -> registration

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

        end

      end)

      |> normalize_transaction()

    end

  end

  def register(_run_id, _kind, _resource_id), do: {:error, :invalid_registration}

  @doc "Returns content-free registration counts for one run."

  @spec preview(String.t()) :: {:ok, map()} | {:error, atom()}

  def preview(run_id) when is_binary(run_id) do

    with :ok <- ensure_admitted(),

         :ok <- validate_run_id(run_id) do

      {:ok, %{registered: registration_counts(run_id)}}

    end

  end

  def preview(_run_id), do: {:error, :invalid_run_id}

  @doc "Removes every resource registered to one run in a single transaction."

  @spec cleanup(String.t()) :: {:ok, map()} | {:error, atom() | tuple()}

  def cleanup(run_id) when is_binary(run_id) do

    with :ok <- ensure_admitted(),

         :ok <- validate_run_id(run_id) do

      Repo.transaction(fn ->

        lock_run(run_id)

        registrations =

          Repo.all(

            from(resource in DisposableResource,

              where: resource.run_id == ^run_id,

              order_by: [asc: resource.kind, asc: resource.resource_id],

              lock: "FOR UPDATE"

            )

          )

        registered = counts(registrations)

        targets = targets(registrations)

        validate_cleanup_targets!(targets)

        deleted = %{

          recording: delete_recordings(targets.recording),

          repository: delete_repositories(targets.repository),

          machine: delete_machines(targets.machine),

          account: delete_accounts(targets.account)

        }

        {_registration_count, nil} =

          Repo.delete_all(from(resource in DisposableResource, where: resource.run_id == ^run_id))

        %{registered: registered, deleted: stringify_counts(deleted)}

      end)

      |> normalize_transaction()

    end

  end

  def cleanup(_run_id), do: {:error, :invalid_run_id}

  @doc "Returns one bounded JSON result for the staging operator command."

  @spec command!(String.t(), String.t()) :: String.t()

  def command!(run_id, "check") do

    case preview(run_id) do

      {:ok, result} -> encode_result(run_id, "checked", result)

      {:error, reason} -> raise "staging cleanup refused: #{bounded_reason(reason)}"

    end

  end

  def command!(run_id, "apply") do

    case cleanup(run_id) do

      {:ok, result} -> encode_result(run_id, "cleaned", result)

      {:error, reason} -> raise "staging cleanup refused: #{bounded_reason(reason)}"

    end

  end

  def command!(_run_id, _mode), do: raise("staging cleanup mode is invalid")

  defp ensure_admitted do

    environment = Application.get_env(:openagents, :runtime_environment)

    enabled? = Application.get_env(:openagents, :staging_cleanup_enabled, false) == true

    staging_gate = Application.get_env(:openagents, :staging_gate, 0)

    if enabled? and

         (environment == :test or (environment == :staging and staging_gate >= 12)) do

      :ok

    else

      {:error, :staging_cleanup_not_admitted}

    end

  end

  defp validate_run_id(run_id) do

    if Regex.match?(@run_id_pattern, run_id), do: :ok, else: {:error, :invalid_run_id}

  end

  defp cast_resource_id(resource_id) do

    case Ecto.UUID.cast(resource_id) do

      {:ok, cast_id} -> {:ok, cast_id}

      :error -> {:error, :invalid_resource_id}

    end

  end

  defp fetch_resource(kind, resource_id) do

    case Repo.get(Map.fetch!(@schemas, kind), resource_id) do

      nil -> {:error, :resource_not_found}

      resource -> {:ok, resource}

    end

  end

  defp validate_resource(:repository, %Repository{

         owner_key: "openagentsinc",

         name_key: "openagents.com"

       }),

       do: {:error, :canonical_repository_forbidden}

  defp validate_resource(:account, %User{} = user) do

    if Accounts.admin?(user), do: {:error, :administrator_account_forbidden}, else: :ok

  end

  defp validate_resource(_kind, _resource), do: :ok

  defp lock_run(run_id) do

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

    :ok

  end

  defp registration_counts(run_id) do

    Repo.all(

      from(resource in DisposableResource,

        where: resource.run_id == ^run_id,

        group_by: resource.kind,

        select: {resource.kind, count(resource.id)}

      )

    )

    |> Map.new()

    |> complete_counts()

  end

  defp counts(registrations) do

    registrations

    |> Enum.frequencies_by(& &1.kind)

    |> complete_counts()

  end

  defp complete_counts(counts) do

    Map.new(Map.values(@kind_names), &{&1, Map.get(counts, &1, 0)})

  end

  defp stringify_counts(counts) do

    Map.new(@kinds, fn kind -> {Map.fetch!(@kind_names, kind), Map.fetch!(counts, kind)} end)

  end

  defp targets(registrations) do

    by_kind = Enum.group_by(registrations, & &1.kind, & &1.resource_id)

    %{

      account: Map.get(by_kind, "account", []),

      machine: Map.get(by_kind, "machine", []),

      recording: Map.get(by_kind, "recording", []),

      repository: Map.get(by_kind, "repository", [])

    }

  end

  defp validate_cleanup_targets!(targets) do

    validate_repositories!(targets.repository)

    validate_accounts!(

      targets.account,

      targets.repository,

      targets.machine,

      targets.recording

    )

    validate_machines!(targets.machine)

  end

  defp validate_repositories!(repository_ids) do

    canonical? =

      Repo.exists?(

        from(repository in Repository,

          where:

            repository.id in ^repository_ids and repository.owner_key == "openagentsinc" and

              repository.name_key == "openagents.com"

        )

      )

    if canonical?, do: Repo.rollback(:canonical_repository_forbidden)

  end

  defp validate_accounts!(account_ids, repository_ids, machine_ids, recording_ids) do

    users = Repo.all(from(user in User, where: user.id in ^account_ids, lock: "FOR UPDATE"))

    if Enum.any?(users, &Accounts.admin?/1),

      do: Repo.rollback(:administrator_account_forbidden)

    outside_project? =

      Repo.exists?(

        from(project in Project,

          where:

            project.owner_user_id in ^account_ids and

              project.repository_id not in ^repository_ids

        )

      )

    if outside_project?, do: Repo.rollback(:account_owns_unregistered_project)

    outside_machine? =

      Repo.exists?(

        from(machine in Machine,

          where: machine.user_id in ^account_ids and machine.id not in ^machine_ids

        )

      )

    if outside_machine?, do: Repo.rollback(:account_owns_unregistered_machine)

    outside_recording? =

      Repo.exists?(

        from(recording in Recording,

          join: session in Session,

          on: session.id == recording.voice_session_id,

          join: conversation in Conversation,

          on: conversation.id == session.conversation_id,

          join: visitor in Visitor,

          on: visitor.id == conversation.visitor_id,

          where: visitor.user_id in ^account_ids and recording.id not in ^recording_ids

        )

      )

    if outside_recording?, do: Repo.rollback(:account_owns_unregistered_recording)

  end

  defp validate_machines!(machine_ids) do

    if Enum.any?(machine_ids, &OpenAgents.Computer.online?/1),

      do: Repo.rollback(:machine_online)

    active_work? =

      Repo.exists?(

        from(job in Job,

          where: job.machine_id in ^machine_ids and job.status in ["queued", "running"]

        )

      )

    if active_work?, do: Repo.rollback(:machine_has_active_work)

  end

  defp delete_recordings([]), do: 0

  defp delete_recordings(recording_ids) do

    {count, nil} =

      Repo.delete_all(from(recording in Recording, where: recording.id in ^recording_ids))

    count

  end

  defp delete_repositories([]), do: 0

  defp delete_repositories(repository_ids) do

    project_ids =

      from(project in Project,

        where: project.repository_id in ^repository_ids,

        select: project.id

      )

    {_field_count, nil} =

      Repo.delete_all(

        from(field in ProjectField, where: field.project_id in subquery(project_ids))

      )

    {_item_count, nil} =

      Repo.delete_all(from(item in ProjectItem, where: item.repository_id in ^repository_ids))

    {count, nil} =

      Repo.delete_all(from(repository in Repository, where: repository.id in ^repository_ids))

    count

  end

  defp delete_machines([]), do: 0

  defp delete_machines(machine_ids) do

    {_job_count, nil} = Repo.delete_all(from(job in Job, where: job.machine_id in ^machine_ids))

    {count, nil} = Repo.delete_all(from(machine in Machine, where: machine.id in ^machine_ids))

    count

  end

  defp delete_accounts([]), do: 0

  defp delete_accounts(account_ids) do

    account_ids

    |> Enum.sort()

    |> Enum.count(fn account_id ->

      case Repo.get(User, account_id) do

        nil ->

          false

        %User{} = user ->

          delete_account_data!(user)

          case Repo.delete(user) do

            {:ok, _deleted} -> true

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

          end

      end

    end)

  end

  defp delete_account_data!(user) do

    case Conversations.get_conversation_for_user(user) do

      nil ->

        :ok

      conversation ->

        owner = Conversations.get_conversation_owner!(conversation)

        case DataRights.delete(user, owner, conversation) do

          {:ok, :deleted} -> :ok

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

        end

    end

  end

  defp normalize_transaction({:ok, result}), do: {:ok, result}

  defp normalize_transaction({:error, reason}), do: {:error, reason}

  defp encode_result(run_id, status, result) do

    Jason.encode!(%{

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

      "run_id" => run_id,

      "status" => status,

      "registered" => result.registered,

      "deleted" => Map.get(result, :deleted)

    })

  end

  defp bounded_reason({:account_data_cleanup_failed, reason}) when is_atom(reason),

    do: "account_data_#{reason}"

  defp bounded_reason(reason) when is_atom(reason), do: Atom.to_string(reason)

  defp bounded_reason(%Ecto.Changeset{}), do: "registration_conflict"

  defp bounded_reason(_reason), do: "cleanup_failed"

end

cd "$repo_root"

ops/ci/reference-check.sh

sh -n ops/staging/cleanup-run.sh

elixir ops/ci/docs-check.exs

MIX_ENV=test mix test --warnings-as-errors \

  test/openagents/log_safety_test.exs \

  test/openagents/runtime_config_test.exs \

  test/openagents/staging_cleanup_test.exs \

  test/openagents_web/icon_affordances_test.exs \

  test/openagents_web/icons_test.exs \

  test/openagents_web/ui_test.exs

#!/bin/sh

set -eu

run_id=${1:-}

mode=${2:-check}

staging_project=${OPENAGENTS_STAGING_PROJECT_ID:-}

production_project=${OPENAGENTS_PRODUCTION_PROJECT_ID:-}

zone=${OPENAGENTS_STAGING_ZONE:-us-central1-a}

: "${staging_project:?OPENAGENTS_STAGING_PROJECT_ID is required}"

: "${production_project:?OPENAGENTS_PRODUCTION_PROJECT_ID is required}"

case "$staging_project" in

  *stag*) ;;

  *) echo "staging project ID must contain 'stag'" >&2; exit 1 ;;

esac

if [ "$staging_project" = "$production_project" ]; then

  echo "staging and production project IDs must differ" >&2

  exit 1

fi

case "$run_id" in

  *[!a-z0-9-]* | "") echo "run ID must contain only lowercase letters, numbers, and hyphens" >&2; exit 64 ;;

esac

run_id_length=${#run_id}

if [ "$run_id_length" -lt 8 ] || [ "$run_id_length" -gt 64 ]; then

  echo "run ID must contain 8 through 64 characters" >&2

  exit 64

fi

case "$run_id" in

  [a-z0-9]*) ;;

  *) echo "run ID must start with a lowercase letter or number" >&2; exit 64 ;;

esac

case "$mode" in

  check) action=check ;;

  --apply) action=apply ;;

  *) echo "usage: ops/staging/cleanup-run.sh RUN_ID [check|--apply]" >&2; exit 64 ;;

esac

for command_name in gcloud; do

  if ! command -v "$command_name" >/dev/null 2>&1; then

    echo "$command_name is required" >&2

    exit 1

  fi

done

gcloud auth print-access-token >/dev/null

remote_expression="IO.puts(OpenAgents.StagingCleanup.command!(\"$run_id\", \"$action\"))"

remote_command="sudo docker exec openagents /app/bin/openagents eval '$remote_expression'"

gcloud compute ssh openagents-fleet-1 \

  --project="$staging_project" \

  --zone="$zone" \

  --tunnel-through-iap \

  --quiet \

  --command="$remote_command"

export OPENAGENTS_RA_EXPECTED_SIZE="3"

export OPENAGENTS_SECURE_COOKIES="true"

export OPENAGENTS_STAGING_GATE="5"

export OPENAGENTS_STAGING_CLEANUP_ENABLED="false"

export PHX_HOST="stage.openagents.com"

export POOL_SIZE="${POOL_SIZE:-10}"

export VOICE_RECORDING_ENCRYPTION_KEY=""

defmodule OpenAgents.Repo.Migrations.CreateStagingDisposableResources do

  use Ecto.Migration

  def up do

    create table(:staging_disposable_resources, primary_key: false) do

      add :id, :binary_id, primary_key: true, default: fragment("gen_random_uuid()")

      add :run_id, :string, null: false

      add :kind, :string, null: false

      add :resource_id, :binary_id, null: false

      add :inserted_at, :utc_datetime_usec,

        null: false,

        default: fragment("timezone('utc', now())")

    end

    create index(:staging_disposable_resources, [:run_id])

    create unique_index(:staging_disposable_resources, [:kind, :resource_id])

    create constraint(:staging_disposable_resources, :staging_disposable_run_id_check,

             check: "run_id ~ '^[a-z0-9][a-z0-9-]{7,63}$'"

           )

    create constraint(:staging_disposable_resources, :staging_disposable_kind_check,

             check: "kind IN ('account', 'machine', 'recording', 'repository')"

           )

    execute("""

    CREATE FUNCTION prevent_staging_disposable_resource_update()

    RETURNS trigger AS $$

    BEGIN

      RAISE EXCEPTION 'staging disposable resource registrations are immutable';

    END;

    $$ LANGUAGE plpgsql;

    """)

    execute("""

    CREATE TRIGGER staging_disposable_resources_prevent_update

    BEFORE UPDATE ON staging_disposable_resources

    FOR EACH ROW

    EXECUTE FUNCTION prevent_staging_disposable_resource_update();

    """)

  end

  def down do

    drop table(:staging_disposable_resources)

    execute("DROP FUNCTION prevent_staging_disposable_resource_update()")

  end

end

             |> RuntimeConfig.validate()

  end

  test "staging cleanup is admitted only at Gate 12 or later" do

    exact_identity = %{

      build_revision: String.duplicate("a", 40),

      image_digest: "sha256:" <> String.duplicate("b", 64)

    }

    assert {:ok, _config} =

             staging_settings()

             |> Map.merge(exact_identity)

             |> Map.merge(%{staging_gate: 12, staging_cleanup_enabled: true})

             |> RuntimeConfig.validate()

    assert {:error, %{setting: :staging_cleanup_enabled}} =

             staging_settings()

             |> Map.merge(exact_identity)

             |> Map.merge(%{staging_gate: 11, staging_cleanup_enabled: true})

             |> RuntimeConfig.validate()

    assert {:error, %{setting: :staging_cleanup_enabled}} =

             staging_settings()

             |> Map.put(:staging_cleanup_enabled, "true")

             |> RuntimeConfig.validate()

  end

  test "fleet deployment requires the isolated GCP rolling provider" do

    settings =

      staging_settings()

defmodule OpenAgents.StagingCleanupTest do

  use OpenAgents.DataCase, async: false

  import OpenAgents.AccountsFixtures

  alias OpenAgents.Conversations

  alias OpenAgents.Machines.Machine

  alias OpenAgents.ProjectFields.ProjectField

  alias OpenAgents.Projects

  alias OpenAgents.Repo

  alias OpenAgents.Repositories

  alias OpenAgents.Repositories.Repository

  alias OpenAgents.Staging.DisposableResource

  alias OpenAgents.StagingCleanup

  alias OpenAgents.Voice

  alias OpenAgents.Voice.{Config, Recording, Recordings}

  alias OpenAgents.Work.Job

  @run_id "gate14-cleanup-0001"

  setup do

    original_enabled = Application.get_env(:openagents, :staging_cleanup_enabled)

    original_environment = Application.get_env(:openagents, :runtime_environment)

    original_gate = Application.get_env(:openagents, :staging_gate)

    Application.put_env(:openagents, :staging_cleanup_enabled, true)

    Application.put_env(:openagents, :runtime_environment, :test)

    Application.put_env(:openagents, :staging_gate, 0)

    on_exit(fn ->

      restore_env(:staging_cleanup_enabled, original_enabled)

      restore_env(:runtime_environment, original_environment)

      restore_env(:staging_gate, original_gate)

    end)

    :ok

  end

  test "one run removes only its registered accounts, repositories, recordings, and machines" do

    user = repository_user_fixture("cleanup-target")

    unrelated_user = repository_user_fixture("cleanup-unrelated")

    repository = repository_fixture(user)

    project = project_fixture(repository, user)

    field = project_field_fixture(project)

    machine = machine_fixture(user)

    recording = recording_fixture(user)

    for {kind, resource_id} <- [

          {:account, user.id},

          {:repository, repository.id},

          {:machine, machine.id},

          {:recording, recording.id}

        ] do

      assert {:ok, %DisposableResource{}} = StagingCleanup.register(@run_id, kind, resource_id)

    end

    assert {:ok,

            %{

              registered: %{

                "account" => 1,

                "machine" => 1,

                "recording" => 1,

                "repository" => 1

              }

            }} = StagingCleanup.preview(@run_id)

    checked = @run_id |> StagingCleanup.command!("check") |> Jason.decode!()

    assert checked["schema"] == "openagents.staging_cleanup.v1"

    assert checked["status"] == "checked"

    assert checked["deleted"] == nil

    assert {:ok, result} = StagingCleanup.cleanup(@run_id)

    assert result.registered == result.deleted

    assert Repo.get(OpenAgents.Accounts.User, user.id) == nil

    assert Repo.get(Repository, repository.id) == nil

    assert Repo.get(Machine, machine.id) == nil

    assert Repo.get(Recording, recording.id) == nil

    assert Repo.get(ProjectField, field.id) == nil

    assert Repo.get(OpenAgents.Accounts.User, unrelated_user.id)

    assert Repositories.initial_repository!()

    assert Repo.aggregate(DisposableResource, :count) == 0

    assert {:ok, %{registered: empty}} = StagingCleanup.preview(@run_id)

    assert Enum.all?(empty, fn {_kind, count} -> count == 0 end)

  end

  test "registration refuses the canonical repository and administrator accounts" do

    assert {:error, :canonical_repository_forbidden} =

             StagingCleanup.register(@run_id, :repository, Repositories.initial_repository!().id)

    user = repository_user_fixture("cleanup-admin")

    original_ids = Application.get_env(:openagents, :admin_github_ids)

    Application.put_env(:openagents, :admin_github_ids, [user.github_id])

    on_exit(fn -> restore_env(:admin_github_ids, original_ids) end)

    assert {:error, :administrator_account_forbidden} =

             StagingCleanup.register(@run_id, :account, user.id)

  end

  test "cleanup refuses an account that owns a project outside the registered repositories" do

    user = repository_user_fixture("cleanup-project-owner")

    project = project_fixture(Repositories.initial_repository!(), user)

    assert {:ok, _registration} = StagingCleanup.register(@run_id, :account, user.id)

    assert {:error, :account_owns_unregistered_project} = StagingCleanup.cleanup(@run_id)

    assert Repo.get(OpenAgents.Accounts.User, user.id)

    assert Repo.get(OpenAgents.Projects.Project, project.id)

    assert Repo.get_by(DisposableResource, run_id: @run_id)

  end

  test "cleanup refuses an account that owns an unregistered machine" do

    user = repository_user_fixture("cleanup-machine-owner")

    machine = machine_fixture(user)

    assert {:ok, _registration} = StagingCleanup.register(@run_id, :account, user.id)

    assert {:error, :account_owns_unregistered_machine} = StagingCleanup.cleanup(@run_id)

    assert Repo.get(OpenAgents.Accounts.User, user.id)

    assert Repo.get(Machine, machine.id)

  end

  test "cleanup refuses an account that owns an unregistered recording" do

    user = repository_user_fixture("cleanup-recording-owner")

    recording = recording_fixture(user)

    assert {:ok, _registration} = StagingCleanup.register(@run_id, :account, user.id)

    assert {:error, :account_owns_unregistered_recording} = StagingCleanup.cleanup(@run_id)

    assert Repo.get(OpenAgents.Accounts.User, user.id)

    assert Repo.get(Recording, recording.id)

  end

  test "cleanup refuses an online machine" do

    user = repository_user_fixture("cleanup-online-machine")

    machine = machine_fixture(user)

    assert {:ok, _registration} = StagingCleanup.register(@run_id, :machine, machine.id)

    assert {:ok, _pid} = OpenAgents.Computer.register(machine.id)

    on_exit(fn -> OpenAgents.Computer.unregister(machine.id) end)

    assert {:error, :machine_online} = StagingCleanup.cleanup(@run_id)

    assert Repo.get(Machine, machine.id)

  end

  test "cleanup refuses a machine with queued work" do

    user = repository_user_fixture("cleanup-active-work")

    machine = machine_fixture(user)

    {:ok, conversation} = Conversations.ensure_conversation(user)

    owner = Conversations.get_conversation_owner!(conversation)

    job =

      %Job{}

      |> Job.create_changeset(%{

        conversation_id: conversation.id,

        owner_visitor_id: owner.id,

        machine_id: machine.id,

        surface: "text",

        goal: "Keep this staging machine busy"

      })

      |> Repo.insert!()

    assert {:ok, _registration} = StagingCleanup.register(@run_id, :machine, machine.id)

    assert {:error, :machine_has_active_work} = StagingCleanup.cleanup(@run_id)

    assert Repo.get(Machine, machine.id)

    assert Repo.get(Job, job.id)

  end

  test "cleanup refuses account data with an active voice session" do

    user = repository_user_fixture("cleanup-active-voice")

    {:ok, conversation} = Conversations.ensure_conversation(user)

    {:ok, _session} = Voice.admit_session(conversation, enabled_voice_config())

    assert {:ok, _registration} = StagingCleanup.register(@run_id, :account, user.id)

    assert {:error, {:account_data_cleanup_failed, :voice_session_in_progress}} =

             StagingCleanup.cleanup(@run_id)

    assert Repo.get(OpenAgents.Accounts.User, user.id)

  end

  test "cleanup is unavailable unless the staging-only feature is admitted" do

    user = repository_user_fixture("cleanup-disabled")

    Application.put_env(:openagents, :staging_cleanup_enabled, false)

    assert {:error, :staging_cleanup_not_admitted} =

             StagingCleanup.register(@run_id, :account, user.id)

    Application.put_env(:openagents, :staging_cleanup_enabled, true)

    Application.put_env(:openagents, :runtime_environment, :production)

    assert {:error, :staging_cleanup_not_admitted} = StagingCleanup.preview(@run_id)

  end

  defp repository_fixture(user) do

    {:ok, repository} =

      Repositories.create_repository(%{

        owner: "OpenAgentsStaging",

        name: "cleanup-#{System.unique_integer([:positive])}",

        visibility: "private",

        default_branch: "main"

      })

    {:ok, _membership} = Repositories.add_member(repository, user, "owner")

    repository

  end

  defp project_fixture(repository, user) do

    {:ok, project} =

      Projects.create_project(

        repository,

        %{title: "Disposable cleanup project", owner: user.github_login},

        user

      )

    project

  end

  defp project_field_fixture(project) do

    {:ok, field} =

      Projects.create_project_field(%{

        name: "Status",

        data_type: "single_select",

        options: %{},

        project_id: project.id

      })