`/api/operator/artifact-listings`.

- Creating, cancelling, resuming, and replaying continual-learning jobs under

  `/api/operator/continual-learning/jobs`.

- Retracting a memory record or an engram from `/memory`

  (`OpenAgentsWeb.MemoryLive`, which rechecks the operator on the event, not

  only on mount). The write appends: it goes through

  `OpenAgents.ProfileMemory.forget_active/2`, which supersedes rather than

  deletes, so a retraction is another entry in the audit trail the same

  surface renders and never a row that quietly stops existing.

- Recording a graded Gym run under `POST /api/v3/gym/runs`

  (`OpenAgentsWeb.GymRunController`, which rechecks the operator on every

  request over the bearer scope), and reading the scoreboard from `/gym`

     |> assign(:recording_config, Recordings.config())

     |> assign(:privacy_delete_form, to_form(%{"confirmation" => ""}, as: :privacy))

     |> assign(:work_scope, "conversation:#{conversation.id}")

     |> assign(:operator?, Accounts.admin?(current_user))

     |> load_dashboard()}

  end

        engram_timeline={@engram_timeline}

        derived_heuristics={@derived_heuristics}

        supersession_trail={@supersession_trail}

        operator?={@operator?}

      />

    </Layouts.app>

    """

     |> load_dashboard()}

  end

  def handle_event(

        "retract_record",

        %{"record_id" => record_id, "expected_generation" => generation},

        socket

      ) do

    if Accounts.admin?(socket.assigns.current_user) do

      case Integer.parse(generation) do

        {expected_generation, ""} -> do_retract_record(record_id, expected_generation, socket)

        _ -> {:noreply, assign(socket, :memory_status, {:error, "Invalid retraction request."})}

      end

    else

      {:noreply, redirect(socket, to: ~p"/")}

    end

  end

  def handle_event("retract_engram", %{"record_ref" => ref}, socket) do

    if Accounts.admin?(socket.assigns.current_user) do

      do_retract_engram(ref, socket)

    else

      {:noreply, redirect(socket, to: ~p"/")}

    end

  end

  defp do_retract_record(record_id, expected_generation, socket) do

    owner = socket.assigns.memory_owner

    result =

      ProfileMemory.forget_active(owner, %{

        "mode" => "record",

        "record_id" => record_id,

        "expected_generation" => expected_generation

      })

    message =

      case result do

        {:ok, %{disposition: "forgotten", records: records}} ->

          "Retracted #{length(records)} memory record(s)."

        {:ok, %{disposition: "already_absent"}} ->

          "Those records were already absent."

        {:error, reason} ->

          "Could not retract record: #{format_reason(reason)}"

      end

    status = if match?({:ok, _}, result), do: :ok, else: :error

    {:noreply,

     socket

     |> assign(:memory_status, {status, message})

     |> load_dashboard()}

  end

  defp do_retract_engram(ref, socket) do

    owner = socket.assigns.memory_owner

    context_consent = %{

        {:error, _reason} -> {[], []}

      end

    records_by_id = Map.new(profile_export["records"] || [], &{&1["id"], &1})

    records = profile_export["records"] || []

    records_by_id = Map.new(records, &{&1["id"], &1})

    superseded_ids =

      for r <- records,

          r["supersedes_record_id"],

          into: MapSet.new(),

          do: r["supersedes_record_id"]

    supersession_trail =

      Enum.reduce(profile_export["records"] || [], [], fn record, acc ->

        if record["supersedes_record_id"] do

          previous = Map.get(records_by_id, record["supersedes_record_id"])

          [%{previous: previous, replacement: record} | acc]

        else

          acc

        end

      end)

      |> Enum.reverse()

      records

      |> Enum.reject(&MapSet.member?(superseded_ids, &1["id"]))

      |> Enum.map(&build_supersession_chain(&1, records_by_id))

      |> Enum.filter(&(&1.chain != []))

      |> Enum.sort_by(& &1.current["inserted_at"], :desc)

    socket

    |> assign(:memory_records, profile_export["records"] || [])

    |> assign(:memory_records, records)

    |> assign(:memory_status, memory_status)

    |> assign(:graph_entities, graph_entities)

    |> assign(:engram_timeline, engram_timeline)

  attr :engram_timeline, :list, default: []

  attr :derived_heuristics, :list, default: []

  attr :supersession_trail, :list, default: []

  attr :operator?, :boolean, default: false

  defp memory_manager(assigns) do

    ~H"""

      </.empty>

      <div :if={@memory_records != []} id="memory-records" class="memory-records">

        <.memory_record :for={record <- @memory_records} record={record} />

        <.memory_record

          :for={record <- @memory_records}

          record={record}

          operator?={@operator?}

        />

      </div>

      <.memory_dashboard

        engram_timeline={@engram_timeline}

        derived_heuristics={@derived_heuristics}

        supersession_trail={@supersession_trail}

        operator?={@operator?}

      />

      <.card id="leaderboard-preference" aria-labelledby="leaderboard-preference-heading">

  end

  attr :record, :map, required: true

  attr :operator?, :boolean, default: false

  defp memory_record(assigns) do

    ~H"""

          >

            <.icon name="trash" /> FORGET {String.upcase(@record["category"])} CATEGORY

          </.text_button>

          <.button

            :if={@operator?}

            id={"retract-record-#{@record["id"]}"}

            variant={:link}

            tone={:danger}

            size={:sm}

            phx-click="retract_record"

            phx-value-record_id={@record["id"]}

            phx-value-expected_generation={to_string(@record["generation"])}

          >

            <.icon name="trash" /> RETRACT

          </.button>

        </div>

      </div>

    </.card>

  attr :engram_timeline, :list, default: []

  attr :derived_heuristics, :list, default: []

  attr :supersession_trail, :list, default: []

  attr :operator?, :boolean, default: false

  defp memory_dashboard(assigns) do

    ~H"""

              {engram["outcome"]}

            </p>

            <.button

              :if={@operator?}

              id={"retract-engram-#{engram_id(engram["record_ref"])}"}

              variant={:link}

              tone={:danger}

        </.empty>

        <.list :if={@supersession_trail != []}>

          <:item

            :for={event <- @supersession_trail}

            title={event.replacement["claim"] || "WITHHELD"}

            :for={chain <- @supersession_trail}

            title={chain.current["claim"] || "WITHHELD"}

          >

            <p>

              Superseded

              <time :if={event.previous["inserted_at"]} datetime={event.previous["inserted_at"]}>

                {memory_date(event.previous["inserted_at"])}

              </time>

              : {event.previous["claim"] || "WITHHELD"}

            </p>

            <.badge variant={:warning}>Superseded by {event.replacement["id"]}</.badge>

            <div class="memory-supersession__meta">

              <.badge>{String.upcase(chain.current["category"])}</.badge>

              <.badge variant={memory_badge_variant(chain.current["status"])}>

                {String.upcase(chain.current["status"])}

              </.badge>

            </div>

            <ol :if={chain.chain != []} class="memory-supersession__chain">

              <li

                :for={prior <- chain.chain}

                id={"superseded-#{chain.current["id"]}-#{if prior.record, do: prior.record["id"], else: "missing"}"}

              >

                <%= if prior.record do %>

                  <p>{prior.record["claim"] || "WITHHELD"}</p>

                  <p class="memory-supersession__detail">

                    Superseded

                    <time :if={prior.superseded_at} datetime={prior.superseded_at}>

                      {memory_date(prior.superseded_at)}

                    </time>

                    by {prior.superseded_by_id}

                    <span :if={prior.consent_kind}>with consent {prior.consent_kind}</span>

                  </p>

                <% else %>

                  <p>Prior value unavailable</p>

                  <p class="memory-supersession__detail">

                    Superseded record is no longer in the exported scope.

                  </p>

                <% end %>

              </li>

            </ol>

          </:item>

        </.list>

      </.card>

    end

  end

  defp build_supersession_chain(current, records_by_id) do

    build_supersession_chain(current, records_by_id, [])

  end

  defp build_supersession_chain(current, records_by_id, chain) do

    case current["supersedes_record_id"] do

      nil ->

        %{current: current, chain: chain}

      previous_id ->

        previous = Map.get(records_by_id, previous_id)

        prior = %{

          record: previous,

          superseded_at: current["inserted_at"],

          superseded_by_id: current["id"],

          consent_kind: if(previous, do: consent_kind(current), else: nil)

        }

        if previous do

          build_supersession_chain(previous, records_by_id, chain ++ [prior])

        else

          %{current: current, chain: chain ++ [prior]}

        end

    end

  end

  defp consent_kind(record) do

    provenance = record["provenance"] || %{}

    basis = provenance["basis"]

    creator = provenance["creator"] || record["creator"] || "unknown"

    if basis do

      "#{basis} (#{creator})"

    else

      creator

    end

  end

  defp engram_state_variant("succeeded"), do: :success

  defp engram_state_variant("failed"), do: :danger

  defp engram_state_variant("corrected"), do: :warning

    assert {:ok, []} = ProfileMemory.list_current(owner)

  end

  test "supersession audit renders the chain of prior claims, superseded time, and consent kind",

       %{

         conn: conn

       } do

    token = "memory-audit-browser-credential-00000000000000"

    %{record: record} = create_profile_memory(token, "I prefer concise answers")

    conn = log_in_github_user(conn, token)

    assert {:ok, view, _html} = live(conn, ~p"/memory")

    view

    |> form("#memory-record-#{record.id} form", %{

      "claim" => "I prefer concise, direct answers"

    })

    |> render_submit()

    html = render(view)

    assert has_element?(view, "#supersession-audit ol li")

    assert html =~ "I prefer concise answers"

    assert html =~ "I prefer concise, direct answers"

    assert html =~ "owner_assertion"

  end

  test "retract appends a tombstone and does not delete the row", %{conn: conn} do

    token = "memory-retract-browser-credential-000000000000"

    %{record: record} = create_profile_memory(token, "Retract me")

    conn = log_in_admin_user(conn, token)

    assert {:ok, view, _html} = live(conn, ~p"/memory")

    view |> element("#retract-record-#{record.id}") |> render_click()

    assert has_element?(view, "#memory-record-#{record.id}[data-status=forgotten]")

    assert OpenAgents.Repo.get!(OpenAgents.ProfileMemory.Record, record.id).status == "forgotten"

  end

  test "unauthorized retraction redirects and does not mutate the record", %{conn: conn} do

    token = "memory-unauthorized-retract-browser-0000000000"

    %{record: record} = create_profile_memory(token, "No retract")

    conn = log_in_github_user(conn, token)

    assert {:ok, view, _html} = live(conn, ~p"/memory")

    assert {:error, {:redirect, %{to: "/"}}} =

             render_click(view, "retract_record", %{

               "record_id" => record.id,

               "expected_generation" => to_string(record.generation)

             })

    assert OpenAgents.Repo.get!(OpenAgents.ProfileMemory.Record, record.id).status == "active"

  end

  defp create_profile_memory(token, claim, category \\ "preference") do

    assert {:ok, conversation} = Conversations.ensure_conversation(github_user(token))

    owner = Conversations.get_conversation_owner!(conversation)

    OpenAgentsWeb.Layouts => "shows the operator entries in the sidebar",

    OpenAgentsWeb.Plugs.OperatorApiTokenAuth => "rechecks the operator behind /api/operator",

    OpenAgentsWeb.ReputationController => "gates reputation subject-claim review over the API",

    OpenAgentsWeb.UserAuth => "gates the /admin scope as a plug and as an on_mount hook"

    OpenAgentsWeb.UserAuth => "gates the /admin scope as a plug and as an on_mount hook",

    OpenAgentsWeb.MemoryLive =>

      "rechecks the operator before retracting memory records and engrams"

  }

  test "the operator-classified routes are exactly the set ADMIN-001 enumerates" do