FAQ: What a Free Agent Session Does Not Prove

Have you ever copied a patch from a free agent box?
Then watched local CI reject the same tree?

I keep hearing five claims in review threads.
They sound harmless until a merge fails locally.

This FAQ treats those claims as testable myths.
A free session can draft work at useful speed.
It still cannot freeze your actual toolchain.

What I mean by a free session

Some agents give free model access for drafting patches.
Some also give a free server to run shell commands.

Disclosure: This article was prepared as part of MonkeyCode's product outreach.

I use MonkeyCode's free models and free server as scratch.
They help me try commands I might later keep.
They do not pin a compiler, image, or locale.

The rest of this piece stays useful without that product.
The receipt workflow is just git, a shell, and honesty.

How to read each answer

Each myth has a claim, a check, and a better model.
Skip anything you cannot verify on your own machine.

Ask one rude question after every remote green build.
What evidence will still exist when that box is gone?

FAQ 1: Remote green means the PR is merge-ready?

Claim: The free server built it, so the PR is done.

Did the remote compiler match your CI image?
Did it use the same libc, locale, and umask?
You probably do not know, and that is the problem.

I run this after every copy, before any review ping:

git rev-parse HEAD
git status --porcelain
git diff --stat

Then I rerun the same command CI will run.
A remote green build is a hint, not a gate.

Better model: Treat remote green as an untrusted preview.
Merge only after the local runner or CI repeats it.

Quick list I keep next to the laptop:

• The git HEAD matches the PR branch exactly.
• git status --porcelain stays empty after the copy.
• One CI command runs locally and exits zero.

FAQ 2: It was a free draft, so skip the model note?

Claim: It was only a free model. Logging is ceremony.

Which turn produced the patch you are about to commit?
If you cannot point to it, you cannot replay advice.
Free does not mean interchangeable across days or teammates.
It means the draft was unpaid, not that it was pinned.

I do not invent model names I cannot see in logs.
I still write a one-line note in the receipt file.

session_note: drafted on a free model; not a version pin

Why bother, if the name is not a hash?
Because future you will ask where the patch was born.
A note saying "free draft" beats a silent blob every time.

Better model: Record that the source was a free draft.
Never pretend the model string is a compiler hash.

FAQ 3: Copying files off the box equals a commit?

Claim: The files sit on the server, so they are saved.

Saved where, on whose disk, and under which umask?
A server path is not a branch you can push.
It is a rental workspace with a short memory.

I copy through a reviewed diff, never through hope.

# on your laptop, after scp or a download
git add -N .
git diff
# only then
git add -p

If you cannot git add -p it, you do not own it yet.

Better model: Treat the free filesystem as a clipboard only.
A commit is the first moment the work becomes yours.

Questions I ask before I even open scp:

• Which paths changed, and which paths must stay untouched?
• Did the agent rewrite lockfiles I never asked it to touch?
• Can I explain every hunk in one sitting?

FAQ 4: Locale and timezone never leak into artifacts?

Claim: The box is generic. Timestamps and sorts will match.

Have you seen tests fail on filename sort order?
Have you seen tarballs change because tar saw local time?
Have you seen Python tests break on %c locale formats?

I capture the personality of the box before I leave it.

date
date -u
locale
umask
id
python3 -c 'import locale,time,sys; print(sys.platform); print(locale.getlocale()); print(time.tzname)'

Write those values into receipt.json and compare them at home.

Better model: The free server has a quiet personality of its own.
Capture it, or you will debug ghosts after the copy.

Leaks worth hunting in copied trees:

• Sorted test output can depend on LC_COLLATE.
• Archive metadata can be stamped with the server timezone.
• Generated headers can embed local strftime text.
• File modes may only make sense under that umask.

FAQ 5: A teammate can resume from your memory?

Claim: We share the same free product, so we share state.

Do you share the same cwd and the same dirty tree?
Do you share env names and the same uncommitted patch stack?
Product sameness is not session sameness, not even close.

Better model: Hand off a receipt, not a remembered vibe.

Minimum handoff packet I will accept from a teammate:

1. Keep the receipt.json captured on the remote box.
2. Keep receipt.json from the laptop after copy.
3. Write the exact command that must pass locally.
4. Attach a git diff you can explain line by line.

No packet means no resume, because memory is not a worktree.

The artifact: two receipts and a diff

I want a file I can attach to the PR.
It records what the free session refused to freeze.

Save the script below as scripts/session-receipt.sh.
Treat it as a labeled example, not a production service.

#!/usr/bin/env bash
# session-receipt.sh — labeled example, run from a git worktree
set -euo pipefail

OUT="${1:-receipt.json}"
CMD_LOCAL="${MUST_PASS_LOCALLY:-python -m pytest -q}"

if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
  echo "run this inside a git worktree" >&2
  exit 1
fi

python3 - "$OUT" "$CMD_LOCAL" <<'PY'
import json, os, subprocess, sys, time, locale

out, cmd = sys.argv[1], sys.argv[2]

def sh(args):
    p = subprocess.run(args, capture_output=True, text=True)
    return p.returncode, p.stdout.strip(), p.stderr.strip()

_, head, _ = sh(["git", "rev-parse", "HEAD"])
_, status, _ = sh(["git", "status", "--porcelain"])
_, branch, _ = sh(["git", "branch", "--show-current"])
_, umask, _ = sh(["bash", "-lc", "umask"])
_, who, _ = sh(["id"])

receipt = {
    "captured_at_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
    "git_head": head,
    "git_branch": branch,
    "git_status_porcelain": status.splitlines(),
    "dirty": bool(status),
    "umask": umask,
    "id": who,
    "cwd": os.getcwd(),
    "locale": list(locale.getlocale()),
    "tzname": list(time.tzname),
    "python": sys.version.split()[0],
    "platform": sys.platform,
    "env_names_only": sorted(os.environ.keys()),
    "command_that_must_pass_locally": cmd,
    "model_note": "free-model draft; not a pin",
    "server_note": "free server is scratch; not CI",
}
with open(out, "w", encoding="utf-8") as f:
    json.dump(receipt, f, indent=2)
    f.write("\n")
print("wrote", out)
if receipt["dirty"]:
    print("worktree is dirty; review git diff before you trust a copy")
PY

Run it on the free server before you copy files.
Run it again on your laptop after the copy lands.
Then diff the two JSON files; that is the whole method.

chmod +x scripts/session-receipt.sh
MUST_PASS_LOCALLY="python -m pytest -q" ./scripts/session-receipt.sh /tmp/remote-receipt.json
# after copy
MUST_PASS_LOCALLY="python -m pytest -q" ./scripts/session-receipt.sh /tmp/local-receipt.json
python3 - <<'PY'
import json
remote = json.load(open("/tmp/remote-receipt.json"))
local = json.load(open("/tmp/local-receipt.json"))
keys = ["python", "platform", "locale", "tzname", "umask", "git_head"]
for key in keys:
    same = remote.get(key) == local.get(key)
    print(key, "match=" + str(same), "remote=", remote.get(key), "local=", local.get(key))
if local.get("dirty"):
    print("LOCAL_DIRTY")
PY

If git_head matches and dirty is false, the tree is honest.
If locale or umask differ, inspect generated files with extra care.

Decision table

Use this table before you click merge.

Claim you heard	Evidence that would support it	What I do instead
Remote build was green	CI image digest matches the box	Rerun the CI command locally
Free model drafted it	A written note that it was a draft	Keep the note; do not pin a fake hash
Files exist on the server	git add -p hunks you can explain	Commit only explained hunks
Locale cannot matter	Receipt locale equals laptop locale	Diff receipts; inspect generated files
Teammate can continue	Two receipts plus an explained diff	Refuse a memory-only handoff

Read the middle column twice before you argue.
If you lack that evidence, you are holding a story.

What this receipt does not prove

The receipt does not pin a model weight or vendor SKU.
The receipt does not clone a CI container or a runner label.
The receipt does not redact secrets hiding in env values.
That is why I store env names only, never values.

Free servers go away, and free models change without a changelog.
I do not claim quotas, hardware, duration, or uptime here.
Those numbers were not supplied, so they are not in this FAQ.

Who should not use this workflow

Do not put customer data on a shared free server.
Do not treat this script as a substitute for real CI.
Do not use it if you need bit-for-bit model replay.
Do not use it for regulated builds or release signing.

Release engineers need pinned images and signed provenance.
This FAQ is for people copying drafts off scratch boxes.

If your threat model includes other tenants, stop here.
A free server is a convenience, not a tenancy boundary.

A local gate I refuse to skip

After the receipt diff looks boring, I still run this.

test -z "$(git status --porcelain)" || echo "DIRTY TREE"
python3 - <<'PY'
import json, os
cmd = json.load(open("/tmp/local-receipt.json"))["command_that_must_pass_locally"]
print("running:", cmd)
raise SystemExit(os.system(cmd))
PY

If that command fails locally, the remote green was theater.
I send the patch back and I do not merge on memory.

Closing

So what did the free session actually prove?
It proved a draft could run in one unpaid environment.
That result is useful, but it is not a freeze.
It is also not CI, no matter how green it looked.

Export the receipt before you copy anything down.
If you skip that step, you are merging a rumor.