declared roots, presence, probe-reported ACP agents, prompt bounds, and

execution; the API cannot widen a tier, add a root, or request an unadvertised

capability. Computer projections never expose a computer token, token digest, or

raw probe document.

raw probe document. They do expose `revoked_at`: `machines.revoked_at` was

written by both revocation paths and read by nothing, so the computers API and

the account export could say a computer was revoked and never when, alone among

this release's credentials. It is the owner's own record of their own computer

and is published with `status`.

Amended 2026-08-24 (issue #183): revoking a computer ends the inference

authority it holds, and cannot be raced.

| IDENTITY-005 | `test/openagents_web/controllers/box_controller_test.exs` |

| IDENTITY-006 | `test/openagents/forge/assignment_test.exs` |

| IDENTITY-007 | `test/openagents/agents_test.exs` |

| IDENTITY-008 | `test/openagents_web/controllers/computer_control_api_test.exs`, `test/openagents/inference/computer_revocation_test.exs` |

| IDENTITY-008 | `test/openagents_web/controllers/computer_control_api_test.exs`, `test/openagents/inference/computer_revocation_test.exs`, `test/openagents/computer_projection_test.exs` |

| IDENTITY-009 | `test/openagents_web/controllers/delegations_controller_test.exs` |

| IDENTITY-010 | `test/openagents/forge/assignment_test.exs`, `test/openagents/forge/assignment_credential_reach_test.exs` |

| IDENTITY-011 | `test/openagents/machines/pairing_expiry_test.exs` |

defmodule OpenAgents.ComputerProjection do

  @moduledoc "Safe projection of a paired computer for API and product surfaces."

  @moduledoc """

  Safe projection of a paired computer for API and product surfaces.

  Everything here is the owner's own record of their own computer. What stays

  out is what IDENTITY-008 keeps out: the computer token, its digest, and the

  raw probe document.

  `revoked_at` is included because `status` alone answers half the question.

  Every other credential in this release publishes both — `api_tokens`,

  `inference_grants`, `agent_tokens`, `forge_assignment_credentials` — and this

  was the one terminal stamp the database held and nothing read, so an account

  export could tell you a computer was revoked and never when.

  """

  alias OpenAgents.Computer

  alias OpenAgents.Machines.Machine

      "name" => machine.name,

      "tier" => machine.tier,

      "status" => machine.status,

      "revoked_at" => iso8601(machine.revoked_at),

      "scoped_forge_credentials_enabled" => machine.scoped_forge_credentials_enabled,

      "online" => machine.status == "active" and Computer.online?(machine.id),

      "platform" => machine.platform,

defmodule OpenAgents.ComputerProjectionTest do

  @moduledoc """

  `machines.revoked_at` was written by both revocation paths and read by

  nothing: `ComputerProjection.project/1` omitted it, so the account export and

  the computers API reported that a computer was revoked without saying when.

  """

  use OpenAgents.DataCase, async: true

  alias OpenAgents.ComputerProjection

  alias OpenAgents.Machines

  alias OpenAgents.Machines.Machine

  alias OpenAgents.Repo

  defp user(key) do

    {:ok, user} =

      OpenAgents.Accounts.upsert_github_user(%{

        github_id: :erlang.phash2({__MODULE__, key}),

        github_login: "projection-#{key}",

        github_avatar_url: "https://avatars.githubusercontent.com/u/1?v=4"

      })

    user

  end

  defp computer(owner, key) do

    {:ok, %{code: code}} = Machines.start_pairing(%{"name" => "box-#{key}", "tier" => "probe"})

    {:ok, machine} = Machines.approve_pairing(owner, code)

    machine

  end

  test "an active computer reports no revocation" do

    projection = ComputerProjection.project(computer(user("active"), "active"))

    assert projection["status"] == "active"

    assert Map.fetch!(projection, "revoked_at") == nil

  end

  test "a revoked computer reports when it was revoked" do

    owner = user("revoked")

    machine = computer(owner, "revoked")

    {:ok, revoked} = Machines.revoke_machine(owner, machine.id)

    projection = ComputerProjection.project(revoked)

    assert projection["status"] == "revoked"

    assert projection["revoked_at"] == DateTime.to_iso8601(revoked.revoked_at)

  end

  test "the stamp the account export carries is the stamp the row holds" do

    owner = user("export")

    machine = computer(owner, "export")

    {:ok, _revoked} = Machines.revoke_machine(owner, machine.id)

    # Projected from a fresh read, the way every caller reaches it.

    [projected] = Enum.map(Machines.list_machines(owner.id), &ComputerProjection.project/1)

    stored = Repo.get!(Machine, machine.id)

    assert projected["revoked_at"] == DateTime.to_iso8601(stored.revoked_at)

  end

  test "a computer revoked by an elapsed pairing reports its stamp too" do

    owner = user("swept")

    machine = computer(owner, "swept")

    OpenAgents.Machines.Pairing

    |> Repo.get_by!(machine_id: machine.id)

    |> Ecto.Changeset.change(expires_at: DateTime.add(DateTime.utc_now(), -3_600, :second))

    |> Repo.update!()

    assert Machines.expire_elapsed_pairings() == 1

    projection = ComputerProjection.project(Repo.get!(Machine, machine.id))

    assert projection["status"] == "revoked"

    assert is_binary(projection["revoked_at"])

  end

  test "the projection still withholds the token, its digest, and the raw probe" do

    machine = computer(user("secrets"), "secrets")

    {:ok, machine} = Machines.store_probe(machine, %{"acp_agents" => [], "secret" => "x"})

    projection = ComputerProjection.project(machine)

    refute Map.has_key?(projection, "token_digest")

    refute Map.has_key?(projection, "token_expires_at")

    refute Map.has_key?(projection, "last_probe")

  end

end