A stalled free session costs nothing when the next person resumes it in one command. It costs a full day when the next person needs a briefing first. The difference is a bundle, not a better document.
Free tiers stop mid-task for boring reasons. Context fills up. An allowance drains. A laptop sleeps at the wrong moment. The driver knows what was tried, what failed, and what comes next. Nobody else does.
Most teams patch this with prose. They write a handoff note and hope it survives contact with a fresh reader. Prose loses fidelity at every hop, and it cannot be executed. A checksummed tarball can.
This playbook defines three roles, one lane card, and two scripts. Paste it into the team wiki and run it at the next stall. It assumes git, bash, and Node, and nothing else.
Three roles on one page
The driver owns the live session and stops at the first hard block. The driver does not quietly keep fixing things for another twenty minutes. That silent tail is exactly where handoffs rot.
The packager turns the stopped session into a tarball. This takes roughly four minutes and needs no model access at all. Any teammate who can run make can do it.
The reviewer replays the tarball on a second lane and reports pass or fail. The reviewer never reads the driver's chat log. The bundle is the entire message.
Commit before you pack anything
The bundle should carry the work, so commit to a scratch branch first.
git switch -c wip/session-2026-10-26-a
git add -A
git commit -m 'wip: stop point before handoff'
Scratch branches are cheap and disposable. Losing an hour of edits is not.
The packer
Save this as tools/lane-bundle.sh and make it executable.
#!/usr/bin/env bash
# tools/lane-bundle.sh - pack a stalled session into a resumable bundle
set -euo pipefail
SESSION_ID="${1:?usage: lane-bundle.sh <session-id>}"
OUT="bundles/${SESSION_ID}"
mkdir -p "$OUT"
git bundle create "$OUT/repo.bundle" --all
git log -1 --format='%H %ad %s' --date=iso > "$OUT/head.txt"
git status --porcelain > "$OUT/dirty.txt"
jq -n --arg sid "$SESSION_ID" \
--arg head "$(cat "$OUT/head.txt")" \
--arg node "$(node -v)" \
'{session:$sid, head:$head, node:$node}' > "$OUT/env.json"
cp "${PROMPT_LOG:-.lane/prompts.jsonl}" "$OUT/prompts.jsonl" 2>/dev/null || true
( cd "$OUT" && sha256sum $(ls) > SHA256SUMS )
tar -czf "$OUT.tar.gz" -C bundles "$SESSION_ID"
echo "wrote $OUT.tar.gz"
Each file earns its place. repo.bundle carries real history, not a zip of files. head.txt pins the exact commit so the reviewer starts where the driver stopped. dirty.txt lists leftovers the driver forgot to commit. env.json records the runtime that produced the failure. prompts.jsonl preserves the exact asks, which matter when output looks wrong.
The checksum line is the load-bearing one. On macOS, swap in ( cd "$OUT" && shasum -a 256 $(ls) > SHA256SUMS ) and adjust the check later.
Run it once into a clean directory. Re-running into a dirty one will self-hash the old manifest.
chmod +x tools/lane-bundle.sh
tools/lane-bundle.sh 2026-10-26-a
The lane card
A bundle without context is a mystery. A five-field card fixes that, and it fits in a YAML file at the repo root.
# .lane/card.yaml
session: 2026-10-26-a
driver: priya
packager: sam
reviewer: jo
lane_in: free-models
lane_out: free-server
stopped_because: context exhausted at step 6 of 9
resume_with: make verify BUNDLE=bundles/2026-10-26-a.tar.gz
open_questions:
- fail fast on 429, or retry with backoff
do_not_touch:
- src/billing/**
- migrations/**
The stopped_because line is the most valuable sentence in the whole file. "Context exhausted at step 6 of 9" tells the reviewer to start at step 6. "It got weird" tells them nothing and costs an hour.
The do_not_touch list prevents a well-meaning reviewer from rewriting billing while chasing a test failure.
The verify run
The reviewer runs one command. If it exits zero on a clean machine, the bundle is valid and the session is resumable.
#!/usr/bin/env bash
# tools/verify-bundle.sh - prove the bundle resumes on a clean machine
set -euo pipefail
TARBALL="${1:?usage: verify-bundle.sh bundles/<session>.tar.gz}"
WORK="$(mktemp -d)"
tar -xzf "$TARBALL" -C "$WORK"
cd "$WORK/$(basename "${TARBALL%.tar.gz}")"
sha256sum -c SHA256SUMS
git clone repo.bundle work
cd work
git checkout "$(cut -d' ' -f1 ../head.txt)"
npm ci --ignore-scripts
npm test
A failing checksum means the tarball was edited in transit. Stop and re-pack; do not debug around it.
A failing npm ci means the runtime drifted between the two lanes. Compare env.json against the reviewer's machine before touching code.
A failing npm test is the useful outcome. That is a real, reproducible failure the next person can attack with a fresh context window.
The handoff run, in prose
The driver hits a block, commits to wip/, and runs the packer. Nobody debates whether the block is worth a bundle; a stop is a stop, and the decision belongs to the packager. The packager fills the card, drops the tarball in bundles/, and posts one line in the channel with the path and the resume_with command. The reviewer pulls, runs verify-bundle.sh, and replies with a single word plus the exit code. If it fails at checksum, the packager re-packs from a clean directory. If it passes, the reviewer starts at the step named in the card and owns the session from there.
The driver is now free. That is the point. A stalled session stops being a hostage.
Why a second lane
Some stalls are allowance problems, not comprehension problems. The work is fine; the budget is not.
That is where a second lane earns its keep. MonkeyCode provides free model access and a free server option, which makes it a plausible second lane for replaying a bundle. The operator states a free allowance on the order of ten million tokens; confirm the current figure and terms at signup rather than trusting a blog post, including this one.
Disclosure: This article was prepared as part of MonkeyCode's product outreach.
The bundle workflow benefits from that lane without depending on it. Because the reviewer resumes from a pinned commit and a checked runtime, a different model on a different box is a fair test. Model variance becomes signal instead of noise.
A cheap rehearsal costs little. Push the tarball to the free server, run verify-bundle.sh, and record the exit code next to the one from the original lane.
scp bundles/2026-10-26-a.tar.gz bench:~/bundles/
ssh bench 'cd ~ && bash verify-bundle.sh bundles/2026-10-26-a.tar.gz; echo exit=$?'
Two matching exit codes mean the failure is real and portable. Two different codes mean the lanes disagree, and the env.json diff is the first place to look.
What the bundle cannot carry
It cannot carry uncommitted file contents, only their names. Anything valuable must be committed to the scratch branch before packing.
It cannot carry secrets, and it should not try. Scrub .env files, tokens, and customer data before the tarball leaves a laptop. Treat every bundle as if it will be forwarded, because it will.
It cannot guarantee identical model output. Hosted models drift, and free tiers drift faster. The bundle pins code and runtime, never inference.
It cannot rescue a slow clone. Repos with large binaries or long histories make repo.bundle unwieldy. Above a few hundred megabytes, pack a shallow bundle and record the base commit instead.
Who should skip this
Solo developers should skip the roles and keep the packer. The tarball is still the fastest way to resume your own work tomorrow morning.
Teams working on regulated code should skip the second lane entirely. If code cannot leave a machine, the bundle stays local and the reviewer walks down the hall.
Teams without a test command should fix that first. A bundle proves resumability only when there is something deterministic to run at the end.
Start with one stall
Add the two scripts, add the card, and wait for the next block. One session is enough to learn whether the run fits your team.
The first bundle takes fifteen minutes. The second takes four. The one after an allowance runs dry takes none, because the answer already exists as a tarball with a checksum and a next command.
Top comments (0)