A Drift Ledger for the Shared Bench

A shared bench lies when the handoff has no name. The model can shift between two quiet nights. The free server can drop its scratch disk.

The ticket still looks finished to the next reader. A one-page wiki run catches that lie early. The run is a relay, not a fresh platform.

This playbook carries one prompt from pin to close. The baton is a hash of the fixture file. A changed hash voids the recorded time at once.

Teams blame the model when the retry was new. The prompt grew one quiet sentence before dawn. The server label changed without a fresh pin.

The note field stayed blank on the close. The second result cannot teach the first run. A drift ledger keeps those facts on one line.

A lab fridge shared by a night crew shows the gap. Someone moves the sample cup to a new shelf. The paper label peels in the cold air.

The morning reader trusts the shelf, not the cup. A dated tape strip fixes that trust gap fast. The wiki run is that strip, not a new fridge.

Four beats

The clock keeper opens the shift on the wiki. That person reads the project page the same day. Old grant notes stay off the run card.

A pasted token count from last month is stale. The keeper writes the page date beside the shift id. A missing date means the shift stays shut.

The prompt clerk freezes one fixture in the repo. Edits during the run start a new shift. A retry is not a license to edit.

The clerk hashes the file and pins the digest. The runner may not touch that fixture file. The pin is the baton pass, not a suggestion.

The runner executes only on the practice server. Live product hosts stay dark for this drill. Logs, keys, and customer text stay off the bench.

The runner records the exit code and the server label. The reader compares output with the fixture note. A pass needs the same hash and the same server.

A fail needs a reason before any retry starts. Silence is not a reason on this card. The reader closes the line and stops the relay.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode is the open-source bench named for this drill. The operator states two availability facts for practice.

Free model access is the first stated fact. A free server option is the second stated fact. Model names and quotas stay off this page.

Hardware, duration, and permanence stay off it too. Those details move and go stale in a wiki. The clock keeper reads them again on shift day.

A blog number is not a license term. The ledger script is a local proposal only. It does not ship as a claimed product feature.

A local gate

A team pastes it beside the wiki run. It refuses a retry that changed the prompt hash. It refuses a close that skipped the reason note.

The script is a gate, not a model score. A second pin with a new hash fails the audit. The reader then opens a new shift id.

#!/usr/bin/env python3
"""Local drift ledger. A proposal, not a product feature."""
import argparse
import hashlib
import json
import sys
from datetime import datetime, timezone
from pathlib import Path

LEDGER = Path("drift_ledger.jsonl")


def sha256_file(path: Path) -> str:
    return hashlib.sha256(path.read_bytes()).hexdigest()


def append(row: dict) -> None:
    with LEDGER.open("a", encoding="utf-8") as handle:
        handle.write(json.dumps(row, sort_keys=True) + chr(10))


def load() -> list:
    if not LEDGER.exists():
        return []
    rows = []
    for line in LEDGER.read_text(encoding="utf-8").splitlines():
        if line.strip():
            rows.append(json.loads(line))
    return rows


def pin(args: argparse.Namespace) -> int:
    digest = sha256_file(Path(args.prompt))
    append(
        {
            "event": "pin",
            "shift_id": args.shift,
            "prompt_hash": digest,
            "server_label": args.server,
            "page_seen": args.page_seen,
            "at": datetime.now(timezone.utc).isoformat(),
        }
    )
    print(digest)
    return 0


def close(args: argparse.Namespace) -> int:
    pins = [
        row
        for row in load()
        if row.get("shift_id") == args.shift and row.get("event") == "pin"
    ]
    if not pins:
        print("missing pin", file=sys.stderr)
        return 2
    if not args.note.strip():
        print("empty note", file=sys.stderr)
        return 2
    last = pins[-1]
    append(
        {
            "event": "close",
            "shift_id": args.shift,
            "prompt_hash": last["prompt_hash"],
            "server_label": last["server_label"],
            "exit_code": args.exit,
            "note": args.note.strip(),
            "at": datetime.now(timezone.utc).isoformat(),
        }
    )
    return 0


def audit(_: argparse.Namespace) -> int:
    if not LEDGER.exists():
        print("missing ledger")
        return 1
    bad = 0
    grouped = {}
    for row in load():
        grouped.setdefault(row["shift_id"], []).append(row)
    for shift_id, rows in grouped.items():
        hashes = {row["prompt_hash"] for row in rows if "prompt_hash" in row}
        servers = {row["server_label"] for row in rows if "server_label" in row}
        closes = [row for row in rows if row.get("event") == "close"]
        pins = [row for row in rows if row.get("event") == "pin"]
        if len(hashes) != 1 or len(servers) != 1 or not closes:
            print("drift " + shift_id)
            bad += 1
        elif any(not row.get("note") for row in closes):
            print("blank note " + shift_id)
            bad += 1
        elif any(not row.get("page_seen") for row in pins):
            print("missing page date " + shift_id)
            bad += 1
    return 1 if bad else 0


def main() -> int:
    parser = argparse.ArgumentParser()
    sub = parser.add_subparsers(dest="cmd", required=True)
    pin_cmd = sub.add_parser("pin")
    pin_cmd.add_argument("--shift", required=True)
    pin_cmd.add_argument("--prompt", required=True)
    pin_cmd.add_argument("--server", required=True)
    pin_cmd.add_argument("--page-seen", required=True)
    pin_cmd.set_defaults(func=pin)
    close_cmd = sub.add_parser("close")
    close_cmd.add_argument("--shift", required=True)
    close_cmd.add_argument("--exit", type=int, required=True)
    close_cmd.add_argument("--note", required=True)
    close_cmd.set_defaults(func=close)
    audit_cmd = sub.add_parser("audit")
    audit_cmd.set_defaults(func=audit)
    args = parser.parse_args()
    return args.func(args)


if __name__ == "__main__":
    raise SystemExit(main())

The clerk pins the fixture before any model call. The page date is a required flag on that pin. A missing page date fails the habit, not the model.

python3 drift_ledger.py pin \
  --shift S-41 \
  --prompt fixtures/retry_case.txt \
  --server practice \
  --page-seen 2026-10-12

python3 drift_ledger.py close \
  --shift S-41 \
  --exit 0 \
  --note "same hash and same practice server"

python3 drift_ledger.py audit

The close line demands a note with real words. An empty note returns a failure to the reader. A missing ledger file fails the audit on contact.

Mixed hashes or mixed servers print a drift mark. A clean audit means the relay held one baton. It does not mean the model answer was wise.

A tiny fixture keeps the drill cheap and repeatable. One file holds a short coding task and a check. The stand-in only proves the fixture still exists.

mkdir -p fixtures
cat > fixtures/retry_case.txt << 'EOF'
Write a function add(a, b) that returns a + b.
Do not add I/O.
EOF
python3 - << 'PY'
from pathlib import Path
text = Path("fixtures/retry_case.txt").read_text()
assert "add(a, b)" in text
print("fixture-ok")
PY

The real call belongs on the free practice server. The runner swaps that stand-in for the team command later. The clerk keeps the same shift id when the hash stays put.

The wiki page is one screen and four names. Blank names mean the shift has not started. The page holds no token count and no slogan.

# Shift run S-__

Clock keeper: ____
Page seen: ____
Prompt clerk: ____
Fixture path: ____
Runner: ____
Server label: practice
Reader: ____
Close note: ____

Pin the fixture before the call.
Run once on the practice server.
Do not edit the fixture mid-shift.
Close only with a written note.
Audit the ledger before the next crew starts.
A new hash means a new shift id.

A keeper who finds a stale count strikes it. The next crew inherits the ledger line, not a vibe. Handoff is a file, not a chat scroll.

Limits of the tape

This drill does not rank models or claim a winner. A green audit can still hide a wrong function. Human review of the diff remains the real gate.

Free servers can reset disks between two shifts. The ledger cannot restore a file the host forgot. Scratch space stays rented space, not owned storage.

Secrets do not belong in the fixture or the note. A public practice server is a poor vault for keys. The clerk strips identifiers before a prompt lands there.

Production incidents need a different on-call path entirely. This run is practice, not a live rescue. Regulated text should stay off a shared free server.

Teams with no named reader should skip the drill. A solo spike with no handoff can skip it too. Guaranteed uptime sits outside this playbook on purpose.

Better model output does not repair a loose handoff. Software around the bench still needs a named baton. A retry without a frozen prompt is a new experiment.

The ledger makes that difference visible in one file. A crew confirms free-model and server terms on shift day. That check happens on the project page before the pin.

Then the same four beats can run on a practice server. The wiki copy is the whole invitation this page offers. No second pitch belongs after a closed ledger line.