#!/usr/bin/env bash
# Shared companions: scripts/ci/run-release.sh scripts/ci/validate-release-inputs.pl scripts/ci/finalize-release-changelog.awk scripts/ci/fixture-lifecycle.sh
set -euo pipefail

# This fixture owns its Make controls; production admission is tested below.
unset MAKEFLAGS MFLAGS MAKEOVERRIDES GNUMAKEFLAGS MAKEFILES
unset RELEASE_VERSION_MODE
export RELEASE_DELIVERY=direct

ROOT="${BASH_SOURCE[0]}"
[[ "$ROOT" == /* ]] || ROOT="$PWD/$ROOT"
ROOT="$(cd -P "${ROOT%/*}/../.." && printf '%s/.' "$PWD")"
ROOT="${ROOT%/.}"
FIXTURE_ROOT="$(mktemp -d "${TMPDIR:-/tmp}/release-runner-test.XXXXXX")"
FIXTURE_ROOT="$(CDPATH="" cd -P -- "$FIXTURE_ROOT" && printf '%s/.' "$PWD")"
FIXTURE_ROOT="${FIXTURE_ROOT%/.}"
# shellcheck source=scripts/ci/fixture-lifecycle.sh
source "$ROOT/scripts/ci/fixture-lifecycle.sh"
fixture_complete=false
trap 'fixture_finish "$?" "$FIXTURE_ROOT" "Failed release-runner fixture retained"' EXIT
export REAL_GIT REAL_MAKE
export RELEASE_FIXTURE_HASH_GIT RELEASE_FIXTURE_GIT_REFUSALS
RELEASE_FIXTURE_HASH_GIT="$(command -v git)"
RELEASE_FIXTURE_GIT_REFUSALS="$FIXTURE_ROOT/forbidden-git"
REAL_MAKE="$(command -v make)"
mkdir -p "$FIXTURE_ROOT/bin"

# The simulation may use Git's inert hash implementation, never its repository
# operations. Record any attempted escape even if an expected-failure case masks
# its exit status; the suite checks this record before reporting success.
REAL_GIT="$FIXTURE_ROOT/bin/hash-git"
cat > "$REAL_GIT" <<'GUARD'
#!/usr/bin/env bash
set -euo pipefail
if [[ $# == 2 && "$1" == hash-object && "$2" == --stdin ]]; then
    exec "$RELEASE_FIXTURE_HASH_GIT" "$@"
fi
printf '%s\n' "$*" >> "$RELEASE_FIXTURE_GIT_REFUSALS"
echo 'simulation fixture refused a real Git operation' >&2
exit 97
GUARD
chmod +x "$REAL_GIT"
for effect in commit tag push; do
    status=0
    "$REAL_GIT" "$effect" > "$FIXTURE_ROOT/guard-$effect.log" 2>&1 || status=$?
    [[ "$status" == 97 ]] || exit 1
done
: > "$RELEASE_FIXTURE_GIT_REFUSALS"

cat > "$FIXTURE_ROOT/bin/make" <<'STUB'
#!/usr/bin/env bash
set -euo pipefail
# Admission uses real GNU Make; all release effects below remain substitutes.
if [[ "${2:-}" == -f && "${3:-}" == - ]]; then exec "$REAL_MAKE" "$@"; fi
while [[ "$1" == --no-print-directory || "$1" == -s ]]; do shift; done
target="$1"
shift
for argument in "$@"; do export "$argument"; done
if [[ "$target" == release-version ]]; then cat version; exit; fi
if [[ "$target" == release-base-version ]]; then cat base-version; exit; fi
printf '%s\n' "$target" >> events
if [[ "$target" == release-verify && "${FIXTURE_RETAIN_BULK:-}" == yes ]]; then
    perl -e 'open my $f, ">", ".release-state/bulk" or die $!; truncate $f, 33554433 or die $!;'
fi
printf '%s %s %s\n' "$target" "$RELEASE_VERSION" "${RELEASE_COMMIT:-}" >> selections
if [[ "$target" == release-verify ]]; then
    attempt="$(awk '$0 == "release-verify" { count++ } END { print count }' events)"
    printf 'validation source: %s\n' "$RELEASE_SOURCE" > "validation.$attempt.log"
    printf 'build source: %s\n' "$RELEASE_SOURCE" > "build.$attempt.evidence"
fi
[[ "${FIXTURE_FAIL_TARGET:-}" != "$target" ]] || exit "${FIXTURE_FAIL_STATUS:-7}"
if [[ "${FIXTURE_DRIFT_TARGET:-}" == "$target" ]]; then
    printf '%s\n' "$FIXTURE_DRIFT_URL" > destination
fi
case "$target" in
    release-preflight)
        [[ "$(cat version)" == "$RELEASE_PREVIOUS" ||
           ( "${RELEASE_VERSION_MODE:-}" == pending && "$(cat version)" == "$RELEASE_VERSION" ) ]] || exit 1 ;;
    release-verify) ;;
    release-prepare-version)
        [[ "$(tail -n 1 ".release-state/$RELEASE_VERSION.plan")" == prepare ]] || exit 1
        [[ "$(sed -n '6p' ".release-state/$RELEASE_VERSION.plan")" == "$RELEASE_SOURCE" ]] || exit 1
        printf '%s\n' "$RELEASE_VERSION" > version
        touch dirty-worktree
        ;;
    release-prepared-check) [[ "$(cat version)" == "$RELEASE_VERSION" ]] || exit 1 ;;
    release-files) printf 'version\0release file.txt\0' ;;
    release-commit-check) ;;
    release-committed-check|release-tagged-check|release-push-check)
        [[ -n "$RELEASE_COMMIT" ]] || exit 1
        [[ "$(cat "commits/$RELEASE_COMMIT.subject")" == "Release $RELEASE_VERSION" ]] || exit 1
        if [[ "$target" == release-push-check ]]; then
            case "${FIXTURE_PUSH_MUTATION:-}" in
                tag) printf 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n' > "tags/v$RELEASE_VERSION" ;;
                tag-object) printf 'ffffffffffffffffffffffffffffffffffffffff\n' > tag-object ;;
                index) touch dirty-index ;;
                worktree) touch dirty-worktree ;;
            esac
        fi
        ;;
    *) exit 2 ;;
esac
STUB

cat > "$FIXTURE_ROOT/bin/git" <<'STUB'
#!/usr/bin/env bash
set -euo pipefail
release_sha=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
tag_sha=cccccccccccccccccccccccccccccccccccccccc
resolve() {
    if [[ "$1" == HEAD ]]; then cat head; else printf '%s\n' "$1"; fi
}
ancestor() {
    local cursor
    cursor="$(resolve "$2")"
    while [[ "$cursor" != "$1" ]]; do
        [[ -f "commits/$cursor.parent" ]] || return 1
        cursor="$(cat "commits/$cursor.parent")"
    done
}
case "$1" in
    for-each-ref) printf '\n' ;;
    check-ref-format) [[ "$2" == refs/heads/main ]] ;;
    symbolic-ref) echo main ;;
    remote)
        if [[ -f destination ]]; then cat destination
        else printf '%s\n' "${FIXTURE_DESTINATION:-https://example.invalid/release-fixture}"; fi
        ;;
    hash-object) exec "$REAL_GIT" hash-object --stdin ;;
    rev-parse)
        case "${*: -1}" in
            --show-toplevel) pwd ;;
            release-state) echo .release-state ;;
            HEAD) cat head ;;
            HEAD^) [[ "$(cat head)" == "$release_sha" ]] || exit 1; cat parent-head ;;
            *'^{tree}')
                name="${*: -1}"; name="$(resolve "${name%\^\{tree\}}")"
                if [[ -n "${FIXTURE_COMMIT_TREE:-}" ]]; then echo "$FIXTURE_COMMIT_TREE"; elif [[ -f "commits/$name.tree" ]]; then cat "commits/$name.tree"; else echo dddddddddddddddddddddddddddddddddddddddd; fi
                ;;
            refs/tags/*'^{commit}')
                name="${*: -1}"; name="${name#refs/tags/}"; name="${name%\^\{commit\}}"
                if [[ -n "${FIXTURE_TAG_COMMIT:-}" ]]; then echo "$FIXTURE_TAG_COMMIT"; elif [[ -f "tags/$name" ]]; then cat "tags/$name"; else
                    if [[ ! -f tag ]]; then
                        [[ " $* " == *' --quiet '* ]] || echo 'fatal: Needed a single revision' >&2
                        exit 1
                    fi
                    echo "$release_sha"
                fi
                ;;
            refs/tags/*) [[ -f tag ]] || exit 1; if [[ -f tag-object ]]; then cat tag-object; else echo "$tag_sha"; fi ;;
            *'^{commit}')
                name="${*: -1}"; name="${name%\^\{commit\}}"
                [[ -f "commits/$name.tree" ]] || exit 1
                printf '%s\n' "$name" ;;
            *) exit 2 ;;
        esac
        ;;
    diff)
        if [[ "$2" == --cached ]]; then [[ ! -e dirty-index ]];
        elif [[ "$2" == --quiet ]]; then [[ "${FIXTURE_DIRTY:-}" != yes && ! -e dirty-worktree ]];
        else cat version; fi
        ;;
    ls-files)
        [[ "${FIXTURE_INVENTORY_FAIL:-}" != yes ]] || exit 9
        if [[ "${FIXTURE_UNTRACKED:-}" == yes ]]; then echo unrelated-file; fi
        ;;
    write-tree) echo "${FIXTURE_INDEX_TREE:-dddddddddddddddddddddddddddddddddddddddd}" ;;
    rev-list)
        range="${*: -1}"; base="${range%..HEAD}"
        cursor="$(cat head)"; history=""
        while [[ "$cursor" != "$base" ]]; do
            [[ -f "commits/$cursor.parent" ]] || exit 1
            history="$cursor${history:+$'\n'$history}"
            cursor="$(cat "commits/$cursor.parent")"
        done
        [[ -z "$history" ]] || printf '%s\n' "$history"
        ;;
    merge-base) ancestor "$3" "$4" ;;
    log)
        sha="${*: -1}"
        case "$3" in
            --format=%P) cat "commits/$sha.parent" ;;
            --format=%s) cat "commits/$sha.subject" ;;
            *) exit 2 ;;
        esac
        ;;
    tag)
        case "$2" in
            --list) if [[ -f tag && "$(cat tag)" == "${3#v}" ]]; then echo "$3"; fi ;;
            -a)
                [[ "$4" == "$(cat head)" || -f "commits/$4.parent" ]] || exit 1
                mkdir -p tags
                printf '%s\n' "${FIXTURE_TAG_COMMIT:-$4}" > "tags/$3"
                printf '%s\n' "${3#v}" > tag
                echo tag >> events
                if [[ "${FIXTURE_FAIL_EFFECT:-}" == tag && ! -f lost-tag ]]; then touch lost-tag; exit 9; fi
                ;;
            *) exit 2 ;;
        esac
        ;;
    cat-file) [[ -f tag ]] || exit 1; echo "${FIXTURE_TAG_TYPE:-tag}" ;;
    ls-remote)
        [[ "${FIXTURE_REMOTE_FAIL:-}" != yes ]] || exit 9
        if [[ "${FIXTURE_DRIFT_TARGET:-}" == remote-observation && -f tag ]]; then
            printf '%s\n' "$FIXTURE_DRIFT_URL" > destination
        fi
        for ref in "$@"; do
            case "$ref" in
                refs/heads/main) if [[ -f remote-head ]]; then printf '%s\t%s\n' "$(cat remote-head)" "$ref"; fi ;;
                refs/tags/*) if [[ -f remote-tag && "$(cat remote-tag-name)" == "${ref#refs/tags/v}" ]]; then printf '%s\t%s\n' "$(cat remote-tag)" "$ref"; fi ;;
            esac
        done
        ;;
    add)
        [[ "$#" == 4 && "$2" == -- && "$3" == version && "$4" == 'release file.txt' ]] || exit 1
        echo stage >> events
        rm -f dirty-worktree
        touch dirty-index
        if [[ "${FIXTURE_FAIL_EFFECT:-}" == stage && ! -f lost-stage ]]; then touch lost-stage; exit 9; fi
        ;;
    commit)
        [[ "$#" == 3 && "$2" == -m && "$3" == "Release $(cat version)" ]] || exit 1
        cp head parent-head
        if [[ -f "commits/$release_sha.parent" ]]; then release_sha="$(printf '%s\n' "$3" "$(cat head)" | "$REAL_GIT" hash-object --stdin)"; fi
        mkdir -p commits
        cp head "commits/$release_sha.parent"
        echo dddddddddddddddddddddddddddddddddddddddd > "commits/$release_sha.tree"
        printf '%s\n' "$3" > "commits/$release_sha.subject"
        echo "$release_sha" > 'head'
        rm -f dirty-index
        echo commit >> events
        if [[ "${FIXTURE_FAIL_EFFECT:-}" == commit && ! -f lost-commit ]]; then touch lost-commit; exit 9; fi
        ;;
    push)
        [[ "$#" == 7 && "$2" == --no-follow-tags && "$3" == --atomic && "$4" == -- && "$5" == https://example.invalid/release-fixture && "$6" == *:refs/heads/main && "$7" == "refs/tags/v$(cat tag):refs/tags/v$(cat tag)" ]] || exit 1
        push_head="$(resolve "${6%:refs/heads/main}")"
        if [[ -f remote-head ]]; then ancestor "$(cat remote-head)" "$push_head"; fi
        printf '%s %s\n' "$push_head" "$(cat tag)" >> pushes
        echo push >> events
        [[ "${FIXTURE_FAIL_EFFECT:-}" != before-push ]] || exit 9
        echo "$push_head" > remote-head
        if [[ -f tag-object ]]; then cat tag-object > remote-tag; else echo "$tag_sha" > remote-tag; fi
        cat tag > remote-tag-name
        if [[ "${FIXTURE_FAIL_EFFECT:-}" == push && ! -f lost-push ]]; then touch lost-push; exit 9; fi
        ;;
    *) exit 2 ;;
esac
STUB
chmod +x "$FIXTURE_ROOT/bin/make" "$FIXTURE_ROOT/bin/git"
export PATH="$FIXTURE_ROOT/bin:$PATH"

new_fixture() {
    mkdir -p "$FIXTURE_ROOT/$1"
    cd "$FIXTURE_ROOT/$1"
    printf '0.1.0\n' > version
    printf 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n' > 'head'
    printf 'retained build artifact\n' > 'release file.txt'
}
# Seed saved intent, including preparation-free records from early attempts.
early_plan() {
    local kind="$1" candidate phase="$2" destination
    candidate="$(perl "$ROOT/scripts/ci/validate-release-inputs.pl" next-version "$(cat version)" "$kind")"
    destination="$(git remote get-url --push --all origin | git hash-object --stdin)"
    mkdir -p .release-state
    printf '%s\n' release-plan-1 "$kind" "$(cat version)" "$candidate" 2026-10-05 \
        "$(cat head)" origin main "$destination" '' "$phase" > ".release-state/$candidate.plan"
}
count_event() { awk -v event="$1" '$0 == event { count++ } END { print count+0 }' events; }
expect_failure() {
    if bash "$ROOT/scripts/ci/run-release.sh" "$@" > output 2>&1; then
        echo 'release runner unexpectedly accepted a failing fixture' >&2
        exit 1
    fi
}

# Focused qualification of the runner's shared journal-parser boundary.
if [[ "${1:-}" == journal ]]; then
    for saved_phase in preflight validate prepare complete; do
        new_fixture "journal-$saved_phase"
        if [[ "$saved_phase" == complete ]]; then
            bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output
            cp events saved-events
            cp .release-state/0.1.1.plan saved-plan
            bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > output
            cmp saved-plan .release-state/0.1.1.plan
            [[ "$(count_event commit)" == 1 && "$(count_event push)" == 1 ]]
        else
            early_plan patch "$saved_phase"
            bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > output
            [[ "$(count_event push)" == 1 ]]
        fi
    done
    new_fixture journal-invalid
    early_plan patch validate
    printf 'extra\n' >> .release-state/0.1.1.plan
    cp .release-state/0.1.1.plan saved-plan
    expect_failure resume 0.1.1 origin main
    cmp saved-plan .release-state/0.1.1.plan
    [[ ! -e events && ! -e .release-state/lock ]]
    [[ ! -s "$RELEASE_FIXTURE_GIT_REFUSALS" ]]
    echo 'Shared journal parser preserves early, completed and rejected runner resumes'
    fixture_complete=true
    exit 0
fi
[[ $# == 0 ]] || { echo 'usage: test-release-runner.sh [journal]' >&2; exit 2; }

# Retention refuses existing bulk before adapters, and new bulk before commit.
new_fixture retention-preflight
mkdir .release-state
perl -e 'open my $f, ">", ".release-state/bulk" or die $!; truncate $f, 33554433 or die $!;'
expect_failure patch origin main
[[ ! -e events && -f .release-state/bulk ]]
rm .release-state/bulk
bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output 2>&1
[[ "$(count_event push)" == 1 ]]
new_fixture retention-adapter
FIXTURE_RETAIN_BULK=yes expect_failure patch origin main
[[ -f .release-state/bulk && "$(count_event commit)" == 0 ]]
rm .release-state/bulk
bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output 2>&1
[[ "$(count_event push)" == 1 ]]

# Explicit recovery rejects corrupt saved dates without changing intent.
for invalid_date in 0000-01-01 1900-02-29 2026-02-29 2026-04-31; do
    new_fixture "invalid-date-$invalid_date"
    early_plan patch preflight
    awk -v invalid_date="$invalid_date" 'NR == 5 { print invalid_date; next } { print }' .release-state/0.1.1.plan > invalid.plan
    mv invalid.plan .release-state/0.1.1.plan
    cp .release-state/0.1.1.plan saved-plan
    : > events
    expect_failure resume 0.1.1 origin main
    cmp .release-state/0.1.1.plan saved-plan
    [[ "$(count_event release-preflight)" == 0 && "$(count_event commit)" == 0 && "$(count_event push)" == 0 ]] || exit 1
done

for mutation in tag tag-object index worktree; do
    new_fixture "push-check-mutation-$mutation"
    FIXTURE_PUSH_MUTATION="$mutation" expect_failure patch origin main
    [[ "$(tail -n 1 .release-state/0.1.1.plan)" == push ]] || exit 1
    [[ "$(count_event push)" == 0 && "$(count_event commit)" == 1 && "$(count_event tag)" == 1 ]] || exit 1
    # Explicitly repair the fixture's changed state and retry its saved release.
    cat head > tags/v0.1.1
    rm -f dirty-index dirty-worktree tag-object
    bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > recovered-output
    [[ "$(count_event push)" == 1 && "$(count_event commit)" == 1 && "$(count_event tag)" == 1 && "$(count_event release-verify)" == 1 ]] || exit 1
done

for conflict in local-tag-missing local-tag-commit local-tag-type remote-tag-missing remote-tag-changed remote-branch-missing remote-branch-diverged remote-unavailable; do
    new_fixture "completed-conflict-$conflict"
    bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output
    cp events completed-events
    cp .release-state/0.1.1.plan completed-plan
    bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > resumed-output
    cmp events completed-events
    case "$conflict" in
        local-tag-missing) rm tag ;;
        local-tag-commit) printf 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n' > tags/v0.1.1 ;;
        local-tag-type) export FIXTURE_TAG_TYPE=commit ;;
        remote-tag-missing) rm remote-tag ;;
        remote-tag-changed) printf 'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\n' > remote-tag ;;
        remote-branch-missing) rm remote-head ;;
        remote-branch-diverged) printf 'ffffffffffffffffffffffffffffffffffffffff\n' > remote-head ;;
        remote-unavailable) export FIXTURE_REMOTE_FAIL=yes ;;
    esac
    expect_failure resume 0.1.1 origin main
    cmp events completed-events
    cmp .release-state/0.1.1.plan completed-plan
    [[ ! -e .release-state/lock ]] || exit 1
    unset FIXTURE_TAG_TYPE FIXTURE_REMOTE_FAIL
done

for kind in patch minor major; do
    for flags in '' i n q t v; do
        new_fixture "make-mode-$kind-${flags:-control}"
        cat > Makefile <<'MAKE'
.PHONY: release-version release-preflight release-verify release-prepare-version
release-version:
	@cat version
release-preflight:
	@echo preflight >> events
release-verify:
	@echo validation-failed >> events
	@exit 23
release-prepare-version:
	@echo preparation-started >> events
	@exit 24
MAKE
        MAKEFLAGS="$flags" RELEASE_MAKE="$REAL_MAKE" expect_failure "$kind" origin main
        [[ "$(cat version)" == 0.1.0 && ! -e .release-state/lock ]] || exit 1
        plans=(.release-state/*.plan)
        [[ ! -e "${plans[0]}" ]] || exit 1
        if [[ -z "$flags" ]]; then
            [[ "$(cat events)" == $'preflight\nvalidation-failed' ]] || exit 1
        else
            [[ ! -e events && ! -e .release-state ]] || exit 1
            rg -F 'requires recipe execution and failure propagation' output >/dev/null
        fi
        [[ ! -e tag && ! -e commits && ! -e pushes ]] || exit 1
    done
done

for kind in patch minor major; do
    new_fixture "$kind"
    case "$kind" in patch) candidate=0.1.1 ;; minor) candidate=0.2.0 ;; major) candidate=1.0.0 ;; esac
    bash "$ROOT/scripts/ci/run-release.sh" "$kind" origin main > output
    [[ "$(cat version)" == "$candidate" && "$(cat tag)" == "$candidate" ]] || exit 1
    awk '/^(release-verify|release-prepare-version|stage|commit|tag|push)$/ { print }' events > observed
    printf '%s\n' release-verify release-prepare-version stage commit tag push > expected
    cmp expected observed
    [[ "$(count_event commit)" == 1 && "$(count_event push)" == 1 ]] || exit 1
    [[ "$(tail -n 1 ".release-state/$candidate.plan")" == complete ]] || exit 1
    [[ "$(cat 'release file.txt')" == 'retained build artifact' ]] || exit 1
    [[ ! -e .release-state/lock ]] || exit 1
done

# A pending VERSION is finalized as-is, without skipping preparation or bumping
# again. Wrong release kinds reject before validation or delivery.
for pending_case in success retry wrong-kind; do
    new_fixture "pending-version-$pending_case"
    printf '0.1.0\n' > base-version
    printf '0.1.1\n' > version
    export RELEASE_VERSION_MODE=pending
    if [[ "$pending_case" == wrong-kind ]]; then
        expect_failure minor origin main
        [[ "$(count_event release-verify)" == 0 && "$(count_event commit)" == 0 ]]
    else
        if [[ "$pending_case" == retry ]]; then
            FIXTURE_FAIL_TARGET=release-prepared-check expect_failure patch origin main
            bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > recovered-output
        else
            bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output
        fi
        [[ "$(cat version)" == 0.1.1 && "$(cat tag)" == 0.1.1 ]]
        [[ "$(count_event release-verify)" == 1 && "$(count_event commit)" == 1 ]]
        [[ "$(count_event release-prepare-version)" -ge 1 ]]
    fi
    unset RELEASE_VERSION_MODE
done

# A typed busy admission after metadata preparation preserves saved validation
# and the exact candidate. Resume rechecks admission without another full gate.
new_fixture prepared-tool-busy
FIXTURE_FAIL_TARGET=release-prepared-check FIXTURE_FAIL_STATUS=75 expect_failure patch origin main
[[ "$(tail -n 1 .release-state/0.1.1.plan)" == prepare && "$(cat version)" == 0.1.1 ]]
cp .release-state/0.1.1.plan saved-busy-plan
cp validation.1.log saved-busy-validation
cp build.1.evidence saved-busy-build
cp version saved-busy-version
[[ "$(count_event release-verify)" == 1 && "$(count_event commit)" == 0 && "$(count_event push)" == 0 ]]
FIXTURE_FAIL_TARGET=release-prepared-check FIXTURE_FAIL_STATUS=75 expect_failure resume 0.1.1 origin main
cmp saved-busy-plan .release-state/0.1.1.plan
cmp saved-busy-validation validation.1.log
cmp saved-busy-build build.1.evidence
cmp saved-busy-version version
bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > resumed-output
cmp saved-busy-validation validation.1.log
cmp saved-busy-build build.1.evidence
cmp saved-busy-version version
[[ "$(count_event release-verify)" == 1 && "$(count_event commit)" == 1 && "$(count_event push)" == 1 ]]

for kind in patch minor major; do
    for target in release-prepare-version release-prepared-check release-commit-check release-committed-check release-tagged-check release-push-check; do
        new_fixture "retry-$kind-$target"
        case "$kind" in patch) candidate=0.1.1 ;; minor) candidate=0.2.0 ;; major) candidate=1.0.0 ;; esac
        export FIXTURE_FAIL_TARGET="$target"
        expect_failure "$kind" origin main
        [[ "$(count_event push)" == 0 && ! -e .release-state/lock ]] || exit 1
        head -n 9 ".release-state/$candidate.plan" > saved-identity
        cp validation.1.log saved-log
        cp build.1.evidence saved-evidence
        cp events saved-events
        unset FIXTURE_FAIL_TARGET
        bash "$ROOT/scripts/ci/run-release.sh" resume "$candidate" origin main > output
        head -n 9 ".release-state/$candidate.plan" > final-identity
        cmp saved-identity final-identity
        cmp saved-log validation.1.log
        cmp saved-evidence build.1.evidence
        [[ "$(count_event release-verify)" == 1 && "$(count_event commit)" == 1 && "$(count_event tag)" == 1 && "$(count_event push)" == 1 ]] || exit 1
        [[ "$(cat version)" == "$candidate" && "$(tail -n 1 ".release-state/$candidate.plan")" == complete ]] || exit 1
        plans=(.release-state/*.plan)
        [[ "${#plans[@]}" == 1 && ! -e .release-state/lock ]] || exit 1
        case "$target" in
            release-prepare-version) [[ "$(count_event release-prepare-version)" == 2 ]] || exit 1 ;;
            *) [[ "$(count_event release-prepare-version)" == 1 ]] || exit 1 ;;
        esac
    done
done

for kind in patch minor major; do
    for target in release-preflight release-verify; do
        new_fixture "restart-$kind-$target"
        case "$kind" in patch) candidate=0.1.1 ;; minor) candidate=0.2.0 ;; major) candidate=1.0.0 ;; esac
        export FIXTURE_FAIL_TARGET="$target"
        expect_failure "$kind" origin main
        [[ ! -e ".release-state/$candidate.plan" && ! -e .release-state/lock ]] || exit 1
        cp output failed-output
        if [[ "$target" == release-preflight ]]; then
            grep -F 'this attempt has not started validation or version preparation' failed-output > /dev/null
            [[ "$(count_event release-verify)" == 0 && "$(count_event release-prepare-version)" == 0 ]] || exit 1
        fi
        if [[ "$target" == release-verify ]]; then
            cp validation.1.log failed-log
            cp build.1.evidence failed-evidence
        fi
        unset FIXTURE_FAIL_TARGET
        # Model a committed validation correction and different inputs.
        printf 'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\n' > 'head'
        printf 'corrected input\n' > corrected-input
        bash "$ROOT/scripts/ci/run-release.sh" "$kind" origin main > output
        [[ "$(sed -n '6p' ".release-state/$candidate.plan")" == eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee ]] || exit 1
        [[ "$(count_event release-preflight)" == 3 && "$(count_event release-prepare-version)" == 1 ]] || exit 1
        [[ "$(count_event commit)" == 1 && "$(count_event push)" == 1 ]] || exit 1
        if [[ "$target" == release-verify ]]; then
            [[ "$(count_event release-verify)" == 2 ]] || exit 1
            cmp failed-log validation.1.log
            cmp failed-evidence build.1.evidence
            [[ "$(cat validation.2.log)" == 'validation source: eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee' ]] || exit 1
        fi
        [[ -s failed-output && "$(cat 'release file.txt')" == 'retained build artifact' && "$(cat corrected-input)" == 'corrected input' ]] || exit 1
        [[ ! -e .release-state/lock ]] || exit 1
    done
done

# Fresh commands never parse historical plans, even several incompatible or
# malformed ones. Only actual current source/ref/lock conflicts may refuse.
for kind in patch minor major; do
    for phase in preflight validate prepare stage staged commit tag push complete pr-review; do
        for metadata in previous prepared; do
            new_fixture "fresh-$kind-$phase-$metadata"
            echo 0.73.1 > version
            early_plan patch "$phase"
            if [[ "$phase" == staged ]]; then
                sed 's/^staged$/stage/; 10s/.*/dddddddddddddddddddddddddddddddddddddddd/' \
                    .release-state/0.73.2.plan > staged-plan
                mv staged-plan .release-state/0.73.2.plan
                printf 'old staged roster\n' > .release-state/0.73.2.plan.files
            fi
            printf 'invalid old PR receipt\n' > .release-state/0.73.2.plan.pr.json
            cp .release-state/0.73.2.plan earlier-plan
            printf 'truncated historical plan\n' > .release-state/0.71.0.plan
            mkdir .release-state/broken.plan
            printf 'prior validation evidence\n' > historical.log
            if [[ "$metadata" == prepared ]]; then
                echo 0.73.2 > version
                mkdir -p commits
                cp head commits/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee.parent
                echo eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee > 'head'
            fi
            # The observed destination is older; old versions have no tags.
            echo aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > remote-head
            base="$(cat version)"
            candidate="$(perl "$ROOT/scripts/ci/validate-release-inputs.pl" next-version "$base" "$kind")"
            FIXTURE_FAIL_TARGET=release-verify expect_failure "$kind" origin main
            grep -F "Release $base -> $candidate" output > /dev/null
            [[ "$(cat version)" == "$base" && "$(count_event commit)" == 0 && "$(count_event tag)" == 0 && "$(count_event push)" == 0 ]] || exit 1
            [[ ! -e ".release-state/$candidate.plan" && ! -e ".release-state/$candidate.plan.files" && ! -e ".release-state/$candidate.plan.pr.json" ]] || exit 1
            if [[ "$candidate" != 0.73.2 ]]; then cmp earlier-plan .release-state/0.73.2.plan; fi
            cp validation.1.log failed-log
            cp build.1.evidence failed-build
            # A retry must validate this new source, never reuse either attempt.
            mkdir -p commits
            cp head commits/ffffffffffffffffffffffffffffffffffffffff.parent
            echo ffffffffffffffffffffffffffffffffffffffff > 'head'
            bash "$ROOT/scripts/ci/run-release.sh" "$kind" origin main > output
            [[ "$(cat version)" == "$candidate" && "$(count_event release-verify)" == 2 ]] || exit 1
            [[ "$(count_event commit)" == 1 && "$(count_event tag)" == 1 && "$(count_event push)" == 1 ]] || exit 1
            [[ "$(cat validation.2.log)" == 'validation source: ffffffffffffffffffffffffffffffffffffffff' ]] || exit 1
            [[ "$(cat historical.log)" == 'prior validation evidence' && -d .release-state/broken.plan ]] || exit 1
            [[ "$(cat .release-state/0.71.0.plan)" == 'truncated historical plan' ]] || exit 1
            [[ "$(tail -n 1 ".release-state/$candidate.plan")" == complete && ! -e .release-state/lock ]] || exit 1
            if [[ "$candidate" != 0.73.2 ]]; then cmp earlier-plan .release-state/0.73.2.plan; fi
            cmp failed-log validation.1.log
            cmp failed-build build.1.evidence
        done
    done
done

# Retention refuses stale links without following targets or erasing logs.
new_fixture fresh-candidate-links
mkdir -p .release-state old-evidence
printf 'retained diagnostics\n' > old-evidence/payload
ln -s ../old-evidence .release-state/0.1.1.plan
ln -s ../old-evidence .release-state/0.1.1.plan.files
ln -s ../old-evidence/payload .release-state/0.1.1.plan.pr.json
expect_failure patch origin main
[[ -L .release-state/0.1.1.plan && "$(cat old-evidence/payload)" == 'retained diagnostics' ]] || exit 1
rm .release-state/0.1.1.plan .release-state/0.1.1.plan.files .release-state/0.1.1.plan.pr.json
bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output
[[ "$(cat old-evidence/payload)" == 'retained diagnostics' ]] || exit 1
[[ ! -L .release-state/0.1.1.plan && ! -L .release-state/0.1.1.plan.files && ! -e .release-state/0.1.1.plan.pr.json ]] || exit 1

# Fresh starts still admit actual source, current candidate refs and concurrency.
for conflict in staged dirty untracked inventory local-tag remote-tag remote-unavailable; do
    new_fixture "fresh-conflict-$conflict"
    early_plan patch stage
    case "$conflict" in
        staged) touch dirty-index ;;
        dirty) export FIXTURE_DIRTY=yes ;;
        untracked) export FIXTURE_UNTRACKED=yes ;;
        inventory) export FIXTURE_INVENTORY_FAIL=yes ;;
        local-tag) echo 0.1.1 > tag ;;
        remote-tag) echo 0.1.1 > remote-tag-name; echo cccccccccccccccccccccccccccccccccccccccc > remote-tag ;;
        remote-unavailable) export FIXTURE_REMOTE_FAIL=yes ;;
    esac
    expect_failure patch origin main
    [[ "$(cat version)" == 0.1.0 && ! -e commits && ! -e .release-state/lock ]] || exit 1
    unset FIXTURE_DIRTY FIXTURE_UNTRACKED FIXTURE_INVENTORY_FAIL FIXTURE_REMOTE_FAIL
done

new_fixture early-exact-resume
early_plan patch validate
bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > output
[[ "$(count_event release-preflight)" == 2 && "$(count_event release-verify)" == 1 ]] || exit 1

for kind in patch minor major; do
    for effect in stage commit tag push before-push; do
        new_fixture "lost-$kind-$effect"
        case "$kind" in patch) candidate=0.1.1 ;; minor) candidate=0.2.0 ;; major) candidate=1.0.0 ;; esac
        export FIXTURE_FAIL_EFFECT="$effect"
        expect_failure "$kind" origin main
        unset FIXTURE_FAIL_EFFECT
        head -n 9 ".release-state/$candidate.plan" > saved-identity
        cp validation.1.log saved-log
        cp build.1.evidence saved-evidence
        bash "$ROOT/scripts/ci/run-release.sh" resume "$candidate" origin main > output
        head -n 9 ".release-state/$candidate.plan" > final-identity
        cmp saved-identity final-identity
        cmp saved-log validation.1.log
        cmp saved-evidence build.1.evidence
        [[ "$(cat version)" == "$candidate" && "$(count_event release-verify)" == 1 ]] || exit 1
        [[ "$(count_event release-prepare-version)" == 1 && "$(count_event commit)" == 1 && "$(count_event tag)" == 1 ]] || exit 1
        [[ "$(tail -n 1 ".release-state/$candidate.plan")" == complete ]] || exit 1
        plans=(.release-state/*.plan)
        [[ "${#plans[@]}" == 1 ]] || exit 1
        case "$effect" in stage) [[ "$(count_event stage)" == 2 ]] || exit 1 ;; *) [[ "$(count_event stage)" == 1 ]] || exit 1 ;; esac
        case "$effect" in before-push) [[ "$(count_event push)" == 2 ]] || exit 1 ;; *) [[ "$(count_event push)" == 1 ]] || exit 1 ;; esac
    done
done

new_fixture late-exact-resume
export FIXTURE_FAIL_EFFECT=push
expect_failure patch origin main
unset FIXTURE_FAIL_EFFECT
bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > output
[[ "$(count_event commit)" == 1 && "$(count_event tag)" == 1 && "$(count_event push)" == 1 ]] || exit 1

# Model a maintainer commit after the saved release, without using real commits.
commit_fix() {
    local fix=eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
    mkdir -p commits
    cp head "commits/$fix.parent"
    printf 'Fix release callback\n' > "commits/$fix.subject"
    printf '%s\n' "$fix" > "commits/$fix.tree"
    printf '%s\n' "$fix" > 'head'
}
new_fixture completed-remote-descendant
bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output
commit_fix
cp head remote-head
cp events completed-events
cp .release-state/0.1.1.plan completed-plan
bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > resumed-output
cmp events completed-events
cmp .release-state/0.1.1.plan completed-plan
[[ "$(cat remote-head)" == eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee ]] || exit 1

for outcome in before-push push; do
    new_fixture "descendant-resume-$outcome"
    FIXTURE_FAIL_EFFECT="$outcome" expect_failure minor origin main
    head -n 10 .release-state/0.2.0.plan > original-identity
    cp validation.1.log original-validation
    commit_fix
    bash "$ROOT/scripts/ci/run-release.sh" resume 0.2.0 origin main > output
    [[ "$(cat version)" == 0.2.0 && "$(count_event commit)" == 1 && "$(count_event release-verify)" == 1 ]] || exit 1
    head -n 10 .release-state/0.2.0.plan > reconciled-identity
    cmp original-identity reconciled-identity
    cmp original-validation validation.1.log
    [[ "$(tail -n 1 .release-state/0.2.0.plan)" == complete ]] || exit 1
    [[ "$(cat tags/v0.2.0)" == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb ]] || exit 1
    if [[ "$outcome" == before-push ]]; then
        [[ "$(sed -n '2p' pushes)" == 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb 0.2.0' ]] || exit 1
    else
        [[ "$(count_event push)" == 1 ]] || exit 1
    fi
    [[ ! -e .release-state/lock && -f 'release file.txt' ]] || exit 1
done

for target in release-committed-check release-tagged-check; do
    new_fixture "descendant-before-tag-$target"
    export FIXTURE_FAIL_TARGET="$target"
    expect_failure minor origin main
    unset FIXTURE_FAIL_TARGET
    commit_fix
    bash "$ROOT/scripts/ci/run-release.sh" resume 0.2.0 origin main > resumed-output
    bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output
    [[ "$(cat tags/v0.2.0)" == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb ]] || exit 1
    [[ "$(count_event commit)" == 2 && "$(count_event tag)" == 2 && "$(count_event release-verify)" == 2 ]] || exit 1
done

new_fixture descendant-validation-fails
export FIXTURE_FAIL_EFFECT=before-push
expect_failure minor origin main
unset FIXTURE_FAIL_EFFECT
commit_fix
export FIXTURE_FAIL_TARGET=release-verify
expect_failure patch origin main
unset FIXTURE_FAIL_TARGET
[[ "$(tail -n 1 .release-state/0.2.0.plan)" == push && ! -e .release-state/0.2.1.plan ]] || exit 1
cp validation.2.log failed-next-validation
bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output
cmp failed-next-validation validation.2.log
[[ "$(count_event release-verify)" == 3 && "$(count_event commit)" == 2 ]] || exit 1

new_fixture remote-descendant-missing-tag
export FIXTURE_FAIL_EFFECT=before-push
expect_failure minor origin main
unset FIXTURE_FAIL_EFFECT
commit_fix
cp head remote-head
bash "$ROOT/scripts/ci/run-release.sh" resume 0.2.0 origin main > output
[[ "$(cat remote-head)" == eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee ]] || exit 1
[[ "$(sed -n '2p' pushes)" == 'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee 0.2.0' ]] || exit 1

# Use the actual Make adapter boundary. Receipt verification must inspect the
# selected historical commit, even though current HEAD contains the wiring fix.
new_fixture descendant-make-receipt
printf '0.264.10\n' > version
cat > Makefile <<'MAKE'
release-version:
	@cat version
release-preflight release-verify release-prepare-version release-prepared-check release-files release-commit-check release-committed-check:
	@"$(FIXTURE_HELPER)" $@ "RELEASE_KIND=$(RELEASE_KIND)" "RELEASE_PREVIOUS=$(RELEASE_PREVIOUS)" "RELEASE_VERSION=$(RELEASE_VERSION)" "RELEASE_DATE=$(RELEASE_DATE)" "RELEASE_SOURCE=$(RELEASE_SOURCE)" "RELEASE_COMMIT=$(RELEASE_COMMIT)"
release-tagged-check:
	@mkdir -p receipts
	@printf '%s\n' "$(RELEASE_COMMIT)" > "receipts/$(RELEASE_VERSION)"
	@"$(FIXTURE_HELPER)" $@ "RELEASE_VERSION=$(RELEASE_VERSION)" "RELEASE_COMMIT=$(RELEASE_COMMIT)"
release-push-check:
	@test "$$(git rev-parse 'refs/tags/v$(RELEASE_VERSION)^{commit}')" = "$(RELEASE_COMMIT)"
	@test "$$(cat receipts/$(RELEASE_VERSION))" = "$(RELEASE_COMMIT)"
	@"$(FIXTURE_HELPER)" $@ "RELEASE_VERSION=$(RELEASE_VERSION)" "RELEASE_COMMIT=$(RELEASE_COMMIT)"
MAKE
export RELEASE_MAKE="$REAL_MAKE" FIXTURE_HELPER="$FIXTURE_ROOT/bin/make" FIXTURE_FAIL_EFFECT=before-push
expect_failure minor origin main
unset FIXTURE_FAIL_EFFECT
commit_fix
bash "$ROOT/scripts/ci/run-release.sh" resume 0.265.0 origin main > resumed-output
bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output
[[ "$(cat receipts/0.265.0)" == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb ]] || exit 1
[[ "$(cat receipts/0.265.1)" == "$(cat head)" && "$(count_event commit)" == 2 ]] || exit 1
unset RELEASE_MAKE FIXTURE_HELPER

for conflict in history dirty untracked inventory tag-commit tag-type remote-tag remote-unavailable destination remote-diverged; do
    new_fixture "descendant-conflict-$conflict"
    export FIXTURE_FAIL_EFFECT=before-push
    expect_failure minor origin main
    unset FIXTURE_FAIL_EFFECT
    commit_fix
    cp .release-state/0.2.0.plan saved-plan
    cp events saved-events
    case "$conflict" in
        history) printf 'Not a release\n' > commits/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.subject ;;
        dirty) export FIXTURE_DIRTY=yes ;;
        untracked) export FIXTURE_UNTRACKED=yes ;;
        inventory) export FIXTURE_INVENTORY_FAIL=yes ;;
        tag-commit) export FIXTURE_TAG_COMMIT=eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee ;;
        tag-type) export FIXTURE_TAG_TYPE=commit ;;
        remote-tag) echo dddddddddddddddddddddddddddddddddddddddd > remote-tag; echo 0.2.0 > remote-tag-name ;;
        remote-unavailable) export FIXTURE_REMOTE_FAIL=yes ;;
        destination) export FIXTURE_DESTINATION=https://example.invalid/other ;;
        remote-diverged) echo ffffffffffffffffffffffffffffffffffffffff > remote-head ;;
    esac
    expect_failure resume 0.2.0 origin main
    cmp saved-plan .release-state/0.2.0.plan
    [[ "$(count_event commit)" == 1 && "$(count_event push)" == 1 && ! -e .release-state/0.2.1.plan ]] || exit 1
    unset FIXTURE_DIRTY FIXTURE_UNTRACKED FIXTURE_INVENTORY_FAIL FIXTURE_TAG_COMMIT FIXTURE_TAG_TYPE FIXTURE_REMOTE_FAIL FIXTURE_DESTINATION
done

for conflict in source metadata index commit-tree tag-type tag-commit remote-tag remote-unavailable destination dirty untracked; do
    new_fixture "reconcile-conflict-$conflict"
    case "$conflict" in
        source|metadata) export FIXTURE_FAIL_TARGET=release-prepared-check ;;
        index) export FIXTURE_FAIL_TARGET=release-commit-check ;;
        tag-type|tag-commit) export FIXTURE_FAIL_TARGET=release-tagged-check ;;
        *) export FIXTURE_FAIL_TARGET=release-push-check ;;
    esac
    expect_failure patch origin main
    unset FIXTURE_FAIL_TARGET
    cp .release-state/0.1.1.plan saved-plan
    count_event commit > saved-commits
    count_event tag > saved-tags
    case "$conflict" in
        source) echo eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee > 'head' ;;
        metadata) echo 0.1.2 > version ;;
        index) export FIXTURE_INDEX_TREE=eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee ;;
        commit-tree) export FIXTURE_COMMIT_TREE=eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee ;;
        tag-type) export FIXTURE_TAG_TYPE=commit ;;
        tag-commit) export FIXTURE_TAG_COMMIT=eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee ;;
        remote-tag) echo eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee > remote-tag; echo 0.1.1 > remote-tag-name ;;
        remote-unavailable) export FIXTURE_REMOTE_FAIL=yes ;;
        destination) export FIXTURE_DESTINATION=https://example.invalid/other ;;
        dirty) export FIXTURE_DIRTY=yes ;;
        untracked) export FIXTURE_UNTRACKED=yes ;;
    esac
    expect_failure resume 0.1.1 origin main
    cmp saved-plan .release-state/0.1.1.plan
    [[ "$(count_event commit)" == "$(cat saved-commits)" && "$(count_event tag)" == "$(cat saved-tags)" && "$(count_event push)" == 0 ]] || exit 1
    [[ ! -e .release-state/0.1.2.plan && ! -e .release-state/lock ]] || exit 1
    unset FIXTURE_INDEX_TREE FIXTURE_COMMIT_TREE FIXTURE_TAG_TYPE FIXTURE_TAG_COMMIT FIXTURE_REMOTE_FAIL FIXTURE_DESTINATION FIXTURE_DIRTY FIXTURE_UNTRACKED
done

# Destination changes within one attempt must stop before dispatch, including
# adding a second URL and changes during the final remote observation.
for drift_target in release-verify release-push-check remote-observation; do
    for drift in replaced additional; do
        new_fixture "destination-$drift_target-$drift"
        export FIXTURE_DRIFT_TARGET="$drift_target"
        export FIXTURE_DRIFT_URL=https://example.invalid/other
        if [[ "$drift" == additional ]]; then
            FIXTURE_DRIFT_URL=$'https://example.invalid/release-fixture\nhttps://example.invalid/other'
        fi
        expect_failure patch origin main
        [[ "$(count_event push)" == 0 && ! -e .release-state/lock ]] || exit 1
        if [[ "$drift_target" == release-verify ]]; then
            [[ ! -e .release-state/0.1.1.plan && "$(cat version)" == 0.1.0 ]] || exit 1
        else
            [[ "$(tail -n 1 .release-state/0.1.1.plan)" == push ]] || exit 1
            [[ "$(count_event commit)" == 1 && "$(count_event tag)" == 1 ]] || exit 1
        fi
        # Restore the destination; only interrupted effectful attempts resume.
        unset FIXTURE_DRIFT_TARGET FIXTURE_DRIFT_URL
        rm destination
        if [[ "$drift_target" == release-verify ]]; then
            bash "$ROOT/scripts/ci/run-release.sh" patch origin main > recovered-output
        else
            bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > recovered-output
        fi
        [[ "$(count_event commit)" == 1 && "$(count_event tag)" == 1 && "$(count_event push)" == 1 ]] || exit 1
        [[ -f validation.1.log && -f build.1.evidence ]] || exit 1
    done
done

new_fixture concurrent
mkdir -p .release-state/lock
early_plan patch validate
cp .release-state/0.1.1.plan earlier-plan
expect_failure patch origin main
cmp earlier-plan .release-state/0.1.1.plan
[[ ! -e events && ! -e tag ]] || exit 1
[[ -d .release-state/lock ]] || exit 1
grep -F 'release lock is occupied' output >/dev/null

# Inject a non-occupancy error even on hosts where chmod cannot deny writes.
new_fixture lock-permission
early_plan patch validate
cp .release-state/0.1.1.plan earlier-plan
export RELEASE_FIXTURE_REAL_MKDIR
RELEASE_FIXTURE_REAL_MKDIR="$(command -v mkdir)"
cat > "$FIXTURE_ROOT/bin/mkdir" <<'STUB'
#!/usr/bin/env bash
if [[ "$*" == .release-state/lock ]]; then
    echo 'mkdir: fixture permission denied' >&2
    exit 37
fi
exec "$RELEASE_FIXTURE_REAL_MKDIR" "$@"
STUB
chmod +x "$FIXTURE_ROOT/bin/mkdir"
status=0
bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output 2>&1 || status=$?
[[ "$status" == 37 ]] || exit 1
grep -F 'mkdir: fixture permission denied' output >/dev/null
grep -F 'unable to acquire release lock' output >/dev/null
if grep -F 'lock is occupied' output >/dev/null; then exit 1; fi
cmp earlier-plan .release-state/0.1.1.plan
[[ ! -e events && ! -e tag && ! -e .release-state/lock ]] || exit 1
rm "$FIXTURE_ROOT/bin/mkdir"

new_fixture corrupt-plan
early_plan patch validate
printf 'unexpected record\n' >> .release-state/0.1.1.plan
expect_failure resume 0.1.1 origin main
[[ ! -e events ]] || exit 1
bash "$ROOT/scripts/ci/run-release.sh" patch origin main > output
[[ "$(count_event release-verify)" == 1 ]] || exit 1

# Malformed saved source identities matter only for explicit recovery.
for width in 39 41 63 65; do
    new_fixture "source-width-$width"
    early_plan patch validate
    identity="$(printf "%0${width}d" 1)"
    awk -v identity="$identity" 'NR==6 {$0=identity} {print}' .release-state/0.1.1.plan > changed-plan
    mv changed-plan .release-state/0.1.1.plan
    cp .release-state/0.1.1.plan saved-plan
    expect_failure resume 0.1.1 origin main
    cmp saved-plan .release-state/0.1.1.plan
    [[ ! -e events && ! -e tag && ! -e .release-state/lock ]] || exit 1
done

new_fixture concurrent-reconciliation
export FIXTURE_FAIL_TARGET=release-prepared-check
expect_failure patch origin main
unset FIXTURE_FAIL_TARGET
mkdir -p .release-state/lock
cp .release-state/0.1.1.plan saved-plan
cp events saved-events
expect_failure patch origin main
cmp saved-plan .release-state/0.1.1.plan
cmp saved-events events

new_fixture changelog
cat > CHANGELOG.md <<'NOTES'
# Changelog

## [0.1.1]

- Current completed change.

## [0.1.0] - 2026-10-05

- Retained history.
NOTES
awk -v version=0.1.1 -v date=2026-10-06 -f "$ROOT/scripts/ci/finalize-release-changelog.awk" CHANGELOG.md > prepared
sed 's/## \[0.1.1\]/## [0.1.1] - 2026-10-06/' CHANGELOG.md > expected
cmp expected prepared
printf '\n## [0.2.0]\n\n- Competing selection.\n' >> CHANGELOG.md
if awk -v version=0.1.1 -v date=2026-10-06 -f "$ROOT/scripts/ci/finalize-release-changelog.awk" CHANGELOG.md > prepared 2>/dev/null; then exit 1; fi

# Consumer adapters carry the saved previous version, including after a bump.
cat > CHANGELOG.md <<'NOTES'
# Changelog

## [0.1.1]

- Current completed change.

## [0.1.0]

- Imported undated history.
NOTES
sed 's/## \[0.1.1\]/## [0.1.1] - 2026-10-06/' CHANGELOG.md > expected
awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 \
    -f "$ROOT/scripts/ci/finalize-release-changelog.awk" CHANGELOG.md > prepared
cmp expected prepared
cp prepared CHANGELOG.md
awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 -v allow_finalized=1 \
    -f "$ROOT/scripts/ci/finalize-release-changelog.awk" CHANGELOG.md > prepared
cmp expected prepared
for selected_date in 2026-10-06 2026-10-07; do
    # Reconciliation is opt-in; another date always conflicts.
    allowed=0
    [[ "$selected_date" == 2026-10-06 ]] || allowed=1
    if awk -v version=0.1.1 -v previous=0.1.0 -v date="$selected_date" -v allow_finalized="$allowed" \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" CHANGELOG.md > prepared 2>/dev/null; then exit 1; fi
done

[[ "$(perl "$ROOT/scripts/ci/validate-release-inputs.pl" next-version 9.8.7 patch)" == 9.8.8 ]] || exit 1
[[ "$(perl "$ROOT/scripts/ci/validate-release-inputs.pl" next-version 9.8.7 minor)" == 9.9.0 ]] || exit 1
[[ "$(perl "$ROOT/scripts/ci/validate-release-inputs.pl" next-version 9.8.7 major)" == 10.0.0 ]] || exit 1
for version in 01.2.3 1.2.3-beta 1.2 18446744073709551616.0.0; do
    if perl "$ROOT/scripts/ci/validate-release-inputs.pl" next-version "$version" patch > /dev/null 2>&1; then exit 1; fi
done
# Preserve exact note ownership beyond binary64 precision and across lengths.
for components in '9007199254740992 9007199254740993 9007199254740991' \
    '999999999999999 1000000000000000 999999999999998'; do
    read -r previous_component candidate_component older_component <<< "$components"
    for position in major minor patch; do
        case "$position" in
            major)
                previous="$previous_component.0.0"
                candidate="$candidate_component.0.0"
                older="$older_component.0.0"
                ;;
            minor)
                previous="0.$previous_component.0"
                candidate="0.$candidate_component.0"
                older="0.$older_component.0"
                ;;
            patch)
                previous="0.0.$previous_component"
                candidate="0.0.$candidate_component"
                older="0.0.$older_component"
                ;;
        esac
        cat > CHANGELOG.md <<NOTES
# Changelog

## [$candidate]

- Pending release notes.

## [$previous]

- Equal cutoff history.

## [$older]

- Older history.
NOTES
        sed "s/## \[$candidate\]/## [$candidate] - 2026-10-06/" CHANGELOG.md > expected
        awk -v version="$candidate" -v previous="$previous" -v date=2026-10-06 \
            -f "$ROOT/scripts/ci/finalize-release-changelog.awk" CHANGELOG.md > prepared
        cmp expected prepared
        # A newer draft must not be reclassified as history at the cutoff.
        if awk -v version="$previous" -v previous="$previous" -v date=2026-10-06 \
            -f "$ROOT/scripts/ci/finalize-release-changelog.awk" CHANGELOG.md \
            > prepared 2> conflict.log; then exit 1; fi
    done
done
# Horizontal heading whitespace is presentation, not a different release identity.
for heading in '## [0.1.1]' $'##\t[0.1.1]'; do
    printf '# Changelog\n\n%s  \t\n\n- Selected notes.\n\n## [0.1.0]\t \n\n- Kept history.\n' "$heading" > whitespace-notes
    printf '# Changelog\n\n## [0.1.1] - 2026-10-06\n\n- Selected notes.\n\n## [0.1.0]\t \n\n- Kept history.\n' > whitespace-expected
    awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" whitespace-notes > whitespace-actual
    cmp whitespace-expected whitespace-actual
    printf '\n## [0.1.1]\t\n' >> whitespace-notes
    if awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" whitespace-notes > /dev/null 2>&1; then exit 1; fi
done
printf '# Changelog\n\n## [0.1.1] - 2026-10-06 \t\n\n- Finalized notes.\n' > whitespace-notes
awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 -v allow_finalized=1 \
    -f "$ROOT/scripts/ci/finalize-release-changelog.awk" whitespace-notes > whitespace-actual
cmp whitespace-notes whitespace-actual
if awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-07 -v allow_finalized=1 \
    -f "$ROOT/scripts/ci/finalize-release-changelog.awk" whitespace-notes > /dev/null 2>&1; then exit 1; fi
# Spacing around a dated identity cannot turn it into another candidate.
for selected_date in 2026-10-06 2026-10-07; do
    printf '# Changelog\n\n## [0.1.1]  - \t%s\t\n\n- Finalized.' "$selected_date" > spaced-dated
    cp spaced-dated spaced-original
    if awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" spaced-dated > spaced-result 2> spaced-error; then exit 1; fi
    [[ ! -s spaced-result ]] || exit 1
    cmp spaced-dated spaced-original
    status=0
    awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 -v allow_finalized=1 \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" spaced-dated > spaced-result 2> spaced-error || status=$?
    if [[ "$selected_date" == 2026-10-06 ]]; then
        [[ "$status" == 0 ]] || exit 1; cmp spaced-dated spaced-result
    else
        [[ "$status" == 1 && ! -s spaced-result ]] || exit 1
    fi
done

# Preserve byte boundaries at historical EOF without relocating candidates.
for ending in lf no-lf; do
    printf '## [0.1.0]\n\n- Historical café, literal ^$ and tabs\t.' > history-bytes
    [[ "$ending" != lf ]] || printf '\n' >> history-bytes
    printf '# Changelog\n\n## [0.1.1]\n\n- Pending.\n\n' > byte-notes
    cat history-bytes >> byte-notes
    printf '# Changelog\n\n## [0.1.1] - 2026-10-06\n\n- Pending.\n\n' > byte-expected
    cat history-bytes >> byte-expected
    awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" byte-notes > byte-result
    cmp byte-expected byte-result
    awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 -v allow_finalized=1 \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" byte-result > byte-repeated
    cmp byte-result byte-repeated
done
printf '## [0.1.0]\n\n- History.\n\n' > history-bytes
printf '# Changelog\n\n' > byte-notes
cat history-bytes >> byte-notes
printf '## [0.1.1]\n\n- Draft at EOF.' >> byte-notes
if awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 \
    -f "$ROOT/scripts/ci/finalize-release-changelog.awk" byte-notes > byte-result 2> rejected-notes.log; then exit 1; fi
[[ ! -s byte-result ]] || exit 1

# Strict candidate admission replaces consumer-owned heading scanners.
for layout in suffix mixed-duplicate duplicate-unreleased competing-unreleased misplaced wrong-date not-increasing; do
    selected=0.1.1
    case "$layout" in
        suffix) printf '## [0.1.1] - Pending\n\n- Pending.\n' > strict-notes ;;
        mixed-duplicate) printf '## [0.1.1]\n\n- Pending.\n\n## [0.1.1] - Unreleased\n' > strict-notes ;;
        duplicate-unreleased) printf '## [0.1.1] - Unreleased\n\n- Pending.\n\n## [0.1.1] - Unreleased\n' > strict-notes ;;
        competing-unreleased) printf '## [0.1.1] - Unreleased\n\n- Pending.\n\n## [0.2.0] - Unreleased\n' > strict-notes ;;
        misplaced) printf '## [0.1.0]\n\n- History.\n\n## [0.1.1] - Unreleased\n' > strict-notes ;;
        wrong-date) printf '## [0.1.1] - 2026-10-05\n' > strict-notes ;;
        not-increasing) selected=0.1.0; printf '## [0.1.0] - Unreleased\n' > strict-notes ;;
    esac
    cp strict-notes strict-before
    if awk -v version="$selected" -v previous=0.1.0 -v date=2026-10-06 \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" strict-notes > strict-result 2> strict-error; then exit 1; fi
    [[ ! -s strict-result ]] || exit 1
    rg -F "expected pending heading: ## [$selected]" strict-error >/dev/null
    cmp strict-before strict-notes
done
for top in '## [Draft]' '## [0.0.9]' '## Unexpected'; do
    printf '# Changelog\n\n%s\n\n- Notes.\n' "$top" > strict-notes
    if awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" strict-notes > strict-result 2> strict-error; then exit 1; fi
    [[ ! -s strict-result ]] || exit 1
done
for top in '## [0.1.0]' '## [0.1.0] - 2026-10-05'; do
    printf '# Changelog\n\n%s\n\n- History.' "$top" > strict-notes
    printf '# Changelog\n\n## [0.1.1] - 2026-10-06\n\n%s\n\n- History.' "$top" > strict-expected
    awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" strict-notes > strict-result
    cmp strict-expected strict-result
done

# Empty ledgers and legacy headings below the selected candidate cannot emit
# a partially prepared payload or modify the source.
for layout in empty heading-only nested-draft; do
    case "$layout" in
        empty) : > strict-notes ;;
        heading-only) printf '# Changelog\n' > strict-notes ;;
        nested-draft) printf '## [0.1.1]\n\n- Pending.\n\n## [Draft]\n' > strict-notes ;;
    esac
    cp strict-notes strict-before
    if awk -v version=0.1.1 -v previous=0.1.0 -v date=2026-10-06 \
        -f "$ROOT/scripts/ci/finalize-release-changelog.awk" strict-notes > strict-result 2> strict-error; then exit 1; fi
    [[ ! -s strict-result ]] || exit 1
    cmp strict-before strict-notes
done

[[ ! -s "$RELEASE_FIXTURE_GIT_REFUSALS" ]] || exit 1
echo 'release runner command-stub tests passed'
fixture_complete=true
