RUN set -eu; \

  case "${TARGETARCH:-$(dpkg --print-architecture)}" in \

    amd64) codex_arch=x86_64; checksum=0246e2e773834e07f0fb5249ed6ebad12e4591e608f8c7bb97dd6a9690544c36 ;; \

    arm64) codex_arch=aarch64; checksum=eb677c80f666b1ab8b4b1d083b66e8d614b1281d960bb6f9fd8ca98f58b38b90 ;; \

    amd64) codex_arch=x86_64; checksum=bd758d53d56e41dc65e045f4589df79a038ed197a011adcb52a258e6ad64cfda ;; \

    arm64) codex_arch=aarch64; checksum=89cbf79bd5ae6f9c58da47e8079f311c84219350c9c43c070d42f3e9b2a81401 ;; \

    *) echo "Unsupported architecture: ${TARGETARCH}" >&2; exit 1 ;; \

  esac; \

  archive="codex-${codex_arch}-unknown-linux-musl.tar.gz"; \

  archive="codex-package-${codex_arch}-unknown-linux-musl.tar.gz"; \

  curl -fsSL --retry 3 -o "/tmp/${archive}" \

    "https://github.com/openai/codex/releases/download/rust-v${CODEX_VERSION}/${archive}"; \

  echo "${checksum}  /tmp/${archive}" | sha256sum --check --strict; \

  tar -xzf "/tmp/${archive}" -C /tmp; \

  install -D -m 0755 "/tmp/codex-${codex_arch}-unknown-linux-musl" /usr/local/bin/codex; \

  rm "/tmp/${archive}" "/tmp/codex-${codex_arch}-unknown-linux-musl"; \

  codex --version

  install -d -m 0755 /opt/codex; \

  tar -xzf "/tmp/${archive}" -C /opt/codex; \

  ln -s /opt/codex/bin/codex /usr/local/bin/codex; \

  ln -s /opt/codex/bin/codex-code-mode-host /usr/local/bin/codex-code-mode-host; \

  rm "/tmp/${archive}"; \

  test -x /opt/codex/codex-resources/bwrap; \

  test -x /opt/codex/codex-path/rg; \

  codex --version; \

  codex-code-mode-host --help >/dev/null

# Set the locale

RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen \

   SHA-256 digest, exact repository SHA, Codex thread and turn IDs, event count,

   usage, and resources.

7. Query `scv_run_events` for that run. Require `driver_started`,

   `driver_session_started`, `turn_started`, at least one activity or message

   event, `turn_finished`, and `run_finished`.

   `driver_session_started`, `turn_started`, at least one successful

   `tool_started` and `tool_completed` pair, `turn_finished`, and

   `run_finished`. A message-only report does not prove repository access and

   does not qualify the SCV runtime.

8. Confirm that no disposable workspace or temporary `CODEX_HOME` remains and

   that the connected account remains **Ready**.

9. Scan the bounded event payloads, application logs, and public status

For one admitted account runtime:

1. Resolve a digest-pinned worker image and Codex binary or stable SDK release.

1. Resolve a digest-pinned worker image and complete Codex package. The package

   must include the app-server entry point, `codex-code-mode-host`, and its

   packaged `bwrap`, `rg`, and `zsh` resources. Installing only the `codex`

   binary disables code-mode tools and does not qualify an SCV runtime.

2. Materialize the account secret or credential home into its isolated

   compartment.

3. Generate host-owned Codex configuration. Ignore repository-controlled user

        redactions: redactions,

        notification_count: 0,

        tool_calls: %{},

        completed_tool_calls: %{},

        usage: %{},

        client_monitor: monitor,

        next_heartbeat_ms: monotonic_ms() + @heartbeat_interval_ms

            status: status

          })

        if event_type == "tool_started" do

          %{state | tool_calls: Map.update(state.tool_calls, tool, 1, &(&1 + 1))}

        else

          state

        case {event_type, status} do

          {"tool_started", _status} ->

            %{state | tool_calls: Map.update(state.tool_calls, tool, 1, &(&1 + 1))}

          {"tool_completed", "completed"} ->

            %{

              state

              | completed_tool_calls: Map.update(state.completed_tool_calls, tool, 1, &(&1 + 1))

            }

          {_event_type, _status} ->

            state

        end

    end

  end

    finished_at = DateTime.utc_now()

    duration_ms = max(monotonic_ms() - started_ms, 0)

    {report, report_valid?} = valid_report(state.report, state.report_truncated?)

    tool_activity_valid? = map_size(state.completed_tool_calls) > 0

    status =

      if state.status == "succeeded" and not report_valid?, do: "failed", else: state.status

      cond do

        state.status != "succeeded" -> state.status

        not report_valid? -> "failed"

        not tool_activity_valid? -> "failed"

        true -> "succeeded"

      end

    error_code =

      if state.status == "succeeded" and not report_valid?,

        do: "report_invalid",

        else: state.error_code

      cond do

        state.status != "succeeded" -> state.error_code

        not report_valid? -> "report_invalid"

        not tool_activity_valid? -> "tool_activity_missing"

        true -> nil

      end

    %{

      schema: @schema,

      events: %{

        event_count: state.notification_count,

        tool_calls: state.tool_calls,

        completed_tool_calls: state.completed_tool_calls,

        usage: state.usage

      },

      report: report,

  exit 1

fi

docker run --rm \

  --entrypoint /bin/sh \

  "$application_image" \

  -c 'set -eu

      test -x /opt/codex/bin/codex

      test -x /opt/codex/bin/codex-code-mode-host

      test -x /opt/codex/codex-resources/bwrap

      test -x /opt/codex/codex-path/rg

      /opt/codex/bin/codex-code-mode-host --help >/dev/null'

application_config_digest=$(docker image inspect "$application_image" --format '{{.Id}}')

builder_config_digest=$(docker image inspect "$builder_image" --format '{{.Id}}')

    assert result.report.text =~ "SCV completed the inspection"

    assert result.report.text =~ "[REDACTED]"

    assert result.events.tool_calls == %{"commandExecution" => 1}

    assert result.events.completed_tool_calls == %{"commandExecution" => 1}

    assert result.usage.total_tokens == 21

    assert_receive {:scv_session, %{driver_thread_id: "thr_fixture"}}

           )

  end

  test "fails a report-only run that never accesses the repository", context do

    config = Application.fetch_env!(:openagents, :scv_codex)

    Application.put_env(

      :openagents,

      :scv_codex,

      Keyword.put(config, :client_options, args: ["no_tools"])

    )

    test_process = self()

    assert {:ok, result} =

             CodexAppServer.run(

               context.repository,

               "Inspect the fixture without changing it.",

               account: context.account,

               run_id: Ecto.UUID.generate(),

               repository_revision: context.revision,

               reasoning_effort: "low",

               event_sink: fn event ->

                 send(test_process, {:scv_event, event})

                 :ok

               end

             )

    assert result.status == "failed"

    assert result.error_code == "tool_activity_missing"

    assert result.report.valid

    assert result.events.tool_calls == %{}

    assert result.events.completed_tool_calls == %{}

    assert_receive {:scv_event, %{type: "turn_finished", status: "succeeded"}}

    assert_receive {:scv_event,

                    %{type: "run_finished", status: "failed", error_code: "tool_activity_missing"}}

  end

  defp fixture do

    Path.expand("../../support/fake_codex_app_server.sh", __DIR__)

  end

             ~s(RELEASE_COOKIE:?RELEASE_COOKIE is required for a distributed node)

  end

  test "the runtime installs the complete pinned Codex package" do

    dockerfile = File.read!("Dockerfile")

    assert dockerfile =~ ~s(archive="codex-package-${codex_arch}-unknown-linux-musl.tar.gz")

    assert dockerfile =~ ~r/amd64\).*checksum=[0-9a-f]{64}/

    assert dockerfile =~ ~r/arm64\).*checksum=[0-9a-f]{64}/

    assert dockerfile =~ "/opt/codex/bin/codex-code-mode-host"

    assert dockerfile =~ "test -x /opt/codex/codex-resources/bwrap"

    assert dockerfile =~ "test -x /opt/codex/codex-path/rg"

    assert dockerfile =~ "codex-code-mode-host --help"

  end

  test "the isolated builder loads runtime configuration without the web role" do

    dockerfile = File.read!("Dockerfile")

    runtime_config = File.read!("config/runtime.exs")

  case "${line}" in

    *'"method":"initialize"'*)

      if [ "${mode}" = "run" ]; then

      if [ "${mode}" = "run" ] || [ "${mode}" = "no_tools" ]; then

        case "${line}" in *'"experimentalApi":true'*) : ;; *) exit 41 ;; esac

      fi

      printf '{"id":%s,"result":{"userAgent":"fake-codex/0.147.0","codexHome":"%s","platformFamily":"unix","platformOs":"linux"}}\n' "${id}" "${CODEX_HOME}"

    *'"method":"account/read"'*)

      account_reads=$((account_reads + 1))

      if [ "${account_reads}" -eq 1 ] && [ "${mode}" != "run" ]; then

      if [ "${account_reads}" -eq 1 ] &&

        [ "${mode}" != "run" ] &&

        [ "${mode}" != "no_tools" ]; then

        printf '{"id":%s,"result":{"account":null,"requiresOpenaiAuth":true}}\n' "${id}"

      else

        printf '{"id":%s,"result":{"account":{"type":"chatgpt","email":"operator@example.test","planType":"plus"},"requiresOpenaiAuth":true}}\n' "${id}"

      printf '{"id":%s,"result":{"status":"canceled"}}\n' "${id}"

      ;;

    *'"method":"thread/start"'*)

      if [ "${mode}" = "run" ]; then

      if [ "${mode}" = "run" ] || [ "${mode}" = "no_tools" ]; then

        case "${line}" in *'"permissions":"scv-read-only"'*) : ;; *) exit 42 ;; esac

        grep -q 'default_permissions = "scv-read-only"' "${CODEX_HOME}/config.toml"

        grep -q '":minimal" = "read"' "${CODEX_HOME}/config.toml"

    *'"method":"turn/start"'*)

      printf '{"id":%s,"result":{"turn":{"id":"turn_fixture","status":"inProgress","items":[],"error":null}}}\n' "${id}"

      printf '%s\n' '{"method":"turn/started","params":{"turn":{"id":"turn_fixture","status":"inProgress","items":[],"error":null}}}'

      printf '%s\n' '{"method":"item/started","params":{"threadId":"thr_fixture","turnId":"turn_fixture","item":{"id":"item_command","type":"commandExecution","command":"redacted","cwd":"/workspace","status":"inProgress"}}}'

      printf '%s\n' '{"method":"item/completed","params":{"threadId":"thr_fixture","turnId":"turn_fixture","item":{"id":"item_command","type":"commandExecution","command":"redacted","cwd":"/workspace","status":"completed","exitCode":0}}}'

      if [ "${mode}" != "no_tools" ]; then

        printf '%s\n' '{"method":"item/started","params":{"threadId":"thr_fixture","turnId":"turn_fixture","item":{"id":"item_command","type":"commandExecution","command":"redacted","cwd":"/workspace","status":"inProgress"}}}'

        printf '%s\n' '{"method":"item/completed","params":{"threadId":"thr_fixture","turnId":"turn_fixture","item":{"id":"item_command","type":"commandExecution","command":"redacted","cwd":"/workspace","status":"completed","exitCode":0}}}'

      fi

      printf '{"method":"item/agentMessage/delta","params":{"threadId":"thr_fixture","turnId":"turn_fixture","itemId":"item_message","delta":"%s"}}\n' "${report}"

      printf '%s\n' '{"method":"thread/tokenUsage/updated","params":{"threadId":"thr_fixture","turnId":"turn_fixture","tokenUsage":{"total":{"totalTokens":21,"inputTokens":13,"cachedInputTokens":3,"cacheWriteInputTokens":0,"outputTokens":8,"reasoningOutputTokens":2},"last":{"totalTokens":21,"inputTokens":13,"cachedInputTokens":3,"cacheWriteInputTokens":0,"outputTokens":8,"reasoningOutputTokens":2},"modelContextWindow":1000}}}'

      printf '{"method":"item/completed","params":{"threadId":"thr_fixture","turnId":"turn_fixture","item":{"id":"item_message","type":"agentMessage","text":"%s","phase":"final_answer"}}}\n' "${report}"