FROM ${BUILDER_IMAGE} AS builder

ARG OPENAGENTS_BUILD_REVISION="image"

ARG OPENAGENTS_RELEASE_VSN="0.2.0"

ARG OPENAGENTS_RELEASE_VSN

ARG SOURCE_DATE_EPOCH=0

ARG DEBIAN_SNAPSHOT

ARG HEX_VERSION

ENV OPENAGENTS_BUILD_REVISION=${OPENAGENTS_BUILD_REVISION}

ENV OPENAGENTS_RELEASE_VSN=${OPENAGENTS_RELEASE_VSN}

ENV SOURCE_DATE_EPOCH=${SOURCE_DATE_EPOCH}

RUN test -n "${OPENAGENTS_RELEASE_VSN}"

# install build dependencies

RUN sed -i \

0.2.3

commit does not require a new application version when the direct path can

deploy it.

After a full release changes the application version, update the default in

`mix.exs` and the plain-release default in `rel/openagents.appup.exs` to the

same version. The Forge builder compiles the candidate application

specification from that source default, and each deployment node compares it

with its running release. Leaving the source default behind causes every later

direct candidate to fail with `runtime_toolchain_mismatch`.

After a full release changes the application version, update `VERSION` in the

same candidate. `mix.exs`, the plain appup, and both image build scripts derive

their default from that file. The Forge builder compiles the candidate

application specification with that identity, and each deployment node

compares it with its running release. Leaving `VERSION` behind causes every

later direct candidate to fail with `runtime_toolchain_mismatch`.

## Receipts and status

version. Reserve a minor-version change for a deliberate compatibility or

feature boundary.

When a full release changes the application version, commit the same default

version in `mix.exs` and `rel/openagents.appup.exs`. The sidecar reads that

source identity into its build manifest, and deployment nodes compare it with

the running application. If those versions drift, direct preparation fails

with `runtime_toolchain_mismatch` on every node.

When a full release changes the application version, commit the new value in

`VERSION`. `mix.exs`, the plain appup, and both image build scripts derive their

default from that file. The sidecar reads that source identity into its build

manifest, and deployment nodes compare it with the running application. If

those versions drift, direct preparation fails with

`runtime_toolchain_mismatch` on every node.

If classification returns `needs_rolling_replace`, keep that receipt and use

this fallback order:

  end

  defp release_version do

    System.get_env("OPENAGENTS_RELEASE_VSN", "0.2.3")

    System.get_env("OPENAGENTS_RELEASE_VSN", default_release_version())

  end

  defp default_release_version do

    __DIR__

    |> Path.join("VERSION")

    |> File.read!()

    |> String.trim()

  end

  # Hot-upgrade-capable release: castle/forecastle add appup + relup generation

git_sha=$(git -C "$repo_root" rev-parse --verify HEAD)

source_date_epoch=$(git -C "$repo_root" show -s --format=%ct "$git_sha")

release_version=$(tr -d '\n' <"$repo_root/VERSION")

platform=${OPENAGENTS_IMAGE_PLATFORM:-linux/amd64}

tag=${1:-"openagents:$git_sha"}

image_root="$git_common_dir/openagents/images"

docker build \

  --platform "$platform" \

  --build-arg "OPENAGENTS_BUILD_REVISION=$git_sha" \

  --build-arg "OPENAGENTS_RELEASE_VSN=$release_version" \

  --build-arg "SOURCE_DATE_EPOCH=$source_date_epoch" \

  --iidfile "$iid_file" \

  --label "org.opencontainers.image.revision=$git_sha" \

git_sha=$(git rev-parse --verify HEAD)

origin_main=$(git rev-parse --verify refs/remotes/origin/main)

source_date_epoch=$(git show -s --format=%ct "$git_sha")

release_version=$(tr -d '\n' <"$repo_root/VERSION")

if [ "$git_sha" != "$origin_main" ]; then

  echo "candidate must equal the locally fetched origin/main commit" >&2

  docker build \

    --platform "$platform" \

    --build-arg "OPENAGENTS_BUILD_REVISION=$git_sha" \

    --build-arg "OPENAGENTS_RELEASE_VSN=$release_version" \

    --build-arg "SOURCE_DATE_EPOCH=$source_date_epoch" \

    --iidfile "$builder_iid" \

    --label "org.opencontainers.image.revision=$git_sha" \

  *) echo "builder image does not contain one release archive" >&2; exit 1 ;;

esac

release_version=${archive_name#openagents-}

release_version=${release_version%.tar.gz}

archive_version=${archive_name#openagents-}

archive_version=${archive_version%.tar.gz}

if [ "$archive_version" != "$release_version" ]; then

  echo "builder archive version does not match VERSION" >&2

  exit 1

fi

builder_container=$(docker create "$builder_image")

docker cp "$builder_container:/app/_build/prod/$archive_name" "$candidate_temp/$archive_name" >/dev/null

docker rm "$builder_container" >/dev/null

       )

     is_nil(to) and is_nil(from) ->

       {String.to_charlist(System.get_env("OPENAGENTS_RELEASE_VSN", "0.2.3")), [], []}

       {String.to_charlist(Mix.Project.config()[:version]), [], []}

     true ->

       raise "RELUP_FROM and RELUP_TO must be set together"

  alias OpenAgents.Release.Appup

  @appup_file Path.expand("../../../rel/openagents.appup.exs", __DIR__)

  @dockerfile Path.expand("../../../Dockerfile", __DIR__)

  @version_file Path.expand("../../../VERSION", __DIR__)

  @environment [

    "OPENAGENTS_RELEASE_VSN",

    "RELUP_FROM",

  test "plain releases keep the appup and project versions aligned" do

    Enum.each(@environment, &System.delete_env/1)

    assert String.trim(File.read!(@version_file)) == Mix.Project.config()[:version]

    assert {String.to_charlist(Mix.Project.config()[:version]), [], []} ==

             @appup_file |> Code.eval_file() |> elem(0)

    assert File.read!(@dockerfile) =~ "ARG OPENAGENTS_RELEASE_VSN\n"

    refute File.read!(@dockerfile) =~ "ARG OPENAGENTS_RELEASE_VSN="

  end

  test "covers a changed module the fixed proof set never named" do