Why I Stopped Borrowing a Stale Repo and Started Cloning Fresh After a Scheduled Task Couldn't Write to Shared /tmp

What cloning fresh every time costs

So what does giving up reuse actually cost? I measured it.

Reuse saves about 2 seconds per run. For a task that runs once a day, that is roughly 12 minutes a year. Taking on "depends on another run's state" and "cannot notice staleness" for that price was not a good trade for how I work.

One caveat. $HOME is a per-run location (/sessions/rcw-… this time) and was not carried into the next run. So "keep it in $HOME/repos and pull next time" cannot be counted on, and every run ends up cloning anyway. At 2.8 seconds, that is fine.

A script that picks the location, then verifies after cloning

I reduced the policy to two rules. Choose a location only after actually creating a child in it. And compare the local HEAD with origin/main's SHA before starting any work.

The first script chooses the location.

#!/usr/bin/env bash
# pick_base.sh — return the first writable parent directory from the list
set -u
CANDIDATES=("/tmp/repos" "${TMPDIR:-/nonexistent}/repos" "$HOME/repos")
for base in "${CANDIDATES[@]}"; do
  # mkdir -p succeeds even when the directory exists but is not writable.
  # So create and remove a real child to prove it can be written to
  mkdir -p "$base" 2>/dev/null || { echo "skip(mkdir): $base" >&2; continue; }
  probe="$base/.probe.$$"
  if mkdir "$probe" 2>/dev/null; then
    rmdir "$probe"
    echo "$base"
    exit 0
  fi
  echo "skip(owner=$(stat -c %U "$base") mode=$(stat -c %a "$base")): $base" >&2
done
echo "FATAL: no writable working location" >&2
exit 1

Run in this environment, it skipped /tmp/repos with a reason and chose the one under TMPDIR.

skip(owner=nobody mode=755): /tmp/repos
/sessions/rcw-017tvrnbapgi3k7hq52tm5wv/tmp/repos

Why not stop at mkdir -p? mkdir -p returns success for an existing directory, so it would have judged the unwritable /tmp/repos as usable. The skip(owner=…) line appearing instead of skip(mkdir) confirmed that behaviour here.

The second script clones and verifies.

#!/usr/bin/env bash
# fresh_repo.sh <remote-url> <name> — prints the working directory path
set -euo pipefail
REMOTE="$1"; NAME="$2"
BASE=$("$(dirname "$0")/pick_base.sh")
DIR="$BASE/$NAME"
 
if [ -d "$DIR/.git" ]; then
  # Reuse an existing clone only if it is writable by me AND current
  if [ -w "$DIR/.git" ] && git -C "$DIR" pull -q --rebase origin main 2>/dev/null; then
    :
  else
    echo "stale or read-only: $DIR -> recreating" >&2
    rm -rf "$DIR" 2>/dev/null || DIR="$BASE/$NAME.$$"
  fi
fi
[ -d "$DIR/.git" ] || git clone -q --depth 1 --branch main "$REMOTE" "$DIR"
 
# Always verify last: does local HEAD equal remote main?
LOCAL=$(git -C "$DIR" rev-parse HEAD)
REMOTE_SHA=$(git -C "$DIR" ls-remote origin main | cut -f1)
[ "$LOCAL" = "$REMOTE_SHA" ] || { echo "FATAL: HEAD=$LOCAL origin/main=$REMOTE_SHA" >&2; exit 2; }
echo "$DIR"

I put the check at the end because even after deciding not to borrow, silent pull failures remain (expired auth, a dropped network). With 2>/dev/null swallowing the error, the exit code alone would let a stale tree through. If the script refuses to return a directory until the SHAs match, work never starts from an old state.

Three steps at the top of a scheduled task

I placed the two scripts at the very start of the runbook, in this order.

1. Decide a writable location with pick_base.sh. If it fails, stop there and do not proceed.
2. Call fresh_repo.sh and store the returned path in a variable. The path is not returned until the SHAs match.
3. In every later step, use only that variable. I recommend leaving no fixed path such as /tmp/claudelab.net anywhere in the runbook text.

In my case the third step is the one I expect to matter most. If even one fixed path remains, an old step goes on reading it right after the way the location is chosen has been tidied up.

Pitfalls

• Cleaning with rm -rf /tmp/repos/* does not work on what other runs created. Deletion is governed by write permission on the parent directory, not the target, so you cannot remove entries under a nobody-owned 755 directory. If your out-of-space procedure says "empty /tmp", rewrite it to remove only places you created.
• Reading someone else's clone with git can be stopped by an ownership check. This time I added -c safe.directory='*' for that single call. I avoided writing it into the global config.
• The token-in-URL approach is left to the REMOTE argument here. How to carry credentials is a separate matter; I wrote up the case where it stopped working after a redirect in another article. I mask the output with sed before reading logs so the token never appears.
• Mixing up the working location can also come from looking at a different shell. The morning WS came back empty is written up here. The cause differs, but the idea of "one line to check first" is the same.

When reuse is fine, and when it is not

My decision assumes a repository around 50 MB and a handful of runs a day. Change those, and the answer changes.

• If cloning takes tens of seconds or more (deep history, LFS), reuse earns its place. Even then, keep the two rules: put it where you can write, and compare SHAs.
• If you clone every run, keep --depth 1. Pulling full history makes the 2.8 seconds a different story.
• If runs overlap, giving each run its own name such as $BASE/$NAME.$$ avoids fights over a directory (the script above falls back to that form only when deletion fails).

One thing to do next: put pick_base.sh and the SHA check at the top of your scheduled task. From that day on, you no longer have to ask where today's working directory is.