Simplify build cache to per-runner directories

Replace the shared cache (with flock, sed path fixups, and workspace
tracking) with per-runner caches keyed by RUNNER_NAME. Each runner
always uses the same workspace path, so CMake's absolute paths are
always correct — no cross-runner path issues, no locking needed.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: sbryngelson

.github/scripts/setup-build-cache.sh

@@ -1,94 +1,35 @@
 #!/bin/bash
 # Sets up a persistent build cache for self-hosted CI runners.
-# Creates a symlink: ./build -> <resolved scratch path>/.mfc-ci-cache/<key>/build
+# Creates a symlink: ./build -> <scratch>/.mfc-ci-cache/<key>/build
 #
-# This ensures that every run of the same config (cluster/device/interface) finds
-# cached build artifacts regardless of which runner instance picks up the job.
-#
-# Concurrent safety: uses flock to serialize access per cache directory. If
-# multiple PRs trigger the same config simultaneously, the second job waits
-# for the first to finish (up to 1 hour), then gets a warm cache. If the lock
-# times out, falls back to a local build (same as no caching).
+# Each runner gets its own cache keyed by (cluster, device, interface, runner).
+# This avoids cross-runner path issues entirely — CMake's absolute paths are
+# always correct because the same runner always uses the same workspace path.
 #
 # Usage: source .github/scripts/setup-build-cache.sh <cluster> <device> <interface>
 
 _cache_cluster="${1:?Usage: setup-build-cache.sh <cluster> <device> <interface>}"
 _cache_device="${2:?}"
 _cache_interface="${3:-none}"
+_cache_runner="${RUNNER_NAME:?RUNNER_NAME not set}"
 
-_cache_key="${_cache_cluster}-${_cache_device}-${_cache_interface}"
+_cache_key="${_cache_cluster}-${_cache_device}-${_cache_interface}-${_cache_runner}"
 _cache_base="$HOME/scratch/.mfc-ci-cache/${_cache_key}/build"
 
-# Create the cache dir, then resolve to a physical path (no symlinks).
-# $HOME/scratch is typically a symlink to a scratch filesystem — resolving
-# it ensures the build symlink target remains valid even if intermediate
-# symlinks change.
 mkdir -p "$_cache_base"
 _cache_dir="$(cd "$_cache_base" && pwd -P)"
 
 echo "=== Build Cache Setup ==="
 echo "  Cache key: $_cache_key"
 echo "  Cache dir: $_cache_dir"
 
-# Acquire an exclusive lock on the cache directory to prevent concurrent
-# builds from corrupting it. The lock is fd-based (flock on fd 9), so it
-# auto-releases when the calling process exits — no stale locks.
-#
-# Timeout: 1 hour. If another build holds the lock, we wait. This is fine
-# because the waiting job will get a warm cache when it finally acquires.
-# If the lock can't be acquired after 1 hour, something is wrong — fall
-# back to a local build in the workspace.
-_cache_locked=false
-_lock_file="$_cache_dir/.cache.lock"
-exec 9>"$_lock_file"
-echo "  Acquiring cache lock..."
-if flock --timeout 3600 9; then
-    _cache_locked=true
-    echo "  Cache lock acquired"
-else
-    echo "  WARNING: Cache lock timeout (1h), building locally without cache"
-    exec 9>&-
-    # Remove any existing symlink to the shared cache so we don't write
-    # into it without the lock. Then create a real local directory.
-    if [ -L "build" ]; then
-        rm -f "build"
-    fi
-    mkdir -p "build"
-    echo "========================="
-    return 0 2>/dev/null || true
-fi
-
-# If build/ exists (real dir or stale symlink), remove it.
-# rm -rf on a symlink removes the symlink, not the target — cache is safe.
+# Replace any existing build/ (real dir or stale symlink) with a symlink
+# to our runner-specific cache directory.
 if [ -e "build" ] || [ -L "build" ]; then
     rm -rf "build"
 fi
 
 ln -s "$_cache_dir" "build"
 
-# Handle cross-runner workspace path changes.
-# CMakeCache.txt stores absolute paths from whichever runner instance
-# originally configured the build. If we're on a different runner, sed-replace
-# the old workspace path with the current one so CMake can do incremental builds.
-_workspace_marker="$_cache_dir/.workspace_path"
-if [ -f "$_workspace_marker" ]; then
-    _old_workspace=$(cat "$_workspace_marker")
-    if [ "$_old_workspace" != "$(pwd)" ]; then
-        echo "  Workspace path changed: $_old_workspace -> $(pwd)"
-        echo "  Updating cached paths..."
-        # Update CMake build files in staging/
-        find "$_cache_dir/staging" -type f \
-            \( -name "CMakeCache.txt" -o -name "*.cmake" \
-               -o -name "*.make" -o -name "Makefile" \
-               -o -name "build.ninja" \) \
-            -exec sed -i "s|${_old_workspace}|$(pwd)|g" {} + 2>/dev/null || true
-        # Compiled binaries have stale paths baked in — delete install/
-        # so CMake rebuilds and re-installs them with correct paths.
-        echo "  Clearing install/ to force rebuild of binaries..."
-        rm -rf "$_cache_dir/install"
-    fi
-fi
-echo "$(pwd)" > "$_workspace_marker"
-
 echo "  Symlink: build -> $_cache_dir"
 echo "========================="

.github/workflows/phoenix/test.sh

@@ -33,13 +33,6 @@ while [ $attempt -le $max_attempts ]; do
     attempt=$((attempt + 1))
 done
 
-# Release the cache lock before running tests. Tests only read installed
-# binaries and can take hours — no need to block other builds.
-if [ "${_cache_locked:-false}" = true ]; then
-    exec 9>&-
-    echo "Released build cache lock before tests"
-fi
-
 n_test_threads=8
 
 if [ "$job_device" = "gpu" ]; then