diff --git a/.github/workflows/e2e-go.yml b/.github/workflows/e2e-go.yml
index 30616f08f..ced66a21f 100644
--- a/.github/workflows/e2e-go.yml
+++ b/.github/workflows/e2e-go.yml
@@ -14,9 +14,9 @@ on:
         description: "PR head SHA to report status on"
         required: false
       suites:
-        description: "Space-separated Make targets to run (e.g. 'e2e-single e2e-cert e2e-lb')"
+        description: "Space-separated Make targets to run (e.g. 'e2e-single e2e-multinode e2e-cert e2e-lb')"
         required: false
-        default: "e2e-single e2e-cert e2e-lb"
+        default: "e2e-single e2e-multinode e2e-cert e2e-lb"
 
 permissions:
   contents: read
@@ -31,7 +31,7 @@ concurrency:
 
 env:
   GIT_BRANCH: ${{ github.ref_name }}
-  SUITES: ${{ inputs.suites || 'e2e-single e2e-cert e2e-lb' }}
+  SUITES: ${{ inputs.suites || 'e2e-single e2e-multinode e2e-cert e2e-lb' }}
 
 jobs:
   e2e_go_single:
@@ -165,7 +165,11 @@ jobs:
           # 'reboot' is filtered out here — that suite runs runner-resident
           # via the e2e_go_reboot job, not in-VM, so this build step doesn't
           # need its binary.
-          SUITES_BUILD=$(echo "${SUITES}" | sed 's/e2e-//g' | tr ' ' '\n' | grep -v '^reboot$' | tr '\n' ' ')
+          # Filter out reboot (runs on e2e_go_reboot) and multinode (runs on
+          # e2e_go_multinode). Single VM has no 3-node cluster — building +
+          # shipping multinode.test here would just produce a binary that
+          # skips on its own SPINIFEX_MODE check.
+          SUITES_BUILD=$(echo "${SUITES}" | sed 's/e2e-//g' | tr ' ' '\n' | grep -vE '^(reboot|multinode)$' | tr '\n' ' ')
           if [ -z "$(echo "${SUITES_BUILD}" | tr -d ' ')" ]; then
             echo "no in-VM suites requested (SUITES=${SUITES}); nothing to build"
             exit 0
@@ -206,7 +210,7 @@ jobs:
           # suite gets its own ::group:: + cyan banner inside so the Actions
           # UI collapses suite output by default; expand only what failed.
           # 'reboot' is filtered: runs via e2e_go_reboot on the runner, not here.
-          SUITES_RUN=$(echo "${SUITES}" | sed 's/e2e-//g' | tr ' ' '\n' | grep -v '^reboot$' | tr '\n' ' ')
+          SUITES_RUN=$(echo "${SUITES}" | sed 's/e2e-//g' | tr ' ' '\n' | grep -vE '^(reboot|multinode)$' | tr '\n' ' ')
           if [ -z "$(echo "${SUITES_RUN}" | tr -d ' ')" ]; then
             echo "no in-VM suites requested (SUITES=${SUITES}); skipping"
             echo "rc=0" >> "$GITHUB_OUTPUT"
@@ -377,6 +381,360 @@ jobs:
             exit 1
           fi
 
+  e2e_go_multinode:
+    name: Multi-Node E2E (Go)
+    # Opt-in via e2e-multinode in the SUITES list. Runs the Go multinode
+    # suite (port of run-multinode-e2e.sh) plus cert + lb against a 3-node
+    # tofu cluster. Mirrors e2e_go_single's binary-ship + per-suite flow,
+    # adapted for the ci-multi runner pool and SPINIFEX_NODES env wiring.
+    if: github.event_name != 'workflow_dispatch' || contains(github.event.inputs.suites, 'e2e-multinode')
+    runs-on: [ self-hosted, ci-multi ]
+    timeout-minutes: 60
+    env:
+      TOFU_LOG: /tmp/e2e-go-tofu-multi-${{ github.run_id }}.log
+      ARTIFACT_DIR: /tmp/spinifex-e2e-multi-artifacts-${{ github.run_id }}
+    steps:
+      - name: Reap Orphan Procs
+        run: |
+          set +e
+          UID_SELF=$(id -u)
+          WS="${GITHUB_WORKSPACE}"
+          reap() {
+            local sig="$1"
+            for pid in $(pgrep -u "$UID_SELF" -x tofu) $(pgrep -u "$UID_SELF" -x terraform); do
+              cwd=$(readlink "/proc/$pid/cwd" 2>/dev/null) || continue
+              case "$cwd" in
+                "$WS"|"$WS"/*) echo "reap $sig pid=$pid cwd=$cwd"; kill "-$sig" "$pid" 2>/dev/null ;;
+              esac
+            done
+          }
+          reap TERM
+          sleep 3
+          reap KILL
+          find "$WS" -name '.terraform.tfstate.lock.info' -delete 2>/dev/null
+          true
+
+      - name: Clean Workspace
+        run: sudo rm -rf "$GITHUB_WORKSPACE"/*
+
+      - uses: actions/create-github-app-token@v3
+        id: app-token
+        with:
+          client-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
+          repositories: mulga
+
+      - uses: actions/checkout@v6
+        with:
+          repository: mulgadc/mulga
+          token: ${{ steps.app-token.outputs.token }}
+          sparse-checkout: scripts/tofu-cluster
+          path: mulga
+
+      - uses: actions/checkout@v6
+        with:
+          path: spinifex
+
+      - uses: actions/setup-go@v6
+        with:
+          go-version-file: spinifex/go.mod
+          cache: false
+
+      - name: Re-enable Go toolchain auto-download
+        run: echo "GOTOOLCHAIN=auto" >> "$GITHUB_ENV"
+
+      - name: Build Install Artifacts
+        working-directory: mulga/scripts/tofu-cluster
+        run: |
+          ./build-install-artifacts.sh "${GIT_BRANCH}" \
+            "${RUNNER_TEMP}/spinifex-distro.tar.gz" \
+            "${RUNNER_TEMP}/setup.sh" \
+            "${RUNNER_TEMP}/spinifex-tests.tar"
+
+      - name: Provision VMs
+        working-directory: mulga/scripts/tofu-cluster
+        run: |
+          set -euo pipefail
+          # shellcheck source=/dev/null
+          source "${GITHUB_WORKSPACE}/spinifex/.github/scripts/ci-fmt.sh"
+          export TF_VAR_git_branch="${GIT_BRANCH}"
+          quiet_run "tofu init"                "$TOFU_LOG" tofu init -input=false
+          quiet_run "tofu workspace select"    "$TOFU_LOG" tofu workspace select -or-create "${SPINIFEX_CI_ENV}"
+          quiet_run "tofu destroy (pre-clean)" "$TOFU_LOG" tofu destroy -var-file=envs/${SPINIFEX_CI_ENV}.tfvars -auto-approve -input=false || true
+          quiet_run "scrub-env (pre-clean)"    "$TOFU_LOG" ./scrub-env.sh "${SPINIFEX_CI_ENV}" || true
+          quiet_run "tofu apply"               "$TOFU_LOG" tofu apply -var-file=envs/${SPINIFEX_CI_ENV}.tfvars -auto-approve -input=false
+          ok "3-node cluster provisioned"
+
+      - name: Bootstrap via Binary Install
+        working-directory: mulga/scripts/tofu-cluster
+        run: |
+          SPX_EXTERNAL_POOL="${SPINIFEX_CI_POOL}" \
+          ./bootstrap-install.sh "${SPINIFEX_CI_ENV}" \
+            "${RUNNER_TEMP}/setup.sh" \
+            "${RUNNER_TEMP}/spinifex-distro.tar.gz" \
+            --test-tar "${RUNNER_TEMP}/spinifex-tests.tar"
+
+      - name: Resolve cluster SSH details
+        id: cluster
+        working-directory: mulga/scripts/tofu-cluster
+        run: |
+          INVENTORY=$(tofu output -json inventory)
+          NODE1_IP=$(echo "$INVENTORY" | jq -r '.nodes[0].wan_ip')
+          SSH_KEY=$(echo "$INVENTORY" | jq -r '.ssh_key_path')
+          SSH_KEY="${SSH_KEY/#\~/$HOME}"
+          # Comma-separated node list for SPINIFEX_NODES (ClusterFromEnv)
+          # and SPINIFEX_NODE_IPS (Env.NodeIPs). Both consume the same csv.
+          NODE_COUNT=$(echo "$INVENTORY" | jq '.nodes | length')
+          NODES_CSV=""
+          for i in $(seq 0 $((NODE_COUNT - 1))); do
+            ip=$(echo "$INVENTORY" | jq -r ".nodes[$i].wan_ip")
+            if [ -z "$NODES_CSV" ]; then NODES_CSV="$ip"; else NODES_CSV="$NODES_CSV,$ip"; fi
+          done
+          echo "node1_ip=${NODE1_IP}" >> "$GITHUB_OUTPUT"
+          echo "ssh_key=${SSH_KEY}" >> "$GITHUB_OUTPUT"
+          echo "nodes_csv=${NODES_CSV}" >> "$GITHUB_OUTPUT"
+
+      - name: Build E2E test binaries on runner
+        working-directory: spinifex/tests/e2e
+        run: |
+          set -euo pipefail
+          # shellcheck source=/dev/null
+          source "${GITHUB_WORKSPACE}/spinifex/.github/scripts/ci-fmt.sh"
+          # Strip e2e- prefix, drop reboot (runner-resident) and single
+          # (single-VM job only) so the multinode job builds only what it
+          # ships: multinode, cert, lb.
+          SUITES_BUILD=$(echo "${SUITES}" | sed 's/e2e-//g' | tr ' ' '\n' | grep -vE '^(reboot|single)$' | tr '\n' ' ')
+          if [ -z "$(echo "${SUITES_BUILD}" | tr -d ' ')" ]; then
+            echo "no multinode-eligible suites requested (SUITES=${SUITES}); nothing to build"
+            exit 0
+          fi
+          banner "build ${SUITES_BUILD// /, }"
+          group_open "go test -c"
+          make e2e-build SUITES_BUILD="${SUITES_BUILD}"
+          group_close
+          for f in _bin/*.test; do
+            ok "$(basename "$f") $(stat -c '%s' "$f" | numfmt --to=iec)"
+          done
+
+      - name: Install go-junit-report on runner
+        run: |
+          go install github.com/jstemmer/go-junit-report/v2@latest
+          echo "$HOME/go/bin" >> "$GITHUB_PATH"
+
+      - name: Ship test binaries to node1
+        run: |
+          set -euo pipefail
+          # shellcheck source=/dev/null
+          source "${GITHUB_WORKSPACE}/spinifex/.github/scripts/ci-fmt.sh"
+          SSH_OPTS=(-o StrictHostKeyChecking=no -i "${{ steps.cluster.outputs.ssh_key }}")
+          VM=tf-user@${{ steps.cluster.outputs.node1_ip }}
+          ssh "${SSH_OPTS[@]}" "$VM" "rm -rf \$HOME/spinifex-e2e-bin && mkdir -p \$HOME/spinifex-e2e-bin"
+          tar -C spinifex/tests/e2e/_bin -cf - . | ssh "${SSH_OPTS[@]}" "$VM" "tar -xf - -C \$HOME/spinifex-e2e-bin"
+          ok "shipped binaries to $VM"
+
+      - name: Pre-flight diagnostics on node1
+        # Captures cluster + tf-user state directly via SSH so the post-mortem
+        # in run 26163994815-style spx-NATS failures has structured data
+        # before the test binary runs. Best-effort (|| true on everything) —
+        # this step never fails the job, only feeds the artifact bundle.
+        run: |
+          set +e
+          source "${GITHUB_WORKSPACE}/spinifex/.github/scripts/ci-fmt.sh" 2>/dev/null || true
+          SSH_OPTS=(-o StrictHostKeyChecking=no -i "${{ steps.cluster.outputs.ssh_key }}")
+          VM=tf-user@${{ steps.cluster.outputs.node1_ip }}
+          mkdir -p "${ARTIFACT_DIR}"
+          DIAG="${ARTIFACT_DIR}/preflight-diag.log"
+          {
+            echo "=== id (tf-user groups) ==="
+            ssh "${SSH_OPTS[@]}" "$VM" 'id; echo; getent group spinifex || true'
+            echo
+            echo "=== ls -la /etc/spinifex/ ==="
+            ssh "${SSH_OPTS[@]}" "$VM" 'ls -la /etc/spinifex/ 2>&1; echo; ls -la /etc/spinifex/nats/ 2>&1'
+            echo
+            echo "=== spinifex.toml NATS section ==="
+            ssh "${SSH_OPTS[@]}" "$VM" 'grep -A4 "\[nodes\\..*\\.nats" /etc/spinifex/spinifex.toml 2>&1 | head -40'
+            echo
+            echo "=== systemctl is-active spinifex-* ==="
+            ssh "${SSH_OPTS[@]}" "$VM" 'for s in spinifex-nats spinifex-predastore spinifex-awsgw spinifex-vpcd spinifex-daemon; do printf "%-22s %s\n" "$s" "$(systemctl is-active $s 2>&1)"; done'
+            echo
+            echo "=== which spx + version ==="
+            ssh "${SSH_OPTS[@]}" "$VM" 'which spx; spx --version 2>&1 || true'
+            echo
+            echo "=== spx get nodes (direct ssh, tf-user) ==="
+            ssh "${SSH_OPTS[@]}" "$VM" 'spx get nodes --timeout 5s 2>&1; echo "exit=$?"'
+            echo
+            echo "=== spx top nodes (direct ssh, tf-user) ==="
+            ssh "${SSH_OPTS[@]}" "$VM" 'spx top nodes 2>&1 | head -30; echo "exit=$?"'
+            echo
+            echo "=== NATS routez (curl 127.0.0.1:8222) ==="
+            ssh "${SSH_OPTS[@]}" "$VM" 'curl -fsS http://127.0.0.1:8222/routez 2>&1 | head -40'
+            echo
+            echo "=== aws describe-instance-types via gateway (tf-user) ==="
+            ssh "${SSH_OPTS[@]}" "$VM" 'AWS_PROFILE=spinifex AWS_CA_BUNDLE=/etc/spinifex/ca.pem aws --endpoint-url https://${{ steps.cluster.outputs.node1_ip }}:9999 ec2 describe-instance-types --query "InstanceTypes[*].InstanceType" --output text 2>&1 | head -5'
+          } 2>&1 | tee "$DIAG"
+          true
+
+      - name: Run Go E2E suites
+        id: e2e
+        run: |
+          set +e
+          # multinode + cert + lb only — see SUITES_BUILD comment above.
+          SUITES_RUN=$(echo "${SUITES}" | sed 's/e2e-//g' | tr ' ' '\n' | grep -vE '^(reboot|single)$' | tr '\n' ' ')
+          if [ -z "$(echo "${SUITES_RUN}" | tr -d ' ')" ]; then
+            echo "no multinode-eligible suites requested (SUITES=${SUITES}); skipping"
+            echo "rc=0" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          VM_HOST="tf-user@${{ steps.cluster.outputs.node1_ip }}"
+          SSH_KEY="${{ steps.cluster.outputs.ssh_key }}"
+          NODES_CSV="${{ steps.cluster.outputs.nodes_csv }}"
+          cleanup_remote() {
+            ssh -o StrictHostKeyChecking=no -o ConnectTimeout=5 -i "$SSH_KEY" "$VM_HOST" \
+              'pkill -u tf-user -TERM -f "/spinifex-e2e-bin/.*\.test( |$)" 2>/dev/null; sleep 1; pkill -u tf-user -KILL -f "/spinifex-e2e-bin/.*\.test( |$)" 2>/dev/null; true' \
+              2>/dev/null || true
+          }
+          trap cleanup_remote EXIT INT TERM
+          # SPINIFEX_NODES + SPINIFEX_NODE_IPS share the csv; ClusterFromEnv
+          # uses the first; cert/lb use Env.NodeIPs for SAN + endpoint maps.
+          # SPINIFEX_SSH_KEY default ~/.ssh/tf-user-ap-southeast-2 lines up
+          # with the bash peer_ssh path — bootstrap-install.sh writes it.
+          ssh -tt -o StrictHostKeyChecking=no -i "$SSH_KEY" \
+            "$VM_HOST" \
+            "set -u; mkdir -p '${ARTIFACT_DIR}'; \
+             cd \$HOME/spinifex-e2e-bin; \
+             R=\$'\033[0m' B=\$'\033[1m' C=\$'\033[36m' G=\$'\033[32m' RED=\$'\033[31m'; \
+             FAIL=0; \
+             for SUITE in ${SUITES_RUN}; do \
+               echo \"::group::suite \$SUITE\"; \
+               printf '\n%s%s━━ suite %s ━━%s\n' \"\$B\" \"\$C\" \"\$SUITE\" \"\$R\"; \
+               date -u +%Y-%m-%dT%H:%M:%SZ > '${ARTIFACT_DIR}/test-'\$SUITE'.start'; \
+               GITHUB_ACTIONS=true FORCE_COLOR=1 SPINIFEX_E2E=1 SPINIFEX_MODE=multinode \
+                 SPINIFEX_NODES='${NODES_CSV}' \
+                 SPINIFEX_NODE_IPS='${NODES_CSV}' \
+                 SPINIFEX_SSH_USER=tf-user \
+                 SPINIFEX_SSH_KEY=\$HOME/.ssh/tf-user-ap-southeast-2 \
+                 ARTIFACT_DIR='${ARTIFACT_DIR}' \
+                 ./\$SUITE.test -test.v -test.timeout=30m \
+                 2>&1 | tee '${ARTIFACT_DIR}/test-'\$SUITE'.log' \
+                      | sed -uE 's/^[[:space:]]+([a-zA-Z0-9_]+_test\.go:[0-9]+: )?//'; \
+               rc=\${PIPESTATUS[0]}; \
+               echo \"::endgroup::\"; \
+               if [ \$rc -ne 0 ]; then \
+                 printf '%s✗%s suite %s failed (exit %d)\n' \"\$RED\" \"\$R\" \"\$SUITE\" \"\$rc\"; \
+                 echo \"::error::suite \$SUITE failed (exit \$rc)\"; \
+                 echo \"\$SUITE: FAILED\" >> '${ARTIFACT_DIR}/suite-status.txt'; \
+                 FAIL=1; \
+               else \
+                 printf '%s✓%s suite %s passed\n' \"\$G\" \"\$R\" \"\$SUITE\"; \
+               fi; \
+             done; \
+             exit \$FAIL"
+          E2E_RC=$?
+          echo "rc=${E2E_RC}" >> "$GITHUB_OUTPUT"
+          exit 0
+
+      - name: Collect artifacts from node1
+        if: always()
+        run: |
+          set +e
+          # shellcheck source=/dev/null
+          source "${GITHUB_WORKSPACE}/spinifex/.github/scripts/ci-fmt.sh"
+          mkdir -p "${ARTIFACT_DIR}"
+          SSH_OPTS=(-o StrictHostKeyChecking=no -i "${{ steps.cluster.outputs.ssh_key }}")
+          VM=tf-user@${{ steps.cluster.outputs.node1_ip }}
+          ssh "${SSH_OPTS[@]}" "$VM" "tar -C '${ARTIFACT_DIR}' -cf - . 2>/dev/null || true" \
+            | tar -C "${ARTIFACT_DIR}" -xf - 2>/dev/null
+          ok "artifacts pulled to ${ARTIFACT_DIR}"
+          # Fan out journal collection across all 3 nodes so a failure
+          # signal on node2/3 isn't blind. Naming matches DumpAllNodeLogs.
+          IFS=',' read -ra NODE_LIST <<< "${{ steps.cluster.outputs.nodes_csv }}"
+          for i in "${!NODE_LIST[@]}"; do
+            idx=$((i + 1))
+            ip="${NODE_LIST[$i]}"
+            ssh "${SSH_OPTS[@]}" tf-user@"$ip" 'sudo journalctl -u "spinifex-*" --no-pager --output=short-iso --since "60 min ago"' \
+              > "${ARTIFACT_DIR}/spinifex-journal-node${idx}.log" 2>/dev/null
+            ok "journal node${idx}: $(wc -l < "${ARTIFACT_DIR}/spinifex-journal-node${idx}.log" 2>/dev/null || echo 0) lines"
+          done
+
+      - name: Convert test logs to JUnit XML
+        if: always()
+        run: |
+          shopt -s nullglob
+          for LOG in "${ARTIFACT_DIR}"/test-*.log; do
+            BASE=$(basename "$LOG" .log)
+            SUITE=${BASE#test-}
+            go-junit-report -in "$LOG" -out "${ARTIFACT_DIR}/junit-${SUITE}.xml" || true
+          done
+
+      - name: Publish test summary
+        if: always()
+        uses: ./spinifex/.github/actions/junit-report
+        with:
+          junit-glob: ${{ env.ARTIFACT_DIR }}/junit-*.xml
+          title: "Go Multi-Node E2E results"
+
+      - name: Analyze e2e failures
+        if: always()
+        uses: ./spinifex/.github/actions/e2e-analyze
+        with:
+          junit-glob: ${{ env.ARTIFACT_DIR }}/junit-*.xml
+          log-dir: ${{ env.ARTIFACT_DIR }}
+          title: "Multi-Node E2E failure analysis"
+
+      - uses: actions/upload-artifact@v7
+        if: always()
+        with:
+          name: e2e-go-multi-artifacts-${{ github.run_id }}
+          path: ${{ env.ARTIFACT_DIR }}
+          if-no-files-found: warn
+          retention-days: 14
+
+      - name: Teardown
+        if: always()
+        working-directory: mulga/scripts/tofu-cluster
+        run: |
+          set +e
+          # shellcheck source=/dev/null
+          source "${GITHUB_WORKSPACE}/spinifex/.github/scripts/ci-fmt.sh"
+          if [ -n "${{ steps.cluster.outputs.node1_ip }}" ] && [ -n "${{ steps.cluster.outputs.ssh_key }}" ]; then
+            IFS=',' read -ra NODE_LIST <<< "${{ steps.cluster.outputs.nodes_csv }}"
+            for ip in "${NODE_LIST[@]}"; do
+              ssh -o StrictHostKeyChecking=no -o ConnectTimeout=5 \
+                -i "${{ steps.cluster.outputs.ssh_key }}" \
+                tf-user@"$ip" \
+                'pkill -u tf-user -TERM -f "/spinifex-e2e-bin/.*\.test( |$)" 2>/dev/null; sleep 1; pkill -u tf-user -KILL -f "/spinifex-e2e-bin/.*\.test( |$)" 2>/dev/null; true' \
+                2>/dev/null || true
+            done
+          fi
+          UID_SELF=$(id -u)
+          WS="${GITHUB_WORKSPACE}"
+          reap() {
+            local sig="$1"
+            for pid in $(pgrep -u "$UID_SELF" -x tofu) $(pgrep -u "$UID_SELF" -x terraform); do
+              cwd=$(readlink "/proc/$pid/cwd" 2>/dev/null) || continue
+              case "$cwd" in
+                "$WS"|"$WS"/*) kill "-$sig" "$pid" 2>/dev/null ;;
+              esac
+            done
+          }
+          reap TERM
+          sleep 2
+          reap KILL
+          find "$WS" -name '.terraform.tfstate.lock.info' -delete 2>/dev/null
+          quiet_run "tofu workspace select" "$TOFU_LOG" tofu workspace select -or-create "${SPINIFEX_CI_ENV}"
+          quiet_run "tofu destroy"          "$TOFU_LOG" timeout 600 tofu destroy -var-file=envs/${SPINIFEX_CI_ENV}.tfvars -auto-approve -input=false
+          quiet_run "scrub-env"             "$TOFU_LOG" ./scrub-env.sh "${SPINIFEX_CI_ENV}"
+          ok "teardown complete"
+
+      - name: Fail job if any suite failed
+        if: always()
+        run: |
+          if [ "${{ steps.e2e.outputs.rc }}" != "0" ] || [ -s "${ARTIFACT_DIR}/suite-status.txt" ]; then
+            echo "::error::Go multi-node E2E suites failed (rc=${{ steps.e2e.outputs.rc }})"
+            cat "${ARTIFACT_DIR}/suite-status.txt" 2>/dev/null || true
+            exit 1
+          fi
+
   e2e_go_reboot:
     name: Reboot Resilience E2E (Go)
     # Opt-in: only fires when the SUITES dispatch input lists e2e-reboot.
@@ -643,7 +1001,7 @@ jobs:
     # whenever the workflow was dispatched without the optional input
     # (tests passed, status step silently failed). Refs mulga-siv-112.
     if: always()
-    needs: [ e2e_go_single, e2e_go_reboot ]
+    needs: [ e2e_go_single, e2e_go_multinode, e2e_go_reboot ]
     runs-on: [ self-hosted, ci-single ]
     timeout-minutes: 5
     steps:
@@ -656,18 +1014,20 @@ jobs:
             echo "::error::no SHA available (inputs.sha and github.sha both empty)"
             exit 1
           fi
-          # Treat skipped as success — e2e_go_reboot only runs when opted in
-          # via the SUITES input, so a non-reboot dispatch should still post
-          # a green status from the single job alone.
-          single_ok=true; reboot_ok=true
+          # Treat skipped as success — e2e_go_multinode and e2e_go_reboot
+          # only run when opted in via the SUITES input, so a single-only
+          # dispatch should still post a green status when the single job
+          # passes and the others skipped.
+          single_ok=true; multi_ok=true; reboot_ok=true
           case "${{ needs.e2e_go_single.result }}" in success|skipped) ;; *) single_ok=false ;; esac
+          case "${{ needs.e2e_go_multinode.result }}" in success|skipped) ;; *) multi_ok=false ;; esac
           case "${{ needs.e2e_go_reboot.result }}" in success|skipped) ;; *) reboot_ok=false ;; esac
-          if $single_ok && $reboot_ok; then
+          if $single_ok && $multi_ok && $reboot_ok; then
             STATE="success"
             DESC="Go E2E suites passed"
           else
             STATE="failure"
-            DESC="Go E2E failed: single=${{ needs.e2e_go_single.result }} reboot=${{ needs.e2e_go_reboot.result }}"
+            DESC="Go E2E failed: single=${{ needs.e2e_go_single.result }} multi=${{ needs.e2e_go_multinode.result }} reboot=${{ needs.e2e_go_reboot.result }}"
           fi
           gh api "repos/${{ github.repository }}/statuses/${REPORT_SHA}" \
             -f state="$STATE" \
diff --git a/spinifex/services/vpcd/topology.go b/spinifex/services/vpcd/topology.go
index b195bd56d..60d7bb488 100644
--- a/spinifex/services/vpcd/topology.go
+++ b/spinifex/services/vpcd/topology.go
@@ -1303,6 +1303,13 @@ func (h *TopologyHandler) handleIGWDetach(msg *nats.Msg) {
 
 // --- NAT (dnat_and_snat for public IPs) ---
 
+// handleAddNAT installs a dnat_and_snat rule for an EIP. Idempotent: if a rule
+// already exists for the external IP and its state matches the target
+// (LogicalIP, VpcId, plus ExternalMAC/LogicalPort under distributed-NAT mode),
+// the handler returns without touching NB. This avoids the delete-then-add
+// gap during which a chassis briefly has no flow for the EIP — a gap that
+// concurrent duplicate publishes for the same EIP would otherwise reopen
+// (mulga-siv-124).
 func (h *TopologyHandler) handleAddNAT(msg *nats.Msg) {
 	if h.ovn == nil {
 		respond(msg, fmt.Errorf("OVN client not connected"))
@@ -1332,13 +1339,35 @@ func (h *TopologyHandler) handleAddNAT(msg *nats.Msg) {
 			"spinifex:public_ip": evt.ExternalIP,
 		},
 	}
-	if !h.useCentralizedNAT() && evt.MAC != "" && evt.PortName != "" {
+	distributed := !h.useCentralizedNAT() && evt.MAC != "" && evt.PortName != ""
+	if distributed {
 		natRule.ExternalMAC = &evt.MAC
 		natRule.LogicalPort = &evt.PortName
 		slog.Debug("vpcd: using distributed NAT (direct bridge)",
 			"external_ip", evt.ExternalIP, "port", evt.PortName, "mac", evt.MAC)
 	}
 
+	// Idempotency: if the existing rule already matches the target, do not
+	// run delete-then-add. Concurrent duplicate vpc.add-nat publishes for the
+	// same EIP would otherwise tear down the rule the previous invocation
+	// just installed, creating a flow-install gap on the chassis.
+	if existing, err := h.ovn.FindNATByExternalIP(ctx, "dnat_and_snat", evt.ExternalIP); err != nil {
+		slog.Warn("vpcd: failed to look up existing NAT for idempotency check", "external_ip", evt.ExternalIP, "err", err)
+	} else if existing != nil && existing.LogicalIP == evt.LogicalIP &&
+		existing.ExternalIDs["spinifex:vpc_id"] == evt.VpcId &&
+		(!distributed ||
+			(existing.ExternalMAC != nil && *existing.ExternalMAC == evt.MAC &&
+				existing.LogicalPort != nil && *existing.LogicalPort == evt.PortName)) {
+		slog.Info("vpcd: dnat_and_snat already current, skipping",
+			"router", routerName,
+			"external_ip", evt.ExternalIP,
+			"logical_ip", evt.LogicalIP,
+			"port", evt.PortName,
+		)
+		respond(msg, nil)
+		return
+	}
+
 	// Remove any stale NAT rule for the same external IP before adding the new
 	// one. Search ALL routers, not just the target — stale rules may exist on a
 	// different VPC's router when vpc.delete-nat (fire-and-forget) hasn't been
diff --git a/spinifex/services/vpcd/topology_test.go b/spinifex/services/vpcd/topology_test.go
index a38518c9c..ec4075c0c 100644
--- a/spinifex/services/vpcd/topology_test.go
+++ b/spinifex/services/vpcd/topology_test.go
@@ -972,6 +972,94 @@ func TestTopologyHandler_AddNAT_InvokesFlowBarrier(t *testing.T) {
 	}
 }
 
+// TestTopologyHandler_AddNAT_Idempotent asserts handleAddNAT does NOT
+// delete-then-re-add the dnat_and_snat rule when the second invocation
+// targets a rule whose state already matches the event (mulga-siv-124).
+// Concurrent duplicate publishes for the same EIP would otherwise tear
+// down the rule the previous invocation just installed, creating a
+// flow-install gap during which the EIP is unreachable.
+//
+// Witness: the row's UUID. If the handler re-ran delete+add the row would
+// be recreated with a fresh UUID; if the handler short-circuits the UUID
+// is preserved. We also confirm the second invocation skips the flow
+// barrier (waitForFlowsHV) — the flow already exists.
+func TestTopologyHandler_AddNAT_Idempotent(t *testing.T) {
+	orig := waitForFlowsHV
+	var barrier int
+	waitForFlowsHV = func() error { barrier++; return nil }
+	defer func() { waitForFlowsHV = orig }()
+
+	_, nc := startTestNATS(t)
+	mock := NewMockOVNClient()
+	_ = mock.Connect(context.Background())
+	ctx := context.Background()
+
+	topo := NewTopologyHandler(mock, WithBridgeMode(BridgeModeVeth))
+	subs, err := topo.Subscribe(nc)
+	require.NoError(t, err)
+	defer func() {
+		for _, s := range subs {
+			_ = s.Unsubscribe()
+		}
+	}()
+
+	require.NoError(t, mock.CreateLogicalRouter(ctx, &nbdb.LogicalRouter{
+		Name: "vpc-vpc-idem",
+		ExternalIDs: map[string]string{
+			"spinifex:vpc_id": "vpc-idem",
+			"spinifex:cidr":   "10.0.0.0/16",
+		},
+	}))
+
+	evt := NATEvent{
+		VpcId:      "vpc-idem",
+		ExternalIP: "192.168.1.244",
+		LogicalIP:  "10.0.1.7",
+		PortName:   "port-eni-idem",
+		MAC:        "02:00:00:cc:cc:cc",
+	}
+	data, _ := json.Marshal(evt)
+
+	// First invocation: rule does not exist → installs + waits for flows.
+	resp, err := nc.Request(TopicAddNAT, data, 5_000_000_000)
+	require.NoError(t, err)
+	assertSuccess(t, resp, "first add-nat")
+
+	router, err := mock.GetLogicalRouter(ctx, "vpc-vpc-idem")
+	require.NoError(t, err)
+	if len(router.NAT) != 1 {
+		t.Fatalf("after first add-nat: expected 1 NAT rule, got %d", len(router.NAT))
+	}
+	firstUUID := router.NAT[0]
+	if barrier != 1 {
+		t.Fatalf("after first add-nat: waitForFlowsHV called %d times, want 1", barrier)
+	}
+
+	// Second invocation with identical event: must short-circuit. The
+	// existing row must survive untouched (same UUID), and the flow
+	// barrier must NOT run again.
+	resp, err = nc.Request(TopicAddNAT, data, 5_000_000_000)
+	require.NoError(t, err)
+	assertSuccess(t, resp, "second add-nat (idempotent)")
+
+	router, err = mock.GetLogicalRouter(ctx, "vpc-vpc-idem")
+	require.NoError(t, err)
+	if len(router.NAT) != 1 {
+		t.Fatalf("after second add-nat: expected 1 NAT rule, got %d", len(router.NAT))
+	}
+	if router.NAT[0] != firstUUID {
+		t.Errorf("second add-nat recreated the NAT row (uuid %q -> %q); delete-then-add was NOT skipped", firstUUID, router.NAT[0])
+	}
+	if barrier != 1 {
+		t.Errorf("second add-nat ran flow barrier: waitForFlowsHV called %d times, want 1", barrier)
+	}
+
+	nat := mock.nats[router.NAT[0]]
+	if nat.LogicalIP != evt.LogicalIP {
+		t.Errorf("NAT logical_ip=%q want %q", nat.LogicalIP, evt.LogicalIP)
+	}
+}
+
 func TestTopologyHandler_IGWAttach_WithExternalPool(t *testing.T) {
 	_, nc := startTestNATS(t)
 	mock := NewMockOVNClient()
diff --git a/tests/e2e/Makefile b/tests/e2e/Makefile
index 8abd5fb9d..6246d6bf9 100644
--- a/tests/e2e/Makefile
+++ b/tests/e2e/Makefile
@@ -35,7 +35,7 @@ e2e:
 e2e-cert:       ; $(MAKE) e2e PKG=./cert/...
 e2e-lb:         ; $(MAKE) e2e PKG=./lb/...
 e2e-single:     ; $(MAKE) e2e PKG=./single/...
-e2e-multinode:  ; $(MAKE) e2e PKG=./multinode/...
+e2e-multinode:  ; $(MAKE) e2e PKG=./multinode/... MODE=multinode
 e2e-bm:         ; $(MAKE) e2e PKG=./baremetal/... MODE=baremetal
 e2e-reboot:     ; $(MAKE) e2e PKG=./reboot/...
 e2e-tofu:       ; $(MAKE) e2e PKG=./tofu/...
diff --git a/tests/e2e/TEST_COVERAGE.md b/tests/e2e/TEST_COVERAGE.md
index 11733fef5..7be72808d 100644
--- a/tests/e2e/TEST_COVERAGE.md
+++ b/tests/e2e/TEST_COVERAGE.md
@@ -603,6 +603,8 @@ Tests that EC2 resources are properly isolated between the Alpha/Beta accounts.
 
 Runs on a real 3-node libvirt cluster provisioned by OpenTofu (`scripts/tofu-cluster/`). Each node is a separate VM with its own OVN, NATS, Predastore, and Spinifex daemon. Bootstrap (`bootstrap.sh`) handles all provisioning before the test script runs.
 
+> **Go port:** every phase below has a `TestMultinode*` counterpart in `tests/e2e/multinode/` (phase N -> `phaseN_*` helper). CI runs the Go suite via the `e2e_go_multinode` job in `.github/workflows/e2e-go.yml`; the bash driver stays in place as the executable spec until the Go run has a soak-tested cadence on `ci-multi`.
+
 ### Bootstrap (pre-test)
 
 1. OpenTofu provisions 3 libvirt VMs (bottlebrush, ironbark, casuarina) with cloud-init
diff --git a/tests/e2e/harness/multinode_aws_via.go b/tests/e2e/harness/multinode_aws_via.go
new file mode 100644
index 000000000..76aa64158
--- /dev/null
+++ b/tests/e2e/harness/multinode_aws_via.go
@@ -0,0 +1,26 @@
+//go:build e2e
+
+package harness
+
+import "testing"
+
+// AWSClientForGateway returns an AWSClient pointed at the named node's
+// gateway endpoint instead of env.ServiceIPs[0]. Used by multinode phases
+// 6 and 7 (cross-node gateway access + cross-node operations) where the
+// test issues describe/stop/start against every node in turn.
+//
+// Bash equivalent: aws_via in run-multinode-e2e.sh — sets AWS_ENDPOINT_URL
+// per call. Here we clone the *Env so the swap is scoped to one call site
+// and concurrent callers can each address a different node safely.
+func AWSClientForGateway(t *testing.T, env *Env, node Node) *AWSClient {
+	t.Helper()
+	if env == nil {
+		t.Fatalf("AWSClientForGateway: nil env")
+	}
+	if node.Addr == "" {
+		t.Fatalf("AWSClientForGateway: node %q has empty addr", node.Name)
+	}
+	scoped := *env
+	scoped.ServiceIPs = []string{node.Addr}
+	return NewAWSClient(t, &scoped)
+}
diff --git a/tests/e2e/harness/multinode_cluster.go b/tests/e2e/harness/multinode_cluster.go
new file mode 100644
index 000000000..39c95e4d2
--- /dev/null
+++ b/tests/e2e/harness/multinode_cluster.go
@@ -0,0 +1,139 @@
+//go:build e2e
+
+package harness
+
+import (
+	"context"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"testing"
+	"time"
+)
+
+// Multinode service ports. Match bash run-multinode-e2e.sh constants.
+const (
+	natsMonitorPort      = 8222
+	predastoreHealthPort = 8443
+	awsgwHealthPort      = 9999
+)
+
+// natsRoutezResponse models the subset of /routez we care about. Bash polled
+// `jq '.routes | unique_by(.remote_id) | length'` — we match by parsing the
+// route slice and counting distinct remote_id values.
+type natsRoutezResponse struct {
+	Routes []struct {
+		RemoteID string `json:"remote_id"`
+	} `json:"routes"`
+}
+
+// WaitNATSPeers polls every node's NATS /routez endpoint until each reports
+// at least want distinct peers. Default timeout 60s / interval 2s — covers
+// the post-join settle window observed in run-multinode-e2e.sh phase 2.
+//
+// NATS monitor binds 127.0.0.1:8222 only (cmd/spinifex/cmd/templates/nats.conf),
+// so the routez query has to land on each node's loopback. Bash uses
+// `peer_ssh "$ip" curl http://127.0.0.1:8222/routez`; we mirror that via
+// PeerSSH + curl rather than dialling node.Addr:8222 directly (which fails
+// with connection refused).
+//
+// Use want=2 on a healthy 3-node cluster (each peer sees the other two via
+// one route — NATS dedupes by remote_id so a 3-node mesh shows 2 unique
+// peers per node). Drops to want=1 after a single-node failure.
+func (c *Cluster) WaitNATSPeers(t *testing.T, want int, opts ...PollOpt) {
+	t.Helper()
+	cfg := applyOpts(pollCfg{timeout: 60 * time.Second, interval: 2 * time.Second}, opts...)
+	ssh := NewPeerSSH()
+
+	EventuallyErr(t, func() error {
+		for _, n := range c.Nodes {
+			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+			out, err := ssh.Run(ctx, n.Addr,
+				fmt.Sprintf("curl -fsS http://127.0.0.1:%d/routez", natsMonitorPort))
+			cancel()
+			if err != nil {
+				return fmt.Errorf("%s NATS /routez via peer_ssh: %w", n.Name, err)
+			}
+			var routez natsRoutezResponse
+			if err := json.Unmarshal(out, &routez); err != nil {
+				return fmt.Errorf("%s NATS /routez decode: %w", n.Name, err)
+			}
+			seen := map[string]struct{}{}
+			for _, r := range routez.Routes {
+				if r.RemoteID == "" {
+					continue
+				}
+				seen[r.RemoteID] = struct{}{}
+			}
+			if len(seen) < want {
+				return fmt.Errorf("%s NATS peers=%d want>=%d", n.Name, len(seen), want)
+			}
+		}
+		return nil
+	}, cfg.timeout, cfg.interval)
+}
+
+// WaitPredastoreHealthy polls every node's Predastore HTTPS endpoint until
+// it returns 2xx. Matches bash verify_predastore_cluster (curl -sk per node).
+func (c *Cluster) WaitPredastoreHealthy(t *testing.T, opts ...PollOpt) {
+	t.Helper()
+	c.waitHTTPSPerNode(t, "Predastore", predastoreHealthPort, "/", opts...)
+}
+
+// WaitGatewayHealthy polls every node's AWS gateway HTTPS endpoint until
+// the TCP+TLS handshake succeeds. Matches bash wait_for_gateway loop.
+func (c *Cluster) WaitGatewayHealthy(t *testing.T, opts ...PollOpt) {
+	t.Helper()
+	c.waitHTTPSPerNode(t, "Gateway", awsgwHealthPort, "/", opts...)
+}
+
+// WaitDaemonReady polls each node's gateway by issuing a cheap
+// DescribeInstanceTypes against that node's gateway endpoint. Matches bash
+// wait_for_daemon_ready — confirms the gateway can route to a live daemon,
+// not just that the gateway socket accepts TLS.
+func (c *Cluster) WaitDaemonReady(t *testing.T, env *Env, opts ...PollOpt) {
+	t.Helper()
+	cfg := applyOpts(pollCfg{timeout: 60 * time.Second, interval: 2 * time.Second}, opts...)
+	EventuallyErr(t, func() error {
+		for _, n := range c.Nodes {
+			cli := AWSClientForGateway(t, env, n)
+			_, err := cli.EC2.DescribeInstanceTypes(nil)
+			if err != nil {
+				return fmt.Errorf("%s DescribeInstanceTypes: %w", n.Name, err)
+			}
+		}
+		return nil
+	}, cfg.timeout, cfg.interval)
+}
+
+func (c *Cluster) waitHTTPSPerNode(t *testing.T, label string, port int, path string, opts ...PollOpt) {
+	t.Helper()
+	cfg := applyOpts(pollCfg{timeout: 60 * time.Second, interval: 2 * time.Second}, opts...)
+	httpc := insecureHTTPClient(cfg.interval)
+	EventuallyErr(t, func() error {
+		for _, n := range c.Nodes {
+			url := fmt.Sprintf("https://%s:%d%s", n.Addr, port, path)
+			resp, err := httpc.Get(url)
+			if err != nil {
+				return fmt.Errorf("%s %s: %w", n.Name, label, err)
+			}
+			_, _ = io.Copy(io.Discard, resp.Body)
+			_ = resp.Body.Close()
+			if resp.StatusCode >= 500 {
+				return fmt.Errorf("%s %s status=%d", n.Name, label, resp.StatusCode)
+			}
+		}
+		return nil
+	}, cfg.timeout, cfg.interval)
+}
+
+func insecureHTTPClient(timeout time.Duration) *http.Client {
+	return &http.Client{
+		Timeout: timeout,
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, //nolint:gosec // health-poll across nodes uses self-signed certs
+		},
+	}
+}
diff --git a/tests/e2e/harness/multinode_diag.go b/tests/e2e/harness/multinode_diag.go
new file mode 100644
index 000000000..7da1db670
--- /dev/null
+++ b/tests/e2e/harness/multinode_diag.go
@@ -0,0 +1,46 @@
+//go:build e2e
+
+package harness
+
+import (
+	"context"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// DumpAllNodeLogs fans out `journalctl -u 'spinifex-*'` per node into the
+// artifact directory. Used by phase 8/9 on failure and by the package
+// TestMain cleanup as a last-resort post-mortem. Tolerates SSH failure on
+// any node — the log dump is best-effort, not a test gate.
+//
+// File naming: artifactsDir/journal-<nodeName>.log. Existing files are
+// overwritten so repeat runs don't accumulate.
+func DumpAllNodeLogs(t *testing.T, c *Cluster, artifactsDir string) {
+	t.Helper()
+	ssh := NewPeerSSH()
+	for _, n := range c.Nodes {
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		out, err := ssh.Run(ctx, n.Addr, "journalctl -u 'spinifex-*' -n 500 --no-pager")
+		cancel()
+		if err != nil {
+			t.Logf("DumpAllNodeLogs: %s journalctl: %v (best-effort, skipping)", n.Name, err)
+			continue
+		}
+		path := filepath.Join(artifactsDir, "journal-"+n.Name+".log")
+		DumpFile(t, filepath.Dir(path), filepath.Base(path), out)
+	}
+}
+
+// SpxGetNodesAcrossCluster runs `spx get nodes` best-effort and returns the
+// raw output stripped of trailing whitespace. Bash phase 9 (run-multinode-e2e
+// .sh:1018) appends `|| echo ""` to swallow a non-zero spx exit — the CLI ↔
+// NATS dial races the cluster join right after node restart and can return
+// "no servers available for connection" even though the data path is healthy
+// (gateway+daemon already verified). Mirror that lenience so phase 9 doesn't
+// fail on a known-flaky CLI dial.
+func SpxGetNodesAcrossCluster(t *testing.T) string {
+	t.Helper()
+	return strings.TrimSpace(SpxRunBestEffort(t, "get", "nodes", "--timeout", "5s"))
+}
diff --git a/tests/e2e/harness/multinode_distribution.go b/tests/e2e/harness/multinode_distribution.go
new file mode 100644
index 000000000..d0932a9a0
--- /dev/null
+++ b/tests/e2e/harness/multinode_distribution.go
@@ -0,0 +1,97 @@
+//go:build e2e
+
+package harness
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+)
+
+// InstanceHostingNode returns the cluster node currently running the named
+// instance's qemu process. Mirrors the bash find_instance_node helper:
+// SSH each node, `ps auxw | grep <instance_id> | grep qemu-system`. Returns
+// nil if no node owns the instance (caller decides whether that's fatal).
+//
+// Skips fix-the-process for the local node (index 0) because the bash uses a
+// direct `ps` instead of SSH for self — but Go runs everywhere as part of
+// the same test binary, so we accept the small redundancy and SSH back to
+// self too. Avoids a special case that the bash had only because of script
+// invocation context.
+func InstanceHostingNode(t *testing.T, c *Cluster, instanceID string) *Node {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	ssh := NewPeerSSH()
+	for i := range c.Nodes {
+		n := c.Nodes[i]
+		out, err := runPSGrep(ctx, ssh, n, instanceID)
+		if err == nil && strings.Contains(out, instanceID) {
+			return &c.Nodes[i]
+		}
+	}
+	return nil
+}
+
+// CountInstancesPerNode fans out a ps grep per node and returns a count by
+// node name. Used by phase 3 distribution checks.
+func CountInstancesPerNode(t *testing.T, c *Cluster, instanceIDs []string) map[string]int {
+	t.Helper()
+	counts := map[string]int{}
+	for _, id := range instanceIDs {
+		if n := InstanceHostingNode(t, c, id); n != nil {
+			counts[n.Name]++
+		}
+	}
+	return counts
+}
+
+// AssertSpreadAcrossNodes fails the test if the given instances don't span
+// at least minNodes distinct cluster members. Bash phase 3 logs but doesn't
+// fail when distribution is sub-optimal — Go matches by accepting minNodes=1
+// (logging only) at the caller's discretion.
+func AssertSpreadAcrossNodes(t *testing.T, c *Cluster, instanceIDs []string, minNodes int) map[string]int {
+	t.Helper()
+	counts := CountInstancesPerNode(t, c, instanceIDs)
+	if len(counts) < minNodes {
+		t.Fatalf("AssertSpreadAcrossNodes: %d instances on %d node(s) (%v), want >= %d nodes",
+			len(instanceIDs), len(counts), counts, minNodes)
+	}
+	return counts
+}
+
+// runPSGrep runs the ps+grep pipeline on a node and returns combined output.
+// Bash uses `ps auxw | grep <id> | grep qemu-system | grep -v grep`; we
+// preserve the same pipeline so future schedulers that change the qemu
+// binary name (e.g. qemu-system-aarch64) surface a single-place change.
+func runPSGrep(ctx context.Context, ssh *PeerSSH, n Node, instanceID string) (string, error) {
+	cmd := fmt.Sprintf("ps auxw | grep %q | grep qemu-system | grep -v grep", instanceID)
+	out, err := ssh.Run(ctx, n.Addr, cmd)
+	if err != nil {
+		// `grep` returns exit 1 when no match; treat that as "no match",
+		// not a transport error.
+		if exitErr, ok := asExitErr(err); ok && exitErr.ExitCode() == 1 {
+			return "", nil
+		}
+		return string(out), err
+	}
+	return string(out), nil
+}
+
+func asExitErr(err error) (*exec.ExitError, bool) {
+	for err != nil {
+		if ee, ok := err.(*exec.ExitError); ok {
+			return ee, true
+		}
+		type unwrapper interface{ Unwrap() error }
+		u, ok := err.(unwrapper)
+		if !ok {
+			return nil, false
+		}
+		err = u.Unwrap()
+	}
+	return nil, false
+}
diff --git a/tests/e2e/harness/multinode_guest_ssh.go b/tests/e2e/harness/multinode_guest_ssh.go
new file mode 100644
index 000000000..f63f0be79
--- /dev/null
+++ b/tests/e2e/harness/multinode_guest_ssh.go
@@ -0,0 +1,112 @@
+//go:build e2e
+
+package harness
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+)
+
+// GuestSSHPort extracts the QEMU hostfwd port for an instance from the
+// hosting node's qemu process command line. Reuses ec2helpers.hostfwdRE
+// (same `hostfwd=tcp:HOST:PORT-:22` pattern). Polls until the qemu
+// process appears (the daemon may still be spawning at the time of the
+// first ssh in). Returns 0 if the port is never observable within the
+// poll window.
+func GuestSSHPort(t *testing.T, hostNode Node, instanceID string, opts ...PollOpt) int {
+	t.Helper()
+	cfg := applyOpts(pollCfg{timeout: 30 * time.Second, interval: 1 * time.Second}, opts...)
+	ssh := NewPeerSSH()
+	var port int
+	EventuallyErr(t, func() error {
+		ctx, cancel := context.WithTimeout(context.Background(), cfg.interval+5*time.Second)
+		defer cancel()
+		out, err := runPSGrep(ctx, ssh, hostNode, instanceID)
+		if err != nil {
+			return fmt.Errorf("%s ps grep: %w", hostNode.Name, err)
+		}
+		m := hostfwdRE.FindStringSubmatch(out)
+		if len(m) < 3 {
+			return fmt.Errorf("%s no hostfwd port for %s yet", hostNode.Name, instanceID)
+		}
+		p, err := strconv.Atoi(m[2])
+		if err != nil {
+			return fmt.Errorf("%s parse hostfwd port %q: %w", hostNode.Name, m[2], err)
+		}
+		port = p
+		return nil
+	}, cfg.timeout, cfg.interval)
+	return port
+}
+
+// GuestSSHEndpoint resolves the (host, port) pair for SSH-ing into a guest
+// VM. Prefers the instance's PublicIpAddress when set; falls back to the
+// hosting node's WAN IP + QEMU hostfwd port. Mirrors the conditional in
+// run-multinode-e2e.sh phase 4.
+//
+// Returns (host, port, nil) on success; t.Fatal on full failure. Public-IP
+// path is the steady-state once OVN's public subnet is wired; the
+// hostfwd path is the legacy fallback for VPCs without public routing.
+func GuestSSHEndpoint(t *testing.T, c *AWSClient, cluster *Cluster, instanceID string, opts ...PollOpt) (host string, port int) {
+	t.Helper()
+
+	inst := WaitForInstanceState(t, c, instanceID, "running", opts...)
+	if pub := aws.StringValue(inst.PublicIpAddress); pub != "" {
+		return pub, 22
+	}
+
+	hostNode := InstanceHostingNode(t, cluster, instanceID)
+	if hostNode == nil {
+		t.Fatalf("GuestSSHEndpoint: no node hosts %s", instanceID)
+	}
+	port = GuestSSHPort(t, *hostNode, instanceID, opts...)
+	if port == 0 {
+		t.Fatalf("GuestSSHEndpoint: hostfwd port not resolved for %s on %s", instanceID, hostNode.Name)
+	}
+	return hostNode.Addr, port
+}
+
+// GuestSSHReady polls SSH into the named instance until a probe command
+// succeeds. Pemfile is the test-scoped private key written by EnsureKeyPair;
+// user defaults to ec2-user (the cloud-init account that spinifex injects
+// regardless of distro family — see handlers/ec2/instance/service_impl.go).
+func GuestSSHReady(t *testing.T, host string, port int, user, pemfile string, opts ...PollOpt) {
+	t.Helper()
+	cfg := applyOpts(pollCfg{timeout: 60 * time.Second, interval: 1 * time.Second}, opts...)
+	target := fmt.Sprintf("%s@%s", user, host)
+
+	EventuallyErr(t, func() error {
+		ctx, cancel := context.WithTimeout(context.Background(), cfg.interval+2*time.Second)
+		defer cancel()
+		args := []string{
+			"-i", pemfile,
+			"-p", strconv.Itoa(port),
+			"-o", "StrictHostKeyChecking=no",
+			"-o", "UserKnownHostsFile=/dev/null",
+			"-o", "ConnectTimeout=2",
+			"-o", "BatchMode=yes",
+			"-o", "LogLevel=ERROR",
+			target,
+			"echo ready",
+		}
+		if err := runSSH(ctx, args); err != nil {
+			return fmt.Errorf("ssh %s:%d: %w", host, port, err)
+		}
+		return nil
+	}, cfg.timeout, cfg.interval)
+}
+
+func runSSH(ctx context.Context, args []string) error {
+	out, err := exec.CommandContext(ctx, "ssh", args...).CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("%w: %s", err, strings.TrimSpace(string(out)))
+	}
+	return nil
+}
diff --git a/tests/e2e/harness/multinode_node_lifecycle.go b/tests/e2e/harness/multinode_node_lifecycle.go
new file mode 100644
index 000000000..3376bce42
--- /dev/null
+++ b/tests/e2e/harness/multinode_node_lifecycle.go
@@ -0,0 +1,63 @@
+//go:build e2e
+
+package harness
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+)
+
+// StopNode stops every spinifex unit on a remote node via
+// `sudo systemctl stop spinifex.target`. Used by phase 8 (node failure).
+// Bash issues the same command and tolerates a non-zero exit because the
+// cluster shutdown sequence racily kills the SSH connection — we mirror
+// that lenience by logging instead of fatal-ing.
+func StopNode(t *testing.T, node Node) {
+	t.Helper()
+	ssh := NewPeerSSH()
+	// spinifex.target has 6+ units (predastore, NATS, awsgw, vpcd, daemon, ui).
+	// stop takes 30-60s in practice; budget 3min to cover slow shutdowns.
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+	defer cancel()
+	if _, err := ssh.Run(ctx, node.Addr, "sudo systemctl stop spinifex.target"); err != nil {
+		t.Logf("StopNode %s: %v (proceeding — bash treats this as non-fatal)", node.Name, err)
+	}
+}
+
+// StartNode brings the spinifex.target back up on a remote node. Used by
+// phase 9 (recovery) and as a t.Cleanup safety net in phase 8 so a
+// cancelled run doesn't leave the cluster degraded for the next suite.
+func StartNode(t *testing.T, node Node) {
+	t.Helper()
+	ssh := NewPeerSSH()
+	// systemctl start on spinifex.target blocks until every dependent unit
+	// is Active=active — predastore + NATS + awsgw + vpcd + daemon + ui can
+	// take 60-90s combined. 30s was too tight and produced "signal: killed"
+	// SSH terminations under context cancel; bump to 5min.
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	if _, err := ssh.Run(ctx, node.Addr, "sudo systemctl start spinifex.target"); err != nil {
+		t.Fatalf("StartNode %s: %v", node.Name, err)
+	}
+}
+
+// WaitNodeServiceReady polls a node's HTTPS gateway until TLS handshake
+// succeeds. Useful after StartNode while the service stack restarts.
+// Distinct from WaitGatewayHealthy (cluster-wide) so a single recovering
+// node can be tracked without re-checking all peers.
+func WaitNodeServiceReady(t *testing.T, node Node, opts ...PollOpt) {
+	t.Helper()
+	cfg := applyOpts(pollCfg{timeout: 60 * time.Second, interval: 2 * time.Second}, opts...)
+	httpc := insecureHTTPClient(cfg.interval)
+	url := fmt.Sprintf("https://%s:%d/", node.Addr, awsgwHealthPort)
+	EventuallyErr(t, func() error {
+		resp, err := httpc.Get(url)
+		if err != nil {
+			return fmt.Errorf("%s gateway %s: %w", node.Name, url, err)
+		}
+		_ = resp.Body.Close()
+		return nil
+	}, cfg.timeout, cfg.interval)
+}
diff --git a/tests/e2e/harness/spxcli.go b/tests/e2e/harness/spxcli.go
index 193415502..e72959709 100644
--- a/tests/e2e/harness/spxcli.go
+++ b/tests/e2e/harness/spxcli.go
@@ -29,6 +29,46 @@ func SpxBin() string {
 	return "spx"
 }
 
+// spxChildEnv returns a sanitized environment for `spx` child processes.
+// spx CLI calls viper.AutomaticEnv() with prefix "SPINIFEX" inside
+// config.LoadConfig (spinifex/spinifex/config/config.go:212), so any
+// SPINIFEX_* env var the harness sets to wire up its own ClusterFromEnv /
+// Env loaders silently overrides the matching cluster.toml field — most
+// notably SPINIFEX_NODES (csv of IPs) clobbers the `nodes` map and leaves
+// NATS.Host empty, surfacing as `nats: no servers available for
+// connection` even though the cluster is healthy (mulga-siv-90 run
+// 26195522455). Strip every SPINIFEX_* except the small set the spx root
+// command actually binds via BindEnv (kept for parity with operator
+// muscle-memory).
+func spxChildEnv() []string {
+	keep := map[string]struct{}{
+		"SPINIFEX_CONFIG_PATH":  {},
+		"SPINIFEX_ACCESS_KEY":   {},
+		"SPINIFEX_SECRET_KEY":   {},
+		"SPINIFEX_HOST":         {},
+		"SPINIFEX_BASE_DIR":     {},
+		"SPINIFEX_NATS_HOST":    {},
+		"SPINIFEX_NATS_TOKEN":   {},
+		"SPINIFEX_NATS_SUBJECT": {},
+	}
+	out := os.Environ()[:0]
+	for _, kv := range os.Environ() {
+		eq := strings.IndexByte(kv, '=')
+		if eq < 0 {
+			out = append(out, kv)
+			continue
+		}
+		k := kv[:eq]
+		if strings.HasPrefix(k, "SPINIFEX_") {
+			if _, ok := keep[k]; !ok {
+				continue
+			}
+		}
+		out = append(out, kv)
+	}
+	return out
+}
+
 // SpxRun runs `spx <args...>` and returns combined stdout+stderr. If wantErr
 // is false the test fails on non-zero exit; if true the call returns the
 // output and the test continues (caller asserts on output content).
@@ -36,6 +76,7 @@ func SpxRun(t *testing.T, wantErr bool, args ...string) string {
 	t.Helper()
 	var buf bytes.Buffer
 	cmd := exec.Command(SpxBin(), args...)
+	cmd.Env = spxChildEnv()
 	cmd.Stdout = &buf
 	cmd.Stderr = &buf
 	err := cmd.Run()
@@ -61,6 +102,22 @@ func SpxGetVMs(t *testing.T) string {
 	return SpxRun(t, false, "get", "vms")
 }
 
+// SpxRunBestEffort runs `spx <args...>` and returns combined output ignoring
+// the exit code. Matches the bash `2>/dev/null` + no exit-check pattern used
+// by `spx get vms` in run-multinode-e2e.sh phases 2-3 — the CLI's NATS dial
+// can race the cluster join shortly after bootstrap without indicating a
+// data-path fault, so a transient non-zero exit shouldn't fail the suite.
+func SpxRunBestEffort(t *testing.T, args ...string) string {
+	t.Helper()
+	var buf bytes.Buffer
+	cmd := exec.Command(SpxBin(), args...)
+	cmd.Env = spxChildEnv()
+	cmd.Stdout = &buf
+	cmd.Stderr = &buf
+	_ = cmd.Run()
+	return buf.String()
+}
+
 // SpxTopNodes runs `spx top nodes`.
 func SpxTopNodes(t *testing.T) string {
 	t.Helper()
diff --git a/tests/e2e/multinode/cluster_health_test.go b/tests/e2e/multinode/cluster_health_test.go
new file mode 100644
index 000000000..24a4898db
--- /dev/null
+++ b/tests/e2e/multinode/cluster_health_test.go
@@ -0,0 +1,56 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+)
+
+// phase2_ClusterHealth is the Go port of `Phase 2: Cluster Health`
+// (run-multinode-e2e.sh:426-510). Verifies the four mesh services
+// (NATS, Predastore, gateway, daemon) are healthy on every node and
+// the `spx get` CLI agrees the cluster is formed.
+//
+// Bash version uses `pass_test` / `fail_test` to accumulate per-check
+// pass counts; the Go port lets each failing sub-check fail the whole
+// test (t.Fatalf) — a single dead node should fail the phase fast.
+func phase2_ClusterHealth(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 2 — Cluster Health")
+
+	harness.Step(t, "NATS unique peers >= 2 per node")
+	fix.Cluster.WaitNATSPeers(t, 2)
+
+	harness.Step(t, "Predastore reachable per node")
+	fix.Cluster.WaitPredastoreHealthy(t)
+
+	harness.Step(t, "Gateway reachable per node")
+	fix.Cluster.WaitGatewayHealthy(t)
+
+	harness.Step(t, "Daemon ready per gateway (DescribeInstanceTypes)")
+	fix.Cluster.WaitDaemonReady(t, fix.Env)
+
+	// Bash phase 2 (run-multinode-e2e.sh:494) wraps `spx get nodes` with
+	// `2>/dev/null` and routes a <3-Ready result through `fail_test` which
+	// merely increments a counter — the bash run keeps going. The Go port
+	// must mirror that lenience: the spx CLI ↔ NATS dial races the cluster
+	// join on cold-bootstrapped CI runners (mulga-siv-90 run 26163994815)
+	// without affecting the data path (gateway+daemon checks above already
+	// confirmed end-to-end NATS reachability). Downgrade to WARN.
+	harness.Step(t, "spx get nodes shows 3 Ready (best-effort)")
+	nodesOut := harness.SpxRunBestEffort(t, "get", "nodes", "--timeout", "5s")
+	harness.Detail(t, "spx_get_nodes", strings.TrimSpace(nodesOut))
+	if ready := readyNodeCount(nodesOut); ready < len(fix.Cluster.Nodes) {
+		t.Logf("WARN: spx get nodes shows %d Ready (want >= %d) — proceeding (bash treats this as non-fatal)\n%s",
+			ready, len(fix.Cluster.Nodes), nodesOut)
+	}
+
+	// Best-effort: bash phase 2 runs `spx get vms --timeout 5s 2>/dev/null`
+	// and never checks the exit code — the CLI ↔ NATS dial can transiently
+	// fail right after cluster join without affecting the data path.
+	harness.Step(t, "spx get vms returns (any result, even empty)")
+	vmsOut := harness.SpxRunBestEffort(t, "get", "vms")
+	harness.Detail(t, "spx_get_vms_bytes", len(vmsOut))
+}
diff --git a/tests/e2e/multinode/crossnode_ops_test.go b/tests/e2e/multinode/crossnode_ops_test.go
new file mode 100644
index 000000000..18a402c4c
--- /dev/null
+++ b/tests/e2e/multinode/crossnode_ops_test.go
@@ -0,0 +1,78 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+	"github.com/stretchr/testify/require"
+)
+
+// phase7_CrossNodeOps is the Go port of phase 7 from
+// run-multinode-e2e.sh:854-895. Picks the first trio instance, finds the
+// node currently hosting it, then drives stop+start through gateways on
+// OTHER nodes — proving the cross-node control path actually reaches the
+// hosting daemon, not just the local one.
+//
+// State guarantee: instance ends running. Other Test*s may share the trio
+// (phase 4 SSH, etc.) so leaving it stopped would cascade-fail downstream
+// tests. Bash phase 7 has the same guarantee implicitly via the start
+// poll at the end.
+func phase7_CrossNodeOps(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 7 — Cross-Node Stop/Start")
+
+	trio := needInstanceTrio(t, fix)
+	require.NotEmpty(t, trio, "trio required")
+	target := trio[0]
+
+	hostNode := harness.InstanceHostingNode(t, fix.Cluster, target)
+	require.NotNil(t, hostNode, "no node hosts %s", target)
+	harness.Detail(t, "target", target, "hosting_node", hostNode.Name)
+
+	stopGW, startGW := otherTwoGateways(fix.Cluster, hostNode)
+	harness.Detail(t, "stop_via", stopGW.Name, "start_via", startGW.Name)
+
+	harness.Step(t, "stop %s via %s", target, stopGW.Name)
+	stopCli := harness.AWSClientForGateway(t, fix.Env, *stopGW)
+	_, err := stopCli.EC2.StopInstances(&ec2.StopInstancesInput{
+		InstanceIds: []*string{aws.String(target)},
+	})
+	require.NoErrorf(t, err, "stop-instances via %s", stopGW.Name)
+	harness.WaitForInstanceState(t, stopCli, target, "stopped",
+		harness.WithTimeout(60*time.Second), harness.WithPoll(2*time.Second))
+
+	harness.Step(t, "start %s via %s", target, startGW.Name)
+	startCli := harness.AWSClientForGateway(t, fix.Env, *startGW)
+	_, err = startCli.EC2.StartInstances(&ec2.StartInstancesInput{
+		InstanceIds: []*string{aws.String(target)},
+	})
+	require.NoErrorf(t, err, "start-instances via %s", startGW.Name)
+	harness.WaitForInstanceState(t, startCli, target, "running",
+		harness.WithTimeout(60*time.Second), harness.WithPoll(2*time.Second))
+}
+
+// otherTwoGateways returns two distinct nodes neither of which is host.
+// Falls back to (other, other) on a 2-node cluster (no third gateway
+// available) — matches the bash fallback.
+func otherTwoGateways(c *harness.Cluster, host *harness.Node) (stop, start *harness.Node) {
+	for i := range c.Nodes {
+		n := &c.Nodes[i]
+		if n.Index == host.Index {
+			continue
+		}
+		if stop == nil {
+			stop = n
+			continue
+		}
+		start = n
+		break
+	}
+	if start == nil {
+		start = stop
+	}
+	return stop, start
+}
diff --git a/tests/e2e/multinode/distribution_test.go b/tests/e2e/multinode/distribution_test.go
new file mode 100644
index 000000000..7631f2360
--- /dev/null
+++ b/tests/e2e/multinode/distribution_test.go
@@ -0,0 +1,44 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+)
+
+// phase3_InstanceDistribution is the Go port of phase 3 from
+// run-multinode-e2e.sh:513-623. Launches a trio of instances and checks
+// at least two cluster nodes host them. Distribution is non-deterministic
+// (scheduler may stack on one node under load) so the bash version
+// warns-not-fails when all three land on the same host. The Go port
+// mirrors: minNodes=1 fatal, log "spread=N" so flaky CI surfaces in
+// metrics without blocking the run.
+func phase3_InstanceDistribution(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 3 — Instance Lifecycle + Distribution")
+
+	ids := needInstanceTrio(t, fix)
+	harness.Detail(t, "instances", ids)
+
+	harness.Step(t, "check distribution across nodes")
+	counts := harness.AssertSpreadAcrossNodes(t, fix.Cluster, ids, 1)
+	harness.Detail(t, "spread", counts, "unique_hosts", len(counts))
+	if len(counts) < 2 {
+		t.Logf("WARN: all %d instances on one node (%v) — non-fatal, scheduler quirk", len(ids), counts)
+	}
+
+	// `spx get vms` is best-effort. Bash phase 3 invokes it with `2>/dev/null`
+	// and downgrades a missing instance to WARN — the underlying CLI ↔ NATS
+	// connection can race the cluster join (mulga-siv-90 CI run 26161792146)
+	// without affecting correctness of the data path. Mirror that: accept
+	// non-zero exit, log when an ID is missing rather than fail.
+	harness.Step(t, "spx get vms includes every launched instance (best-effort)")
+	vms := harness.SpxRunBestEffort(t, "get", "vms")
+	for _, id := range ids {
+		if !strings.Contains(vms, id) {
+			t.Logf("WARN: spx get vms did not list %s", id)
+		}
+	}
+}
diff --git a/tests/e2e/multinode/gateway_test.go b/tests/e2e/multinode/gateway_test.go
new file mode 100644
index 000000000..c08e88655
--- /dev/null
+++ b/tests/e2e/multinode/gateway_test.go
@@ -0,0 +1,51 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"testing"
+
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+	"github.com/stretchr/testify/require"
+)
+
+// phase6_CrossNodeGateway is the Go port of phase 6 from
+// run-multinode-e2e.sh:828-851. Drives DescribeInstances through every
+// node's gateway and asserts each returns the same instance count as
+// node1 (the test runner's local gateway).
+//
+// Catches the regression where the daemon answers only locally-hosted
+// instances instead of fanning out via NATS — i.e. a stale awsgw routing
+// table or a queue-group misconfiguration.
+func phase6_CrossNodeGateway(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 6 — Cross-Node Gateway Access")
+
+	// Trigger trio launch so the baseline count is meaningful.
+	_ = needInstanceTrio(t, fix)
+
+	baseline, err := fix.AWS.EC2.DescribeInstances(&ec2.DescribeInstancesInput{})
+	require.NoError(t, err, "baseline describe-instances")
+	want := countInstances(baseline)
+	harness.Detail(t, "baseline_node", fix.Cluster.Nodes[0].Name, "instances", want)
+	require.Greater(t, want, 0, "baseline returned 0 instances (trio not registered?)")
+
+	// Bash skips node1 (the local one) — its baseline already represents that gateway.
+	for _, n := range fix.Cluster.Nodes[1:] {
+		harness.Step(t, "DescribeInstances via %s (%s)", n.Name, n.Addr)
+		cli := harness.AWSClientForGateway(t, fix.Env, n)
+		out, err := cli.EC2.DescribeInstances(&ec2.DescribeInstancesInput{})
+		require.NoErrorf(t, err, "describe-instances via %s", n.Name)
+		got := countInstances(out)
+		harness.Detail(t, "node", n.Name, "instances", got)
+		require.Equalf(t, want, got, "%s returned %d instances, baseline %d (cross-node fan-out broken)", n.Name, got, want)
+	}
+}
+
+func countInstances(out *ec2.DescribeInstancesOutput) int {
+	n := 0
+	for _, r := range out.Reservations {
+		n += len(r.Instances)
+	}
+	return n
+}
diff --git a/tests/e2e/multinode/guest_ssh_test.go b/tests/e2e/multinode/guest_ssh_test.go
new file mode 100644
index 000000000..a81c08c79
--- /dev/null
+++ b/tests/e2e/multinode/guest_ssh_test.go
@@ -0,0 +1,71 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+)
+
+// phase4_GuestSSH is the Go port of phase 4 from run-multinode-e2e.sh:
+// 626-728. For every instance in the trio, resolve an SSH endpoint
+// (PublicIpAddress or hosting-node hostfwd), wait until SSH answers,
+// and assert `id` reports ec2-user. Also runs `lsblk` as a smoke probe
+// for the root-device wiring.
+func phase4_GuestSSH(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 4 — Guest SSH")
+
+	ids := needInstanceTrio(t, fix)
+	_, pemPath := needKeyPair(t, fix)
+
+	for _, id := range ids {
+		harness.Step(t, "guest_ssh probe %s", id)
+		host, port := harness.GuestSSHEndpoint(t, fix.AWS, fix.Cluster, id)
+		harness.Detail(t, "instance", id, "ssh_host", host, "ssh_port", port)
+
+		harness.GuestSSHReady(t, host, port, "ec2-user", pemPath,
+			harness.WithTimeout(2*time.Minute), harness.WithPoll(2*time.Second))
+
+		idOut := sshRun(t, pemPath, "ec2-user", host, port, "id")
+		harness.Detail(t, "instance", id, "id", strings.TrimSpace(idOut))
+		if !strings.Contains(idOut, "ec2-user") {
+			t.Fatalf("instance %s id output missing ec2-user:\n%s", id, idOut)
+		}
+
+		lsblk := sshRun(t, pemPath, "ec2-user", host, port, "lsblk")
+		// lsblk header line + at least one device row.
+		harness.Detail(t, "instance", id, "lsblk_lines", strings.Count(lsblk, "\n"))
+	}
+}
+
+// sshRun executes cmd over SSH against (user@host:port) using pemPath as
+// the private key. Returns combined stdout+stderr; fatals on non-zero
+// exit. Mirrors the bash ssh invocation in phase 4 (-o flags identical).
+func sshRun(t *testing.T, pemPath, user, host string, port int, cmd string) string {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	args := []string{
+		"-i", pemPath,
+		"-p", strconv.Itoa(port),
+		"-o", "StrictHostKeyChecking=no",
+		"-o", "UserKnownHostsFile=/dev/null",
+		"-o", "ConnectTimeout=5",
+		"-o", "BatchMode=yes",
+		"-o", "LogLevel=ERROR",
+		fmt.Sprintf("%s@%s", user, host),
+		cmd,
+	}
+	out, err := exec.CommandContext(ctx, "ssh", args...).CombinedOutput()
+	if err != nil {
+		t.Fatalf("ssh %s@%s:%d %q failed: %v\n%s", user, host, port, cmd, err, string(out))
+	}
+	return string(out)
+}
diff --git a/tests/e2e/multinode/helpers_test.go b/tests/e2e/multinode/helpers_test.go
new file mode 100644
index 000000000..f9982d026
--- /dev/null
+++ b/tests/e2e/multinode/helpers_test.go
@@ -0,0 +1,146 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+	"github.com/stretchr/testify/require"
+)
+
+// needAZ is a package-local shorthand for the discovered default AZ.
+// Memoized on the harness fixture so every Test* gets the same answer
+// regardless of execution order.
+func needAZ(t *testing.T, fix *Fixture) string {
+	t.Helper()
+	return harness.DiscoverDefaultAZ(t, fix.Harness)
+}
+
+// needInstanceTypeArch returns the discovered nano instance type and its
+// architecture. Memoized on the harness fixture.
+func needInstanceTypeArch(t *testing.T, fix *Fixture) (instanceType, arch string) {
+	t.Helper()
+	return harness.DiscoverNanoInstanceType(t, fix.Harness)
+}
+
+// needAMI returns the discovered Ubuntu AMI for the given architecture.
+// Memoized on the harness fixture.
+func needAMI(t *testing.T, fix *Fixture, arch string) string {
+	t.Helper()
+	return harness.DiscoverUbuntuAMI(t, fix.Harness, arch)
+}
+
+// needKeyPair ensures a test-scoped EC2 key pair and returns its name plus
+// the on-disk PEM path. Memoized on the harness fixture, so every Test*
+// across the package shares the same key (PEM file written once).
+func needKeyPair(t *testing.T, fix *Fixture) (name, pemPath string) {
+	t.Helper()
+	return harness.EnsureKeyPair(t, fix.Harness, fix.Artifacts)
+}
+
+// Package-scoped trio. Phase 3 launches; phases 4–7 reuse the same IDs.
+// Mirrors the iam_helpers_test sync.Once pattern from tests/e2e/single.
+var (
+	trioOnce sync.Once
+	trioIDs  []string
+	trioErr  error
+)
+
+// needInstanceTrio returns the package singleton trio of nano instances on
+// the default VPC, launching them once on first call and registering
+// terminate-on-process-exit. Mirrors bash phase 3 which launches 3 stagger.
+func needInstanceTrio(t *testing.T, fix *Fixture) []string {
+	t.Helper()
+	trioOnce.Do(func() {
+		instType, arch := needInstanceTypeArch(t, fix)
+		amiID := needAMI(t, fix, arch)
+		keyName, _ := needKeyPair(t, fix)
+		def := harness.EnsureDefaultVPC(t, fix.Harness)
+		require.NotEmpty(t, def.SGID, "default SG required")
+		harness.AuthorizeSSHIngress(t, fix.AWS, def.SGID)
+
+		// Bash phase 3 launches with a 2s stagger between calls. Go port
+		// also retries each launch on InsufficientInstanceCapacity — on a
+		// cold-bootstrapped CI cluster (mulga-siv-90 run 26163994815) the
+		// per-node resourceMgr can briefly report 0 capacity right after
+		// daemon start before its first inventory scan completes, even
+		// though DescribeInstanceTypes already answers. AWS itself surfaces
+		// the same error transiently; treat as retryable.
+		input := &ec2.RunInstancesInput{
+			ImageId:          aws.String(amiID),
+			InstanceType:     aws.String(instType),
+			KeyName:          aws.String(keyName),
+			SubnetId:         aws.String(def.SubnetID),
+			SecurityGroupIds: []*string{aws.String(def.SGID)},
+			MinCount:         aws.Int64(1),
+			MaxCount:         aws.Int64(1),
+		}
+		for i := 0; i < 3; i++ {
+			var out *ec2.Reservation
+			var err error
+			for attempt := 1; attempt <= 6; attempt++ {
+				out, err = fix.AWS.EC2.RunInstances(input)
+				if err == nil {
+					break
+				}
+				if !strings.Contains(err.Error(), "InsufficientInstanceCapacity") {
+					break
+				}
+				t.Logf("needInstanceTrio: launch %d attempt %d: InsufficientInstanceCapacity, retrying in 10s", i, attempt)
+				time.Sleep(10 * time.Second)
+			}
+			if err != nil {
+				trioErr = err
+				return
+			}
+			if len(out.Instances) == 0 {
+				trioErr = fmt.Errorf("RunInstances %d: 0 instances returned", i)
+				return
+			}
+			id := aws.StringValue(out.Instances[0].InstanceId)
+			trioIDs = append(trioIDs, id)
+
+			// Process-scoped cleanup — every Test* in the package reuses
+			// the trio, so per-test t.Cleanup would tear down too early.
+			idCopy := id
+			fix.Harness.RegisterCleanup(func() {
+				_, _ = fix.AWS.EC2.TerminateInstances(&ec2.TerminateInstancesInput{
+					InstanceIds: []*string{aws.String(idCopy)},
+				})
+			})
+			// Stagger encourages distribution across nodes (bash sleep 2).
+			if i < 2 {
+				time.Sleep(2 * time.Second)
+			}
+		}
+
+		for _, id := range trioIDs {
+			harness.WaitForInstanceState(t, fix.AWS, id, "running")
+		}
+	})
+	if trioErr != nil {
+		t.Fatalf("needInstanceTrio: %v", trioErr)
+	}
+	return trioIDs
+}
+
+// readyNodeCount counts the number of "Ready" lines in `spx get nodes`
+// output. Bash phase 2 used `grep -c "Ready"`; we match the same
+// (substring, case-sensitive) so cluster-status string drift surfaces in
+// both tracks identically.
+func readyNodeCount(out string) int {
+	n := 0
+	for _, line := range strings.Split(out, "\n") {
+		if strings.Contains(line, "Ready") {
+			n++
+		}
+	}
+	return n
+}
diff --git a/tests/e2e/multinode/main_test.go b/tests/e2e/multinode/main_test.go
new file mode 100644
index 000000000..afab15a32
--- /dev/null
+++ b/tests/e2e/multinode/main_test.go
@@ -0,0 +1,103 @@
+//go:build e2e
+
+// Package multinode is the Go port of run-multinode-e2e.sh — the real
+// 3-node E2E suite that drives the full EC2/VPC/NAT lifecycle against a
+// pre-bootstrapped Spinifex cluster. Each phase from the bash driver runs
+// as a top-level Test* in this package; ordering is not implied — every
+// phase self-bootstraps its prerequisites via harness.Discover* /
+// harness.Ensure* and the package-local need* helpers.
+package multinode
+
+import (
+	"os"
+	"sync"
+	"testing"
+
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+)
+
+// Package-scoped singleton fixture. Mirrors single/main_test.go. Built
+// lazily by the first call to requireMultiNodeFixture so a test run with
+// SPINIFEX_E2E unset stays cheap (no AWS dial, no temp dir).
+var (
+	pkgFixOnce sync.Once
+	pkgFix     *Fixture
+	pkgFixErr  error
+)
+
+// TestMain owns process-level lifecycle for the singleton fixture.
+// harness.Fixture.Close drains every cleanup at process exit, regardless
+// of which Test* created it.
+func TestMain(m *testing.M) {
+	code := m.Run()
+	if pkgFix != nil {
+		if pkgFix.Harness != nil {
+			pkgFix.Harness.Close()
+		}
+		if pkgFix.TmpDir != "" {
+			_ = os.RemoveAll(pkgFix.TmpDir)
+		}
+	}
+	os.Exit(code)
+}
+
+// requireMultiNodeFixture returns the package-scoped Fixture singleton,
+// building it on first call. Skips the calling test if SPINIFEX_E2E is
+// unset or the cluster mode is not multinode. Fails the test if init
+// itself errors (AWS client construction, cluster build).
+func requireMultiNodeFixture(t *testing.T) *Fixture {
+	t.Helper()
+	pkgFixOnce.Do(func() {
+		if os.Getenv("SPINIFEX_E2E") == "" {
+			return
+		}
+		env := harness.LoadEnv(t)
+		if env.Mode != harness.ModeMultinode {
+			return
+		}
+		cluster, cerr := harness.ClusterFromEnv()
+		if cerr != nil {
+			pkgFixErr = cerr
+			return
+		}
+		awsCli := harness.NewAWSClient(t, env)
+		h, herr := harness.NewProcessFixture(awsCli)
+		if herr != nil {
+			pkgFixErr = herr
+			return
+		}
+		tmpDir, terr := os.MkdirTemp("", "multinode-pkgfix-*")
+		if terr != nil {
+			pkgFixErr = terr
+			return
+		}
+		pkgFix = &Fixture{
+			Env:       env,
+			AWS:       awsCli,
+			Harness:   h,
+			Cluster:   cluster,
+			Artifacts: harness.ArtifactDir(t, env),
+			TmpDir:    tmpDir,
+		}
+	})
+	if pkgFixErr != nil {
+		t.Fatalf("multinode singleton fixture init failed: %v", pkgFixErr)
+	}
+	if pkgFix == nil {
+		t.Skip("multinode singleton fixture unavailable (SPINIFEX_E2E unset or mode != multinode)")
+	}
+	return pkgFix
+}
+
+// Fixture carries the per-process state shared across every Test* in this
+// package. Only environment-level slots — every per-phase resource ID is
+// memoized on Harness (harness.Fixture) and surfaced via the package-local
+// need* helpers / harness.Ensure* + harness.Discover*.
+type Fixture struct {
+	Env       *harness.Env
+	AWS       *harness.AWSClient
+	Harness   *harness.Fixture // memoized Ensure* fixture; spans the whole process.
+	Cluster   *harness.Cluster // 3-node WAN-IP cluster from SPINIFEX_NODES.
+	Artifacts string
+	TmpDir    string // package-scoped scratch dir; survives every Test* in the package.
+}
diff --git a/tests/e2e/multinode/node_failure_test.go b/tests/e2e/multinode/node_failure_test.go
new file mode 100644
index 000000000..f1a3b5788
--- /dev/null
+++ b/tests/e2e/multinode/node_failure_test.go
@@ -0,0 +1,68 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+	"github.com/stretchr/testify/require"
+)
+
+// phase8_NodeFailure is the Go port of phase 8 from
+// run-multinode-e2e.sh:898-957. Stops spinifex.target on node2,
+// asserts the cluster degrades cleanly: surviving nodes still serve
+// DescribeInstances, NATS reports 1 peer instead of 2, and the trio
+// remains addressable.
+//
+// Registers a t.Cleanup that restarts node2 unconditionally so a
+// cancelled phase 9 doesn't leave the cluster broken for downstream
+// tests. Phase 9 itself runs the recovery assertions explicitly.
+func phase8_NodeFailure(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 8 — Node Failure")
+
+	// Trio must already exist — node2 going down shouldn't cause a
+	// race with trio launches issuing through that node's gateway.
+	_ = needInstanceTrio(t, fix)
+	require.GreaterOrEqualf(t, len(fix.Cluster.Nodes), 3, "phase 8 requires a 3-node cluster, have %d", len(fix.Cluster.Nodes))
+	node2 := fix.Cluster.Nodes[1]
+	node3 := fix.Cluster.Nodes[2]
+	local := fix.Cluster.Nodes[0]
+
+	harness.Step(t, "stop spinifex.target on %s (%s)", node2.Name, node2.Addr)
+	harness.StopNode(t, node2)
+	t.Cleanup(func() {
+		// Best-effort: ensure node2 comes back even if assertions below
+		// fail or the run is cancelled. Phase 9 calls StartNode again —
+		// systemctl start is idempotent.
+		harness.StartNode(t, node2)
+	})
+
+	// NATS detection of a peer drop is delayed by the heartbeat — bash
+	// uses `sleep 10`. WaitNATSPeers polls so we converge faster on a
+	// healthy run while still tolerating a slow detection.
+	harness.Step(t, "wait NATS to report 1 peer (degraded)")
+	fix.Cluster.WaitNATSPeers(t, 1, harness.WithTimeout(30*time.Second), harness.WithPoll(2*time.Second))
+
+	harness.Step(t, "DescribeInstanceTypes still answers via %s", local.Name)
+	localCli := harness.AWSClientForGateway(t, fix.Env, local)
+	_, err := localCli.EC2.DescribeInstanceTypes(nil)
+	require.NoErrorf(t, err, "%s describe-instance-types during node2 failure", local.Name)
+
+	harness.Step(t, "DescribeInstanceTypes still answers via %s", node3.Name)
+	node3Cli := harness.AWSClientForGateway(t, fix.Env, node3)
+	_, err = node3Cli.EC2.DescribeInstanceTypes(nil)
+	require.NoErrorf(t, err, "%s describe-instance-types during node2 failure", node3.Name)
+
+	harness.Step(t, "DescribeInstances still returns >0 from %s", local.Name)
+	out, err := localCli.EC2.DescribeInstances(&ec2.DescribeInstancesInput{})
+	require.NoError(t, err, "describe-instances during failure")
+	total := 0
+	for _, r := range out.Reservations {
+		total += len(r.Instances)
+	}
+	harness.Detail(t, "instances_visible", total)
+	require.Greaterf(t, total, 0, "no instances visible from %s during node2 failure", local.Name)
+}
diff --git a/tests/e2e/multinode/node_recovery_test.go b/tests/e2e/multinode/node_recovery_test.go
new file mode 100644
index 000000000..4caa338b1
--- /dev/null
+++ b/tests/e2e/multinode/node_recovery_test.go
@@ -0,0 +1,53 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"testing"
+	"time"
+
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+	"github.com/stretchr/testify/require"
+)
+
+// phase9_NodeRecovery is the Go port of phase 9 from
+// run-multinode-e2e.sh:961-1037. Starts spinifex.target on node2,
+// waits for NATS to reform to 2 peers, gateway to answer, spx get
+// nodes to show 3 Ready, and node2's gateway to answer
+// DescribeInstanceTypes.
+//
+// Idempotent: if phase 8 didn't actually take node2 down (e.g.
+// `go test -run TestMultinodeNodeRecovery` in isolation), the StartNode
+// call no-ops and the assertions still hold.
+func phase9_NodeRecovery(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 9 — Node Recovery")
+
+	require.GreaterOrEqualf(t, len(fix.Cluster.Nodes), 3, "phase 9 requires a 3-node cluster, have %d", len(fix.Cluster.Nodes))
+	node2 := fix.Cluster.Nodes[1]
+
+	harness.Step(t, "start spinifex.target on %s (%s)", node2.Name, node2.Addr)
+	harness.StartNode(t, node2)
+
+	harness.Step(t, "wait NATS to reform to 2 peers")
+	fix.Cluster.WaitNATSPeers(t, 2, harness.WithTimeout(2*time.Minute), harness.WithPoll(2*time.Second))
+
+	harness.Step(t, "wait %s gateway to answer HTTPS", node2.Name)
+	harness.WaitNodeServiceReady(t, node2, harness.WithTimeout(60*time.Second), harness.WithPoll(2*time.Second))
+
+	// Bash phase 9 (run-multinode-e2e.sh:1018) appends `|| echo ""` to swallow
+	// a non-zero spx exit and never checks Ready count strictly — recovery is
+	// gated on the gateway DescribeInstanceTypes call below, which actually
+	// proves end-to-end NATS routing through node2. Downgrade spx to WARN.
+	harness.Step(t, "spx get nodes shows %d Ready after recovery (best-effort)", len(fix.Cluster.Nodes))
+	out := harness.SpxGetNodesAcrossCluster(t)
+	harness.Detail(t, "spx_get_nodes", out)
+	if ready := readyNodeCount(out); ready < len(fix.Cluster.Nodes) {
+		t.Logf("WARN: spx get nodes shows %d Ready after recovery (want >= %d) — proceeding (bash treats this as non-fatal)\n%s",
+			ready, len(fix.Cluster.Nodes), out)
+	}
+
+	harness.Step(t, "DescribeInstanceTypes answers via %s after recovery", node2.Name)
+	cli := harness.AWSClientForGateway(t, fix.Env, node2)
+	_, err := cli.EC2.DescribeInstanceTypes(nil)
+	require.NoErrorf(t, err, "%s describe-instance-types after recovery", node2.Name)
+}
diff --git a/tests/e2e/multinode/placement_nat_test.go b/tests/e2e/multinode/placement_nat_test.go
new file mode 100644
index 000000000..1ccb4161e
--- /dev/null
+++ b/tests/e2e/multinode/placement_nat_test.go
@@ -0,0 +1,782 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+	"github.com/stretchr/testify/require"
+)
+
+// phase11_PlacementAndNATGateway is the Go port of phase 11 from
+// run-multinode-e2e.sh:1255-1594. The largest single phase — bash spans
+// 8 sub-steps. The Go port keeps the same sub-step boundaries (Step1..Step8)
+// in harness.Step lines so a triager can cross-reference logs.
+//
+// Sub-steps:
+//
+//	Step 1: VPC + public/private subnets + IGW + main RT route + SGs
+//	Step 2: Bastion in public subnet, wait SSH, scp key
+//	Step 3: Spread placement group + 3 private instances
+//	Step 4: Validate spread across nodes (>=2 unique nodes; >=3 = PASS)
+//	Step 5: Verify private VMs have NO internet pre-NAT
+//	Step 6: Create NAT GW (EIP + create-nat-gateway + priv RT + route)
+//	Step 7: Verify internet via NAT GW from all 3 private VMs
+//	Step 8: Cleanup NAT GW resources inline
+//
+// Every resource is owned by the test — no Ensure* memoization — so a
+// failure mid-flight tears the full VPC graph down via t.Cleanup (LIFO).
+// Bash mirrors the same teardown order.
+func phase11_PlacementAndNATGateway(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 11 — Spread Placement + NAT Gateway")
+
+	require.GreaterOrEqualf(t, len(fix.Cluster.Nodes), 3,
+		"phase 11 requires a 3-node cluster, have %d", len(fix.Cluster.Nodes))
+
+	amiID := needAMI(t, fix, needArch(t, fix))
+	instType, _ := needInstanceTypeArch(t, fix)
+	keyName, keyPath := needKeyPair(t, fix)
+	c := fix.AWS
+
+	// --- Step 1: VPC infrastructure ---------------------------------------
+	harness.Step(t, "Step 1 — create VPC + subnets + IGW + SGs")
+
+	vpcOut, err := c.EC2.CreateVpc(&ec2.CreateVpcInput{
+		CidrBlock: aws.String("10.100.0.0/16"),
+	})
+	require.NoError(t, err, "create-vpc 10.100.0.0/16")
+	vpcID := aws.StringValue(vpcOut.Vpc.VpcId)
+	require.NotEmpty(t, vpcID, "VpcId empty")
+	t.Cleanup(func() {
+		_, _ = c.EC2.DeleteVpc(&ec2.DeleteVpcInput{VpcId: aws.String(vpcID)})
+	})
+
+	pubSubOut, err := c.EC2.CreateSubnet(&ec2.CreateSubnetInput{
+		VpcId:     aws.String(vpcID),
+		CidrBlock: aws.String("10.100.1.0/24"),
+	})
+	require.NoError(t, err, "create public subnet")
+	pubSubnetID := aws.StringValue(pubSubOut.Subnet.SubnetId)
+	t.Cleanup(func() {
+		_, _ = c.EC2.DeleteSubnet(&ec2.DeleteSubnetInput{SubnetId: aws.String(pubSubnetID)})
+	})
+
+	privSubOut, err := c.EC2.CreateSubnet(&ec2.CreateSubnetInput{
+		VpcId:     aws.String(vpcID),
+		CidrBlock: aws.String("10.100.2.0/24"),
+	})
+	require.NoError(t, err, "create private subnet")
+	privSubnetID := aws.StringValue(privSubOut.Subnet.SubnetId)
+	t.Cleanup(func() {
+		_, _ = c.EC2.DeleteSubnet(&ec2.DeleteSubnetInput{SubnetId: aws.String(privSubnetID)})
+	})
+
+	// Public subnet MapPublicIpOnLaunch — bastion picks up routable IP.
+	_, err = c.EC2.ModifySubnetAttribute(&ec2.ModifySubnetAttributeInput{
+		SubnetId:            aws.String(pubSubnetID),
+		MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
+	})
+	require.NoError(t, err, "modify-subnet-attribute MapPublicIpOnLaunch")
+
+	igwOut, err := c.EC2.CreateInternetGateway(&ec2.CreateInternetGatewayInput{})
+	require.NoError(t, err, "create-internet-gateway")
+	igwID := aws.StringValue(igwOut.InternetGateway.InternetGatewayId)
+	igwDetached := false
+	t.Cleanup(func() {
+		if !igwDetached {
+			_, _ = c.EC2.DetachInternetGateway(&ec2.DetachInternetGatewayInput{
+				InternetGatewayId: aws.String(igwID),
+				VpcId:             aws.String(vpcID),
+			})
+		}
+		_, _ = c.EC2.DeleteInternetGateway(&ec2.DeleteInternetGatewayInput{
+			InternetGatewayId: aws.String(igwID),
+		})
+	})
+	_, err = c.EC2.AttachInternetGateway(&ec2.AttachInternetGatewayInput{
+		InternetGatewayId: aws.String(igwID),
+		VpcId:             aws.String(vpcID),
+	})
+	require.NoError(t, err, "attach-internet-gateway")
+
+	// Find main route table for the VPC (auto-created by CreateVpc) and
+	// add a 0.0.0.0/0 -> IGW route so the public subnet has egress.
+	mainRT, err := c.EC2.DescribeRouteTables(&ec2.DescribeRouteTablesInput{
+		Filters: []*ec2.Filter{
+			{Name: aws.String("vpc-id"), Values: []*string{aws.String(vpcID)}},
+		},
+	})
+	require.NoError(t, err, "describe-route-tables (main)")
+	require.NotEmpty(t, mainRT.RouteTables, "no main route table for fresh VPC")
+	mainRTBID := aws.StringValue(mainRT.RouteTables[0].RouteTableId)
+	_, err = c.EC2.CreateRoute(&ec2.CreateRouteInput{
+		RouteTableId:         aws.String(mainRTBID),
+		DestinationCidrBlock: aws.String("0.0.0.0/0"),
+		GatewayId:            aws.String(igwID),
+	})
+	require.NoError(t, err, "create-route main RT -> IGW")
+
+	// SGs: bastion (tcp/22 from anywhere) + private (tcp/22 from bastion-sg,
+	// icmp from VPC).
+	bastionSGOut, err := c.EC2.CreateSecurityGroup(&ec2.CreateSecurityGroupInput{
+		VpcId:       aws.String(vpcID),
+		GroupName:   aws.String("natgw-bastion"),
+		Description: aws.String("Phase 11 bastion (SSH ingress from anywhere)"),
+	})
+	require.NoError(t, err, "create bastion SG")
+	bastionSGID := aws.StringValue(bastionSGOut.GroupId)
+	t.Cleanup(func() {
+		_, _ = c.EC2.DeleteSecurityGroup(&ec2.DeleteSecurityGroupInput{
+			GroupId: aws.String(bastionSGID),
+		})
+	})
+	_, err = c.EC2.AuthorizeSecurityGroupIngress(&ec2.AuthorizeSecurityGroupIngressInput{
+		GroupId: aws.String(bastionSGID),
+		IpPermissions: []*ec2.IpPermission{
+			{
+				IpProtocol: aws.String("tcp"),
+				FromPort:   aws.Int64(22),
+				ToPort:     aws.Int64(22),
+				IpRanges:   []*ec2.IpRange{{CidrIp: aws.String("0.0.0.0/0")}},
+			},
+		},
+	})
+	require.NoError(t, err, "authorize bastion SG tcp/22")
+
+	privSGOut, err := c.EC2.CreateSecurityGroup(&ec2.CreateSecurityGroupInput{
+		VpcId:       aws.String(vpcID),
+		GroupName:   aws.String("natgw-private"),
+		Description: aws.String("Phase 11 private (SSH from bastion-sg, ICMP from VPC)"),
+	})
+	require.NoError(t, err, "create private SG")
+	privSGID := aws.StringValue(privSGOut.GroupId)
+	t.Cleanup(func() {
+		_, _ = c.EC2.DeleteSecurityGroup(&ec2.DeleteSecurityGroupInput{
+			GroupId: aws.String(privSGID),
+		})
+	})
+	// tcp/22 from bastion-sg via UserIdGroupPair
+	_, err = c.EC2.AuthorizeSecurityGroupIngress(&ec2.AuthorizeSecurityGroupIngressInput{
+		GroupId: aws.String(privSGID),
+		IpPermissions: []*ec2.IpPermission{
+			{
+				IpProtocol: aws.String("tcp"),
+				FromPort:   aws.Int64(22),
+				ToPort:     aws.Int64(22),
+				UserIdGroupPairs: []*ec2.UserIdGroupPair{
+					{GroupId: aws.String(bastionSGID)},
+				},
+			},
+		},
+	})
+	require.NoError(t, err, "authorize private SG tcp/22 from bastion-sg")
+	// icmp from VPC CIDR
+	_, err = c.EC2.AuthorizeSecurityGroupIngress(&ec2.AuthorizeSecurityGroupIngressInput{
+		GroupId: aws.String(privSGID),
+		IpPermissions: []*ec2.IpPermission{
+			{
+				IpProtocol: aws.String("icmp"),
+				FromPort:   aws.Int64(-1),
+				ToPort:     aws.Int64(-1),
+				IpRanges:   []*ec2.IpRange{{CidrIp: aws.String("10.100.0.0/16")}},
+			},
+		},
+	})
+	require.NoError(t, err, "authorize private SG icmp from VPC")
+	harness.Detail(t, "vpc", vpcID, "pub_subnet", pubSubnetID, "priv_subnet", privSubnetID,
+		"igw", igwID, "bastion_sg", bastionSGID, "priv_sg", privSGID)
+
+	// --- Step 2: Bastion ---------------------------------------------------
+	harness.Step(t, "Step 2 — launch bastion in public subnet")
+	bastionOut, err := c.EC2.RunInstances(&ec2.RunInstancesInput{
+		ImageId:          aws.String(amiID),
+		InstanceType:     aws.String(instType),
+		KeyName:          aws.String(keyName),
+		SubnetId:         aws.String(pubSubnetID),
+		SecurityGroupIds: []*string{aws.String(bastionSGID)},
+		MinCount:         aws.Int64(1),
+		MaxCount:         aws.Int64(1),
+	})
+	require.NoError(t, err, "run-instances bastion")
+	require.NotEmpty(t, bastionOut.Instances, "run-instances bastion returned no Instances")
+	bastionID := aws.StringValue(bastionOut.Instances[0].InstanceId)
+	require.NotEmpty(t, bastionID, "bastion InstanceId empty")
+	t.Cleanup(func() {
+		_, _ = c.EC2.TerminateInstances(&ec2.TerminateInstancesInput{
+			InstanceIds: []*string{aws.String(bastionID)},
+		})
+		_ = waitForInstanceStateBest(c, bastionID, "terminated", 5*time.Minute)
+	})
+
+	bastion := harness.WaitForInstanceState(t, c, bastionID, "running",
+		harness.WithTimeout(120*time.Second), harness.WithPoll(2*time.Second))
+	bastionPubIP := aws.StringValue(bastion.PublicIpAddress)
+	require.NotEmptyf(t, bastionPubIP,
+		"bastion %s has no PublicIpAddress (pool mode required for phase 11)", bastionID)
+	harness.Detail(t, "bastion", bastionID, "bastion_pub_ip", bastionPubIP)
+
+	// On failure from this point, capture cluster-wide datapath state.
+	// veth bridge mode (run 26198221557 journal) routes all EIP ingress
+	// through the priority-20 gateway-chassis; with a 3-node cluster the
+	// gw chassis is the same node as the bastion only ~33% of the time,
+	// so ARP + geneve traversal need to be observed to localise SYN drops.
+	t.Cleanup(func() {
+		if t.Failed() {
+			dumpPlacementNATDiag(t, fix, bastionPubIP, bastionID)
+		}
+	})
+
+	waitForBastionSSH(t, bastionPubIP, keyPath, 5*time.Minute)
+	scpKeyToBastion(t, keyPath, bastionPubIP)
+
+	// --- Step 3: Placement group + 3 private VMs --------------------------
+	harness.Step(t, "Step 3 — create spread placement group + 3 private VMs")
+	pgName := "nat-spread"
+	_, err = c.EC2.CreatePlacementGroup(&ec2.CreatePlacementGroupInput{
+		GroupName: aws.String(pgName),
+		Strategy:  aws.String("spread"),
+	})
+	require.NoError(t, err, "create-placement-group nat-spread")
+	t.Cleanup(func() {
+		_, _ = c.EC2.DeletePlacementGroup(&ec2.DeletePlacementGroupInput{
+			GroupName: aws.String(pgName),
+		})
+	})
+
+	privOut, err := c.EC2.RunInstances(&ec2.RunInstancesInput{
+		ImageId:          aws.String(amiID),
+		InstanceType:     aws.String(instType),
+		KeyName:          aws.String(keyName),
+		SubnetId:         aws.String(privSubnetID),
+		SecurityGroupIds: []*string{aws.String(privSGID)},
+		MinCount:         aws.Int64(3),
+		MaxCount:         aws.Int64(3),
+		Placement: &ec2.Placement{
+			GroupName: aws.String(pgName),
+		},
+	})
+	require.NoError(t, err, "run-instances private x3")
+	require.Lenf(t, privOut.Instances, 3, "run-instances private returned %d instances", len(privOut.Instances))
+	var privIDs []string
+	for _, inst := range privOut.Instances {
+		id := aws.StringValue(inst.InstanceId)
+		require.NotEmpty(t, id, "private InstanceId empty")
+		privIDs = append(privIDs, id)
+		idCopy := id
+		t.Cleanup(func() {
+			_, _ = c.EC2.TerminateInstances(&ec2.TerminateInstancesInput{
+				InstanceIds: []*string{aws.String(idCopy)},
+			})
+			_ = waitForInstanceStateBest(c, idCopy, "terminated", 5*time.Minute)
+		})
+	}
+	harness.Detail(t, "private_ids", privIDs)
+
+	for _, id := range privIDs {
+		harness.WaitForInstanceState(t, c, id, "running",
+			harness.WithTimeout(120*time.Second), harness.WithPoll(2*time.Second))
+	}
+
+	// --- Step 4: Validate spread across nodes -----------------------------
+	harness.Step(t, "Step 4 — validate spread placement across nodes")
+	hostingNodes := make([]string, 0, len(privIDs))
+	for _, id := range privIDs {
+		n := harness.InstanceHostingNode(t, fix.Cluster, id)
+		if n == nil {
+			hostingNodes = append(hostingNodes, "unknown")
+			harness.Detail(t, "instance", id, "host", "unknown")
+			continue
+		}
+		hostingNodes = append(hostingNodes, n.Name)
+		harness.Detail(t, "instance", id, "host", n.Name)
+	}
+	unique := uniqueCount(hostingNodes)
+	harness.Detail(t, "unique_hosting_nodes", unique, "want_ge", 3)
+	if unique >= 3 {
+		// nominal — full spread
+	} else if unique >= 2 {
+		t.Logf("WARN: only %d unique hosting nodes (expected 3) — spread best-effort", unique)
+	} else {
+		t.Fatalf("spread placement failed: %d unique hosting nodes (want >= 2), hosts=%v", unique, hostingNodes)
+	}
+
+	// Collect private IPs for the bastion-hop probes.
+	privIPs := make([]string, 0, len(privIDs))
+	for _, id := range privIDs {
+		out, err := c.EC2.DescribeInstances(&ec2.DescribeInstancesInput{
+			InstanceIds: []*string{aws.String(id)},
+		})
+		require.NoError(t, err, "describe-instances private")
+		require.NotEmpty(t, out.Reservations, "no Reservations for %s", id)
+		require.NotEmpty(t, out.Reservations[0].Instances, "no Instances for %s", id)
+		ip := aws.StringValue(out.Reservations[0].Instances[0].PrivateIpAddress)
+		require.NotEmptyf(t, ip, "%s has no PrivateIpAddress", id)
+		privIPs = append(privIPs, ip)
+	}
+	harness.Detail(t, "private_ips", privIPs)
+
+	// Wait for SSH via bastion to every private VM. Cloud-init can drag
+	// 30-40s past "running".
+	harness.Step(t, "wait for private SSH via bastion (x%d)", len(privIPs))
+	for i, privIP := range privIPs {
+		waitForSSHViaBastion(t, keyPath, bastionPubIP, privIP, fmt.Sprintf("priv #%d (%s)", i, privIDs[i]))
+	}
+
+	// --- Step 5: Verify NO internet pre-NAT --------------------------------
+	harness.Step(t, "Step 5 — verify private VMs have NO internet pre-NAT")
+	for i, privIP := range privIPs {
+		if _, err := pingViaBastion(keyPath, bastionPubIP, privIP); err == nil {
+			t.Fatalf("baseline FAIL: %s (%s) can reach internet WITHOUT NAT GW", privIDs[i], privIP)
+		}
+		harness.Detail(t, "pre_nat", privIDs[i], "reachable", false)
+	}
+
+	// --- Step 6: Create NAT Gateway ----------------------------------------
+	harness.Step(t, "Step 6 — allocate EIP + create NAT GW + private RT")
+	eipOut, err := c.EC2.AllocateAddress(&ec2.AllocateAddressInput{
+		Domain: aws.String("vpc"),
+	})
+	require.NoError(t, err, "allocate-address vpc")
+	natAllocID := aws.StringValue(eipOut.AllocationId)
+	natPubIP := aws.StringValue(eipOut.PublicIp)
+	require.NotEmpty(t, natAllocID, "EIP AllocationId empty")
+	eipReleased := false
+	t.Cleanup(func() {
+		if !eipReleased {
+			_, _ = c.EC2.ReleaseAddress(&ec2.ReleaseAddressInput{
+				AllocationId: aws.String(natAllocID),
+			})
+		}
+	})
+	harness.Detail(t, "eip", natPubIP, "alloc", natAllocID)
+
+	natOut, err := c.EC2.CreateNatGateway(&ec2.CreateNatGatewayInput{
+		SubnetId:     aws.String(pubSubnetID),
+		AllocationId: aws.String(natAllocID),
+	})
+	require.NoError(t, err, "create-nat-gateway")
+	natGWID := aws.StringValue(natOut.NatGateway.NatGatewayId)
+	require.NotEmpty(t, natGWID, "NatGatewayId empty")
+	natDeleted := false
+	t.Cleanup(func() {
+		if !natDeleted {
+			_, _ = c.EC2.DeleteNatGateway(&ec2.DeleteNatGatewayInput{
+				NatGatewayId: aws.String(natGWID),
+			})
+			_ = waitForNATGatewayStateBest(c, natGWID, "deleted", 5*time.Minute)
+		}
+	})
+	harness.Detail(t, "nat_gw", natGWID)
+	waitForNATGatewayStateFatal(t, c, natGWID, "available")
+
+	// Private route table + association + 0.0.0.0/0 -> NAT GW
+	privRTOut, err := c.EC2.CreateRouteTable(&ec2.CreateRouteTableInput{
+		VpcId: aws.String(vpcID),
+	})
+	require.NoError(t, err, "create-route-table (private)")
+	privRTBID := aws.StringValue(privRTOut.RouteTable.RouteTableId)
+	require.NotEmpty(t, privRTBID, "private RouteTableId empty")
+	rtbDeleted := false
+	t.Cleanup(func() {
+		if !rtbDeleted {
+			_, _ = c.EC2.DeleteRouteTable(&ec2.DeleteRouteTableInput{
+				RouteTableId: aws.String(privRTBID),
+			})
+		}
+	})
+
+	rtbAssocOut, err := c.EC2.AssociateRouteTable(&ec2.AssociateRouteTableInput{
+		RouteTableId: aws.String(privRTBID),
+		SubnetId:     aws.String(privSubnetID),
+	})
+	require.NoError(t, err, "associate private RT")
+	rtbAssocID := aws.StringValue(rtbAssocOut.AssociationId)
+	assocReleased := false
+	t.Cleanup(func() {
+		if !assocReleased {
+			_, _ = c.EC2.DisassociateRouteTable(&ec2.DisassociateRouteTableInput{
+				AssociationId: aws.String(rtbAssocID),
+			})
+		}
+	})
+
+	_, err = c.EC2.CreateRoute(&ec2.CreateRouteInput{
+		RouteTableId:         aws.String(privRTBID),
+		DestinationCidrBlock: aws.String("0.0.0.0/0"),
+		NatGatewayId:         aws.String(natGWID),
+	})
+	require.NoError(t, err, "create-route 0.0.0.0/0 -> NAT GW")
+	routeDeleted := false
+	t.Cleanup(func() {
+		if !routeDeleted {
+			_, _ = c.EC2.DeleteRoute(&ec2.DeleteRouteInput{
+				RouteTableId:         aws.String(privRTBID),
+				DestinationCidrBlock: aws.String("0.0.0.0/0"),
+			})
+		}
+	})
+
+	// --- Step 7: Verify internet via NAT GW from all 3 ------------------
+	harness.Step(t, "Step 7 — verify internet via NAT GW (x%d)", len(privIPs))
+	for i, privIP := range privIPs {
+		host := hostingNodes[i]
+		harness.EventuallyErr(t, func() error {
+			if _, err := pingViaBastion(keyPath, bastionPubIP, privIP); err != nil {
+				return fmt.Errorf("ping via NAT GW (%s on %s): %w", privIDs[i], host, err)
+			}
+			return nil
+		}, 90*time.Second, 5*time.Second)
+		harness.Detail(t, "post_nat", privIDs[i], "node", host, "reachable", true)
+	}
+
+	// --- Step 8: Cleanup NAT GW resources (inline; teardown flips flags) -
+	harness.Step(t, "Step 8 — cleanup NAT GW + private RT")
+	_, err = c.EC2.DeleteRoute(&ec2.DeleteRouteInput{
+		RouteTableId:         aws.String(privRTBID),
+		DestinationCidrBlock: aws.String("0.0.0.0/0"),
+	})
+	require.NoError(t, err, "delete-route 0.0.0.0/0")
+	routeDeleted = true
+
+	_, err = c.EC2.DisassociateRouteTable(&ec2.DisassociateRouteTableInput{
+		AssociationId: aws.String(rtbAssocID),
+	})
+	require.NoError(t, err, "disassociate private RT")
+	assocReleased = true
+
+	_, err = c.EC2.DeleteRouteTable(&ec2.DeleteRouteTableInput{
+		RouteTableId: aws.String(privRTBID),
+	})
+	require.NoError(t, err, "delete private RT")
+	rtbDeleted = true
+
+	_, err = c.EC2.DeleteNatGateway(&ec2.DeleteNatGatewayInput{
+		NatGatewayId: aws.String(natGWID),
+	})
+	require.NoError(t, err, "delete-nat-gateway")
+	waitForNATGatewayStateFatal(t, c, natGWID, "deleted")
+	natDeleted = true
+
+	_, err = c.EC2.ReleaseAddress(&ec2.ReleaseAddressInput{
+		AllocationId: aws.String(natAllocID),
+	})
+	require.NoError(t, err, "release-address")
+	eipReleased = true
+
+	// IGW detach + delete still runs as a unit at the registered t.Cleanup
+	// above (igwDetached never flipped) so the IGW removal stays sequenced
+	// before VPC delete on every path — success or failure.
+}
+
+// --- helpers --------------------------------------------------------------
+
+// uniqueCount returns the number of distinct non-empty / non-"unknown"
+// strings in xs. Matches the bash `sort -u | wc -l` line that gates the
+// spread-placement pass.
+func uniqueCount(xs []string) int {
+	seen := map[string]bool{}
+	for _, x := range xs {
+		if x == "" || x == "unknown" {
+			continue
+		}
+		seen[x] = true
+	}
+	return len(seen)
+}
+
+// waitForBastionSSH polls SSH `true` until the handshake completes. Bash
+// equivalent: phase 11 Step 2's 30-attempt 5s loop = 150s budget. Go port
+// uses a wider 5min budget because a brand-new VPC's OVN flow install on
+// the external switch lags the instance's "running" state on the tofu
+// cluster (mulga-siv-90 runs 26195522455, 26197248656, 26198221557 — SSH
+// timed out at exactly 150s even after the dnat_and_snat race fix
+// mulga-siv-124 landed). 5min covers both cloud-init + OVN warm-up.
+//
+// Logs a single ICMP probe per iteration before the SSH dial so a future
+// failure log distinguishes "datapath down" (ping fails) from "sshd not
+// up yet" (ping ok, ssh refused/timeout) — the smoking-gun split per
+// the RCA agent's fix candidate 3.
+func waitForBastionSSH(t *testing.T, host, keyPath string, timeout time.Duration) {
+	t.Helper()
+	harness.Step(t, "wait bastion SSH %s", host)
+	harness.EventuallyErr(t, func() error {
+		// ICMP probe — diagnostic only; do not fail on ping failure
+		// because some host LANs block ICMP while leaving tcp/22 open.
+		pingCtx, pingCancel := context.WithTimeout(context.Background(), 3*time.Second)
+		pingOut, pingErr := exec.CommandContext(pingCtx, "ping", "-c", "1", "-W", "2", host).CombinedOutput()
+		pingCancel()
+		pingState := "ok"
+		if pingErr != nil {
+			pingState = fmt.Sprintf("fail (%v)", pingErr)
+		}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		args := []string{
+			"-o", "StrictHostKeyChecking=no",
+			"-o", "UserKnownHostsFile=/dev/null",
+			"-o", "LogLevel=ERROR",
+			"-o", "ConnectTimeout=5",
+			"-o", "BatchMode=yes",
+			"-i", keyPath,
+			"ec2-user@" + host,
+			"true",
+		}
+		if out, err := exec.CommandContext(ctx, "ssh", args...).CombinedOutput(); err != nil {
+			return fmt.Errorf("ssh %s: %w\n  ping=%s\n  ping_output=%s\n  ssh_output=%s",
+				host, err, pingState, strings.TrimSpace(string(pingOut)), string(out))
+		}
+		return nil
+	}, timeout, 5*time.Second)
+}
+
+// scpKeyToBastion copies the test PEM to /tmp/key.pem on the bastion and
+// chmods it so the bastion can re-key into private VMs.
+func scpKeyToBastion(t *testing.T, keyPath, host string) {
+	t.Helper()
+	harness.Step(t, "scp key -> bastion:/tmp/key.pem")
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	scpArgs := []string{
+		"-o", "StrictHostKeyChecking=no",
+		"-o", "UserKnownHostsFile=/dev/null",
+		"-o", "LogLevel=ERROR",
+		"-o", "ConnectTimeout=10",
+		"-o", "BatchMode=yes",
+		"-i", keyPath,
+		keyPath,
+		"ec2-user@" + host + ":/tmp/key.pem",
+	}
+	if out, err := exec.CommandContext(ctx, "scp", scpArgs...).CombinedOutput(); err != nil {
+		t.Fatalf("scp %s -> %s:/tmp/key.pem: %v\n%s", keyPath, host, err, string(out))
+	}
+	// chmod 600 — sshd refuses keys with loose perms.
+	ctx2, cancel2 := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel2()
+	sshArgs := []string{
+		"-o", "StrictHostKeyChecking=no",
+		"-o", "UserKnownHostsFile=/dev/null",
+		"-o", "LogLevel=ERROR",
+		"-o", "ConnectTimeout=10",
+		"-o", "BatchMode=yes",
+		"-i", keyPath,
+		"ec2-user@" + host,
+		"chmod 600 /tmp/key.pem",
+	}
+	if out, err := exec.CommandContext(ctx2, "ssh", sshArgs...).CombinedOutput(); err != nil {
+		t.Fatalf("chmod /tmp/key.pem: %v\n%s", err, string(out))
+	}
+}
+
+// sshViaBastion runs cmd on privIP through bastionHost using BatchMode +
+// ConnectTimeout=10 nested-ssh — mirrors the bash priv_hop_cmd helper.
+// Returns combined stdout+stderr and the exit error.
+func sshViaBastion(keyPath, bastionHost, privIP, cmd string) (string, error) {
+	hop := fmt.Sprintf(
+		"ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null "+
+			"-o LogLevel=ERROR -o ConnectTimeout=10 -o BatchMode=yes "+
+			"-i /tmp/key.pem ec2-user@%s '%s'",
+		privIP, cmd,
+	)
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	args := []string{
+		"-o", "StrictHostKeyChecking=no",
+		"-o", "UserKnownHostsFile=/dev/null",
+		"-o", "LogLevel=ERROR",
+		"-o", "ConnectTimeout=10",
+		"-o", "BatchMode=yes",
+		"-i", keyPath,
+		"ec2-user@" + bastionHost,
+		hop,
+	}
+	out, err := exec.CommandContext(ctx, "ssh", args...).CombinedOutput()
+	return string(out), err
+}
+
+// waitForSSHViaBastion polls hostname-through-bastion until cloud-init on
+// the private VM has finished bringing sshd up. label is a triage tag for
+// the log line; bash uses a similar attempt loop with 30 tries x 5s.
+func waitForSSHViaBastion(t *testing.T, keyPath, bastionHost, privIP, label string) {
+	t.Helper()
+	harness.EventuallyErr(t, func() error {
+		out, err := sshViaBastion(keyPath, bastionHost, privIP, "hostname")
+		if err != nil {
+			return fmt.Errorf("%s: bastion->%s hostname: %w\n%s", label, privIP, err, out)
+		}
+		if strings.TrimSpace(out) == "" {
+			return fmt.Errorf("%s: empty hostname response", label)
+		}
+		return nil
+	}, 3*time.Minute, 5*time.Second)
+}
+
+// pingViaBastion sends a single 8.8.8.8 ping through the bastion hop. Used
+// twice: pre-NAT (expect err) and post-NAT (expect nil after a poll).
+func pingViaBastion(keyPath, bastionHost, privIP string) (string, error) {
+	return sshViaBastion(keyPath, bastionHost, privIP, "ping -c 1 -W 3 8.8.8.8")
+}
+
+// --- NAT GW state pollers (multinode-local; phase 8d single-node has its
+// own copies — promote to harness/poll.go once a third consumer lands).
+
+func waitForNATGatewayStateFatal(t *testing.T, c *harness.AWSClient, id, target string) {
+	t.Helper()
+	harness.EventuallyErr(t, func() error {
+		out, err := c.EC2.DescribeNatGateways(&ec2.DescribeNatGatewaysInput{
+			NatGatewayIds: []*string{aws.String(id)},
+		})
+		if err != nil {
+			return fmt.Errorf("describe-nat-gateways %s: %w", id, err)
+		}
+		if len(out.NatGateways) == 0 {
+			if target == "deleted" {
+				return nil
+			}
+			return fmt.Errorf("%s not found", id)
+		}
+		state := aws.StringValue(out.NatGateways[0].State)
+		if state == target {
+			return nil
+		}
+		if state == "failed" {
+			msg := aws.StringValue(out.NatGateways[0].FailureMessage)
+			return fmt.Errorf("%s entered failed state: %s", id, msg)
+		}
+		return fmt.Errorf("%s state=%s want=%s", id, state, target)
+	}, 5*time.Minute, 2*time.Second)
+}
+
+func waitForNATGatewayStateBest(c *harness.AWSClient, id, target string, timeout time.Duration) error {
+	deadline := time.Now().Add(timeout)
+	for {
+		out, err := c.EC2.DescribeNatGateways(&ec2.DescribeNatGatewaysInput{
+			NatGatewayIds: []*string{aws.String(id)},
+		})
+		if err == nil {
+			if len(out.NatGateways) == 0 && target == "deleted" {
+				return nil
+			}
+			if len(out.NatGateways) > 0 && aws.StringValue(out.NatGateways[0].State) == target {
+				return nil
+			}
+		}
+		if time.Now().After(deadline) {
+			return fmt.Errorf("nat gw %s did not reach %s within %s", id, target, timeout)
+		}
+		time.Sleep(2 * time.Second)
+	}
+}
+
+// dumpPlacementNATDiag fans out a fixed shortlist of datapath probes to
+// every cluster node and writes results to <Artifacts>/diag-<node>-<probe>.log.
+// Triggered only on test failure (via t.Cleanup wrapper) so a green run
+// leaves no extra files. Best-effort: per-node SSH errors are logged but
+// never re-fail the test.
+//
+// Probe set targets the centralized-NAT EIP datapath:
+//   - arp -an              : did ARP for the EIP resolve on this node?
+//   - ip route get <eip>   : kernel routing decision for outbound to EIP
+//   - ovs-vsctl show       : bridges + ports (br-int, br-ex)
+//   - ovs-vsctl get ... ovn-bridge-mappings : physnet binding
+//   - ovn-sbctl list chassis              : encap IPs + gateway hostnames
+//   - ovn-nbctl list nat                  : dnat_and_snat rule state
+//   - ovn-nbctl list gateway_chassis      : priority election state
+//   - ovn-nbctl find logical_router_port  : DGP gateway chassis attachment
+func dumpPlacementNATDiag(t *testing.T, fix *Fixture, bastionPubIP, bastionID string) {
+	t.Helper()
+	if fix.Artifacts == "" {
+		t.Logf("dumpPlacementNATDiag: no artifact dir; skipping")
+		return
+	}
+	if fix.Cluster == nil || len(fix.Cluster.Nodes) == 0 {
+		t.Logf("dumpPlacementNATDiag: no cluster nodes; skipping")
+		return
+	}
+
+	t.Logf("dumpPlacementNATDiag: bastion=%s eip=%s nodes=%d -> %s",
+		bastionID, bastionPubIP, len(fix.Cluster.Nodes), fix.Artifacts)
+
+	probes := []struct {
+		name string
+		cmd  string
+	}{
+		{"arp", "arp -an"},
+		{"ip-route-eip", fmt.Sprintf("ip route get %s 2>&1 || true", bastionPubIP)},
+		{"ip-addr", "ip -br addr"},
+		{"ovs-show", "sudo ovs-vsctl show"},
+		{"ovs-bridge-mappings", "sudo ovs-vsctl get Open_vSwitch . external_ids:ovn-bridge-mappings 2>&1 || true"},
+		{"ovn-sb-chassis", "sudo ovn-sbctl --no-leader-only list chassis 2>&1 || true"},
+		{"ovn-nb-nat", "sudo ovn-nbctl --no-leader-only list nat 2>&1 || true"},
+		{"ovn-nb-gw-chassis", "sudo ovn-nbctl --no-leader-only list gateway_chassis 2>&1 || true"},
+		{"ovn-nb-lrp", "sudo ovn-nbctl --no-leader-only list logical_router_port 2>&1 || true"},
+		{"ip-link-geneve", "ip -d link show type geneve 2>&1 || true"},
+	}
+
+	ssh := harness.NewPeerSSH()
+	for _, n := range fix.Cluster.Nodes {
+		for _, p := range probes {
+			ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+			out, err := ssh.Run(ctx, n.Addr, p.cmd)
+			cancel()
+			header := fmt.Sprintf("# host=%s cmd=%s\n", n.Addr, p.cmd)
+			if err != nil {
+				header += fmt.Sprintf("# (ssh error: %v)\n", err)
+			}
+			name := fmt.Sprintf("diag-%s-%s.log", n.Name, p.name)
+			harness.DumpFile(t, fix.Artifacts, name, append([]byte(header), out...))
+		}
+	}
+
+	// Local-side: where does the test runner think the EIP is, and is
+	// ICMP returning right now? Distinguishes runner-network breakage
+	// from cluster datapath breakage.
+	localProbes := []struct {
+		name string
+		cmd  string
+		args []string
+	}{
+		{"local-ping-eip", "ping", []string{"-c", "3", "-W", "2", bastionPubIP}},
+		{"local-traceroute-eip", "traceroute", []string{"-n", "-w", "2", "-m", "12", bastionPubIP}},
+		{"local-ip-route-eip", "ip", []string{"route", "get", bastionPubIP}},
+		{"local-arp", "arp", []string{"-an"}},
+	}
+	for _, p := range localProbes {
+		ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+		out, err := exec.CommandContext(ctx, p.cmd, p.args...).CombinedOutput()
+		cancel()
+		header := fmt.Sprintf("$ %s %s\n", p.cmd, strings.Join(p.args, " "))
+		if err != nil {
+			header += fmt.Sprintf("(exit error: %v)\n", err)
+		}
+		harness.DumpFile(t, fix.Artifacts, p.name+".log", append([]byte(header), out...))
+	}
+}
+
+// waitForInstanceStateBest is the cleanup-time analogue of
+// harness.WaitForInstanceState — no t.Fatal, just polls + returns.
+func waitForInstanceStateBest(c *harness.AWSClient, id, target string, timeout time.Duration) error {
+	deadline := time.Now().Add(timeout)
+	for {
+		out, err := c.EC2.DescribeInstances(&ec2.DescribeInstancesInput{
+			InstanceIds: []*string{aws.String(id)},
+		})
+		if err == nil && len(out.Reservations) > 0 && len(out.Reservations[0].Instances) > 0 {
+			if aws.StringValue(out.Reservations[0].Instances[0].State.Name) == target {
+				return nil
+			}
+		}
+		if time.Now().After(deadline) {
+			return fmt.Errorf("instance %s did not reach %s within %s", id, target, timeout)
+		}
+		time.Sleep(2 * time.Second)
+	}
+}
diff --git a/tests/e2e/multinode/preflight_test.go b/tests/e2e/multinode/preflight_test.go
new file mode 100644
index 000000000..b0ea3e113
--- /dev/null
+++ b/tests/e2e/multinode/preflight_test.go
@@ -0,0 +1,44 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+)
+
+// phase1_Preflight is the Go port of `Phase 1: Pre-flight Validation`
+// (run-multinode-e2e.sh:394-423). Two checks:
+//   - /dev/kvm exists and is writable on the local node (we run on node1).
+//   - SSH to every peer node succeeds with `hostname`.
+//
+// Failing this phase exposes a misconfigured VM image or broken peer
+// networking before any AWS API churn.
+func phase1_Preflight(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 1 — Pre-flight")
+
+	harness.Step(t, "verify /dev/kvm")
+	f, err := os.OpenFile("/dev/kvm", os.O_RDWR, 0)
+	if err != nil {
+		t.Fatalf("/dev/kvm not writable: %v", err)
+	}
+	_ = f.Close()
+
+	harness.Step(t, "peer_ssh hostname on every remote node")
+	ssh := harness.NewPeerSSH()
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	// Bash runs this loop from node1 and skips itself; mirror that — the
+	// runner host doesn't necessarily accept SSH back into its own loopback
+	// and a local hostname call would test nothing about peer reachability.
+	for _, n := range fix.Cluster.Nodes[1:] {
+		if _, err := ssh.Run(ctx, n.Addr, "hostname"); err != nil {
+			t.Fatalf("peer_ssh %s (%s): %v", n.Name, n.Addr, err)
+		}
+		harness.Detail(t, "node", n.Name, "addr", n.Addr, "ssh", "ok")
+	}
+}
diff --git a/tests/e2e/multinode/tests_test.go b/tests/e2e/multinode/tests_test.go
new file mode 100644
index 000000000..8a7d00525
--- /dev/null
+++ b/tests/e2e/multinode/tests_test.go
@@ -0,0 +1,65 @@
+//go:build e2e
+
+package multinode
+
+import "testing"
+
+// Top-level Test* wrappers — one per bash phase. Each delegates to a
+// phaseN_X function in the matching <phase>_test.go file. Names follow
+// the single-node convention (TestX, no numeric prefix) so isolated
+// runs via `go test -run TestMultinodeClusterHealth` are stable.
+
+// TestMultinodePreflight maps to phase 1 of run-multinode-e2e.sh.
+func TestMultinodePreflight(t *testing.T) {
+	phase1_Preflight(t, requireMultiNodeFixture(t))
+}
+
+// TestMultinodeClusterHealth maps to phase 2.
+func TestMultinodeClusterHealth(t *testing.T) {
+	phase2_ClusterHealth(t, requireMultiNodeFixture(t))
+}
+
+// TestMultinodeInstanceDistribution maps to phase 3.
+func TestMultinodeInstanceDistribution(t *testing.T) {
+	phase3_InstanceDistribution(t, requireMultiNodeFixture(t))
+}
+
+// TestMultinodeGuestSSH maps to phase 4.
+func TestMultinodeGuestSSH(t *testing.T) {
+	phase4_GuestSSH(t, requireMultiNodeFixture(t))
+}
+
+// TestMultinodeVolumeLifecycle maps to phase 5.
+func TestMultinodeVolumeLifecycle(t *testing.T) {
+	phase5_VolumeLifecycle(t, requireMultiNodeFixture(t))
+}
+
+// TestMultinodeCrossNodeGateway maps to phase 6.
+func TestMultinodeCrossNodeGateway(t *testing.T) {
+	phase6_CrossNodeGateway(t, requireMultiNodeFixture(t))
+}
+
+// TestMultinodeCrossNodeOps maps to phase 7.
+func TestMultinodeCrossNodeOps(t *testing.T) {
+	phase7_CrossNodeOps(t, requireMultiNodeFixture(t))
+}
+
+// TestMultinodeNodeFailure maps to phase 8.
+func TestMultinodeNodeFailure(t *testing.T) {
+	phase8_NodeFailure(t, requireMultiNodeFixture(t))
+}
+
+// TestMultinodeNodeRecovery maps to phase 9.
+func TestMultinodeNodeRecovery(t *testing.T) {
+	phase9_NodeRecovery(t, requireMultiNodeFixture(t))
+}
+
+// TestMultinodeVPCNetworking maps to phase 10.
+func TestMultinodeVPCNetworking(t *testing.T) {
+	phase10_VPCNetworking(t, requireMultiNodeFixture(t))
+}
+
+// TestMultinodePlacementAndNAT maps to phase 11.
+func TestMultinodePlacementAndNAT(t *testing.T) {
+	phase11_PlacementAndNATGateway(t, requireMultiNodeFixture(t))
+}
diff --git a/tests/e2e/multinode/volume_test.go b/tests/e2e/multinode/volume_test.go
new file mode 100644
index 000000000..f063b2d4c
--- /dev/null
+++ b/tests/e2e/multinode/volume_test.go
@@ -0,0 +1,61 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+	"github.com/stretchr/testify/require"
+)
+
+// phase5_VolumeLifecycle is the Go port of phase 5 from
+// run-multinode-e2e.sh:731-825. Creates a 10GiB volume, attaches to the
+// first trio instance at /dev/sdf, detaches, deletes. Each step polls a
+// matching state target (in-use/attached → available → 404).
+//
+// Volume is created + torn down inline (not via EnsureVolume) because
+// the test exercises the full CRUD cycle including DeleteVolume — wiring
+// it through Ensure* would have the fixture cleanup race the in-test
+// delete and surface as InvalidVolume.NotFound.
+func phase5_VolumeLifecycle(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 5 — Volume Lifecycle")
+
+	az := needAZ(t, fix)
+	trio := needInstanceTrio(t, fix)
+	require.NotEmpty(t, trio, "trio required")
+	target := trio[0]
+
+	harness.Step(t, "create 10GiB volume in %s", az)
+	create, err := fix.AWS.EC2.CreateVolume(&ec2.CreateVolumeInput{
+		AvailabilityZone: aws.String(az),
+		Size:             aws.Int64(10),
+	})
+	require.NoError(t, err, "create-volume")
+	volID := aws.StringValue(create.VolumeId)
+	require.NotEmpty(t, volID, "create-volume returned empty VolumeId")
+	harness.Detail(t, "volume", volID)
+
+	harness.Step(t, "attach %s to %s as /dev/sdf", volID, target)
+	_, err = fix.AWS.EC2.AttachVolume(&ec2.AttachVolumeInput{
+		VolumeId:   aws.String(volID),
+		InstanceId: aws.String(target),
+		Device:     aws.String("/dev/sdf"),
+	})
+	require.NoError(t, err, "attach-volume")
+	harness.WaitForVolumeState(t, fix.AWS, volID, "in-use",
+		harness.WithTimeout(60*time.Second), harness.WithPoll(2*time.Second))
+
+	harness.Step(t, "detach %s", volID)
+	_, err = fix.AWS.EC2.DetachVolume(&ec2.DetachVolumeInput{VolumeId: aws.String(volID)})
+	require.NoError(t, err, "detach-volume")
+	harness.WaitForVolumeState(t, fix.AWS, volID, "available",
+		harness.WithTimeout(60*time.Second), harness.WithPoll(2*time.Second))
+
+	harness.Step(t, "delete %s", volID)
+	_, err = fix.AWS.EC2.DeleteVolume(&ec2.DeleteVolumeInput{VolumeId: aws.String(volID)})
+	require.NoError(t, err, "delete-volume")
+}
diff --git a/tests/e2e/multinode/vpc_test.go b/tests/e2e/multinode/vpc_test.go
new file mode 100644
index 000000000..6309dbc17
--- /dev/null
+++ b/tests/e2e/multinode/vpc_test.go
@@ -0,0 +1,194 @@
+//go:build e2e
+
+package multinode
+
+import (
+	"regexp"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/mulgadc/spinifex/tests/e2e/harness"
+	"github.com/stretchr/testify/require"
+)
+
+// vpcSubnetCIDR is the regex bash uses to gate subnet IP allocation —
+// IPs must come from 10.200.1.0/24. Compiled once.
+var vpcSubnetCIDR = regexp.MustCompile(`^10\.200\.1\.[0-9]+$`)
+
+// phase10_VPCNetworking is the Go port of phase 10 from
+// run-multinode-e2e.sh:1042-1251. Stands up a fresh non-default VPC +
+// subnet, launches 3 instances into the subnet, asserts each gets a
+// unique PrivateIpAddress within 10.200.1.0/24, then stops + restarts
+// all three and re-asserts the same IPs persist.
+//
+// Independent of the package-level trio (which lives on the default
+// VPC) — this phase needs full control over subnet allocation, so
+// instances are launched, terminated, and cleaned up locally via
+// t.Cleanup.
+func phase10_VPCNetworking(t *testing.T, fix *Fixture) {
+	harness.Phase(t, "Multinode Phase 10 — VPC Networking")
+
+	amiID := needAMI(t, fix, needArch(t, fix))
+	instType, _ := needInstanceTypeArch(t, fix)
+	keyName, _ := needKeyPair(t, fix)
+	c := fix.AWS
+
+	// --- VPC ---------------------------------------------------------------
+	harness.Step(t, "create-vpc 10.200.0.0/16")
+	vpcOut, err := c.EC2.CreateVpc(&ec2.CreateVpcInput{
+		CidrBlock: aws.String("10.200.0.0/16"),
+	})
+	require.NoError(t, err, "create-vpc")
+	require.NotNil(t, vpcOut.Vpc, "create-vpc returned nil Vpc")
+	vpcID := aws.StringValue(vpcOut.Vpc.VpcId)
+	require.NotEmpty(t, vpcID, "VpcId empty")
+	t.Cleanup(func() {
+		_, _ = c.EC2.DeleteVpc(&ec2.DeleteVpcInput{VpcId: aws.String(vpcID)})
+	})
+	harness.Detail(t, "vpc", vpcID, "cidr", "10.200.0.0/16")
+
+	// --- Subnet ------------------------------------------------------------
+	harness.Step(t, "create-subnet 10.200.1.0/24")
+	subOut, err := c.EC2.CreateSubnet(&ec2.CreateSubnetInput{
+		VpcId:     aws.String(vpcID),
+		CidrBlock: aws.String("10.200.1.0/24"),
+	})
+	require.NoError(t, err, "create-subnet")
+	require.NotNil(t, subOut.Subnet, "create-subnet returned nil Subnet")
+	subnetID := aws.StringValue(subOut.Subnet.SubnetId)
+	require.NotEmpty(t, subnetID, "SubnetId empty")
+	t.Cleanup(func() {
+		_, _ = c.EC2.DeleteSubnet(&ec2.DeleteSubnetInput{SubnetId: aws.String(subnetID)})
+	})
+	harness.Detail(t, "subnet", subnetID, "cidr", "10.200.1.0/24")
+
+	// OVN topology programming is async — bash sleeps 2s after create-subnet
+	// before launching. Mirror that pause to avoid flakes during the first
+	// RunInstances.
+	time.Sleep(2 * time.Second)
+
+	// --- Launch 3 instances ------------------------------------------------
+	harness.Step(t, "run-instances x3 into %s", subnetID)
+	var instIDs []string
+	for i := 0; i < 3; i++ {
+		runOut, err := c.EC2.RunInstances(&ec2.RunInstancesInput{
+			ImageId:      aws.String(amiID),
+			InstanceType: aws.String(instType),
+			KeyName:      aws.String(keyName),
+			SubnetId:     aws.String(subnetID),
+			MinCount:     aws.Int64(1),
+			MaxCount:     aws.Int64(1),
+		})
+		require.NoErrorf(t, err, "run-instances #%d", i+1)
+		require.NotEmptyf(t, runOut.Instances, "run-instances #%d: no Instances", i+1)
+		id := aws.StringValue(runOut.Instances[0].InstanceId)
+		require.NotEmptyf(t, id, "run-instances #%d: empty InstanceId", i+1)
+		instIDs = append(instIDs, id)
+		harness.Detail(t, "instance", id)
+		// Per-instance cleanup — terminate so the subnet/VPC can drop in
+		// later cleanup phases. Best-effort; we're already unwinding.
+		idCopy := id
+		t.Cleanup(func() {
+			_, _ = c.EC2.TerminateInstances(&ec2.TerminateInstancesInput{
+				InstanceIds: []*string{aws.String(idCopy)},
+			})
+		})
+	}
+
+	harness.Step(t, "wait running x%d", len(instIDs))
+	for _, id := range instIDs {
+		harness.WaitForInstanceState(t, c, id, "running",
+			harness.WithTimeout(60*time.Second), harness.WithPoll(2*time.Second))
+	}
+
+	// --- Initial IP assertions --------------------------------------------
+	harness.Step(t, "verify PrivateIpAddress + Subnet/VPC ids")
+	initialIPs := describeAndCollectIPs(t, c, instIDs, subnetID, vpcID)
+
+	seen := map[string]bool{}
+	for _, ip := range initialIPs {
+		require.Regexpf(t, vpcSubnetCIDR, ip,
+			"PrivateIpAddress %s not in 10.200.1.0/24", ip)
+		require.Falsef(t, seen[ip], "duplicate PrivateIpAddress %s", ip)
+		seen[ip] = true
+	}
+	harness.Detail(t, "ips_initial", initialIPs)
+
+	// --- Stop + verify IP persists while stopped --------------------------
+	harness.Step(t, "stop-instances x%d", len(instIDs))
+	for _, id := range instIDs {
+		_, err := c.EC2.StopInstances(&ec2.StopInstancesInput{
+			InstanceIds: []*string{aws.String(id)},
+		})
+		require.NoErrorf(t, err, "stop-instances %s", id)
+	}
+	for _, id := range instIDs {
+		harness.WaitForInstanceState(t, c, id, "stopped",
+			harness.WithTimeout(60*time.Second), harness.WithPoll(2*time.Second))
+	}
+
+	harness.Step(t, "verify IPs persist while stopped")
+	stoppedIPs := describeAndCollectIPs(t, c, instIDs, subnetID, vpcID)
+	for i, id := range instIDs {
+		require.Equalf(t, initialIPs[i], stoppedIPs[i],
+			"%s PrivateIpAddress changed while stopped: was %s, now %s",
+			id, initialIPs[i], stoppedIPs[i])
+	}
+
+	// --- Restart + verify IP persists after restart -----------------------
+	harness.Step(t, "start-instances x%d", len(instIDs))
+	for _, id := range instIDs {
+		_, err := c.EC2.StartInstances(&ec2.StartInstancesInput{
+			InstanceIds: []*string{aws.String(id)},
+		})
+		require.NoErrorf(t, err, "start-instances %s", id)
+	}
+	for _, id := range instIDs {
+		harness.WaitForInstanceState(t, c, id, "running",
+			harness.WithTimeout(60*time.Second), harness.WithPoll(2*time.Second))
+	}
+
+	harness.Step(t, "verify IPs persist after restart")
+	restartedIPs := describeAndCollectIPs(t, c, instIDs, subnetID, vpcID)
+	for i, id := range instIDs {
+		require.Equalf(t, initialIPs[i], restartedIPs[i],
+			"%s PrivateIpAddress changed after restart: was %s, now %s",
+			id, initialIPs[i], restartedIPs[i])
+	}
+	harness.Detail(t, "ips_restarted", restartedIPs)
+}
+
+// describeAndCollectIPs runs DescribeInstances for each id, asserts the
+// Subnet/VPC binding matches expectations, and returns PrivateIpAddress
+// values in the same order as instIDs. Fatal on any missing field — bash
+// also fatals on these.
+func describeAndCollectIPs(t *testing.T, c *harness.AWSClient, instIDs []string, wantSubnet, wantVPC string) []string {
+	t.Helper()
+	ips := make([]string, 0, len(instIDs))
+	for _, id := range instIDs {
+		out, err := c.EC2.DescribeInstances(&ec2.DescribeInstancesInput{
+			InstanceIds: []*string{aws.String(id)},
+		})
+		require.NoErrorf(t, err, "describe-instances %s", id)
+		require.NotEmptyf(t, out.Reservations, "describe-instances %s: no Reservations", id)
+		require.NotEmptyf(t, out.Reservations[0].Instances, "describe-instances %s: no Instances", id)
+		inst := out.Reservations[0].Instances[0]
+		ip := aws.StringValue(inst.PrivateIpAddress)
+		require.NotEmptyf(t, ip, "%s: empty PrivateIpAddress", id)
+		require.Equalf(t, wantSubnet, aws.StringValue(inst.SubnetId),
+			"%s: SubnetId mismatch", id)
+		require.Equalf(t, wantVPC, aws.StringValue(inst.VpcId), "%s: VpcId mismatch", id)
+		ips = append(ips, ip)
+	}
+	return ips
+}
+
+// needArch returns the discovered arch for the nano instance type.
+// Convenience wrapper because needAMI takes arch, not (t, fix).
+func needArch(t *testing.T, fix *Fixture) string {
+	t.Helper()
+	_, arch := needInstanceTypeArch(t, fix)
+	return arch
+}