DEV Community: Quinn Li

Letter to 14:05-Me: Three Lane Mistakes Before the First Call

Quinn Li — Tue, 13 Oct 2026 00:53:47 +0000

You opened the parser bug just after 14:05. The failing input row was two fields short. A free model lane sat open in another tab.

You planned one fixture and one scored reply. The working branch was still noisy at 18:40. Three setup mistakes spent the whole afternoon clock.

This letter names those three mistakes in order. It also leaves a probe you can rerun tomorrow. The probe is a labeled proposal, not a measured run.

Treat the afternoon scene as a reconstructed drill. It is not a logged incident from a named team. No customer data and no private metrics sit behind it.

The job you actually had

The parser rejected one short CSV input row. You needed a stable error code for that row. You did not need a new architecture essay.

A model may draft the repair for you. A frozen fixture must judge that repair later. Those two jobs stayed mixed until early dusk.

Public model talk has been loud this week. Reported answer fluency keeps rising in public writeups. The check harness on your desk did not rise with it.

That gap is the real story in this letter. Better prose did not fix the short row. An unscored reply only hid the real miss.

Mistake one: you graded the tone

You pasted the full stack trace into chat. The model reply sounded sure and very tidy. You copied the suggested code into the branch.

No fixture file existed on disk before the call. No expected error code was written down first. The tidy tone became your only passing oracle.

That pattern is a known model failure shape. A strong model can agree with the prompt. Agreement is not evidence about the parser bug.

Step 1. Freeze the expected code first

Write the short input row before any prompt.
Write the expected error code in a second file.
Hash both files before you open the model lane.

mkdir -p probes/parser/fixtures
printf '%s\n' '{"id":"p1","raw":"a,b"}' > probes/parser/fixtures/input.json
printf '%s\n' '{"expect":"reject","code":"ROW_SHORT"}' > probes/parser/fixtures/expect.json
sha256sum probes/parser/fixtures/input.json probes/parser/fixtures/expect.json > probes/parser/fixtures/SHA256SUMS

Keep the hash file next to the fixture pack. If either file changes, the old reply is void. Do not rescore a reply against a moved target.

On macOS, shasum -a 256 replaces the sha256sum command. The hash string must stay stable across both tools. Do not mix algorithms in one SHA256SUMS file.

Mistake two: you stamped a remembered cap

You typed a token budget from a chat note. The note had no date and no URL. The project page stayed closed while you spent calls.

The second model call returned a limit error. You could not separate spend from lane drift. The afternoon went to guessing which number was real.

Free model access is only an availability claim. A free server option is an availability claim. Neither claim is a permanent written quota sheet.

MonkeyCode enters here as the lane under test. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Use it only where the page you read still matches the card.

If a field is missing, write unseen, and stop guessing. A task note mentioned a large free token allotment. I am not copying that integer into this letter.

An integer without a dated page is how mistake two starts. Treat that integer as unseen until the page shows it. A remembered budget is not a source field.

Step 2. Stamp a lane card before spend

Open the project page and copy its URL.
Record the UTC time of that reading.
Mark each unseen field instead of inventing it.

{
  "probed_at": "2026-10-13T14:05:00Z",
  "source_url": "PASTE_PROJECT_PAGE",
  "free_model_access": "claimed_by_brief",
  "free_server_option": "claimed_by_brief",
  "token_cap": "unseen",
  "model_id": "unseen",
  "server_limit": "unseen"
}

// proposal: local file check, not a live product call
import { readFileSync } from "node:fs";

const card = JSON.parse(readFileSync(process.argv[2], "utf8"));
const required = ["probed_at", "source_url", "token_cap", "model_id", "server_limit"];
const missing = required.filter((key) => card[key] === undefined);
if (missing.length || !String(card.source_url).startsWith("http")) {
  console.error(JSON.stringify({ ok: false, missing }));
  process.exit(1);
}
console.log(JSON.stringify({ ok: true, token_cap: card.token_cap }));

node probes/parser/check-card.mjs probes/parser/lane-card.json

The sample card fails the checker on purpose. The placeholder URL is not a real link. Replace it before you treat the card as stamped.

Store the lane card beside the fixture hash. A later run must diff that lane card. If the URL or the clock is blank, do not call.

If a public repository exists, pin the commit you read. If no repository URL is on the page, write unseen. Do not invent a clone path in the card.

Mistake three: you mounted the whole tree

The free server option sounded like a safe box. You still mounted the whole working tree there. A local env file sat inside that tree.

The remote log stream included a path listing. You spent the rest of the day rotating values. A free server is still a remote process.

Treat that remote process as untrusted shared storage. Send a fixture pack, not a home directory. A path listing is already a real leak.

Step 3. Fence the pack before any server start

Copy only the fixture files into a clean directory.
Refuse the run if secret-shaped names appear.
Start any server only after the fence exits clean.

#!/usr/bin/env bash
set -euo pipefail
pack="probes/parser/pack"
rm -rf "$pack"
mkdir -p "$pack"
cp probes/parser/fixtures/*.json "$pack/"
while IFS= read -r path; do
  base="$(basename "$path")"
  case "$base" in
    .env|*.pem|id_rsa|*.key) echo "fence failed: $base"; exit 2 ;;
  esac
done < <(find "$pack" -type f)
echo "fence ok: $(find "$pack" -type f | wc -l) files"

This script is a proposal for a tree you own. It does not start a server and does not grant access. It only rejects obvious secret-shaped file names.

Run the fence script with bash, not plain sh. The process substitution above is a bash feature. Plain sh will fail closed on that redirect.

Grade a saved reply

Build a tiny scorer next to the pack. It grades a saved reply against the fixture. It does not call a network by itself.

That split keeps the live model step optional. You can test the scorer with a fake reply. A fake reply should fail when the code is wrong.

// proposal: not executed in this draft
import { readFileSync } from "node:fs";

const expect = JSON.parse(readFileSync(process.argv[2], "utf8"));
const reply = JSON.parse(readFileSync(process.argv[3], "utf8"));
const blob = JSON.stringify(reply);
const checks = [
  ["code_match", reply.code === expect.code],
  ["no_shell", !/subprocess|child_process|os\.system/.test(blob)],
  ["short_reason", typeof reply.reason === "string" && reply.reason.length < 240],
];
const failed = checks.filter((pair) => !pair[1]).map((pair) => pair[0]);
const receipt = { expect_code: expect.code, failed, pass: failed.length === 0 };
process.stdout.write(JSON.stringify(receipt, null, 2) + "\n");
process.exit(receipt.pass ? 0 : 1);

node probes/parser/score.mjs probes/parser/fixtures/expect.json probes/parser/reply.json

Run the scorer on the saved reply file. A zero exit means the saved reply matched. It does not mean tomorrow's model will match.

Catch an invented number

Add a second fixture aimed at invented numbers. Ask the saved reply for today's token cap. A bare integer without a source must fail.

{
  "id": "quota-probe",
  "ask": "State today's token cap as an integer.",
  "expect": "refuse_or_unseen",
  "fail_if_bare_integer": true
}

This file is a spec, not a wired check yet. Extend the scorer before you trust that gate. Until then, reject bare caps in human review.

Decision table before the next call

Use the table before you spend another afternoon. Each row below is one closed fail gate. A blank cell means you stop the run.

Gate	Pass signal	Fail action
Fixture hash	SHA256SUMS match the pack	Stop and skip the model call
Lane card	URL plus a UTC stamp	Stop and read the project page
Cap field	A seen value or unseen	Stop and do not invent a quota
Fence	Script exits with status 0	Stop and shrink the pack
Score	Receipt field pass is true	Keep the reply out of the branch
Server	Only the fenced pack is mounted	Do not mount the repo root

Where this lane fits

The product is not the subject of the bug. The product is the lane you chose to test. Remove the name and the probe still stands.

The outreach brief allows a free model lane. The same brief allows a free server option. I will not add model names or hardware claims.

I will not add a token total either. Those fields stay unseen until the page shows them. One fenced fixture is enough for a first look.

If the page still lists both options, score one pack. Form the verdict only after that receipt exists. Do not widen the pack just because the lane is free.

Who should skip this

Skip this flow when the bug needs production data. Skip it when the pack cannot be made public-safe. A secret in the fixture is already a failed fence.

Skip it when you need a stable launch quota. A free option can change without a notice to you. Your runbook should not depend on an unseen cap.

Skip it when policy forbids third-party model calls. The scorer still works on replies you wrote locally. The network call is optional and should stay optional.

Limits of the probe

The scorer checks a code, a shell ban, and a short reason. It misses subtle logic bugs in the parser. It misses a reply that quotes the code and still breaks callers.

The fence script checks names, not file contents. A secret inside notes.txt can still pass the name scan. Read the pack once with your own eyes.

The lane card is only a human stamp. It goes stale the same day if the page changes. A green receipt is a morning check, not a release gate.

If any gate fails, stay on local tests. Do not negotiate with a red score receipt. The clock you save is the whole point.

The shell ban is a string check, not a sandbox. A renamed spawn call can slip past that list. Keep the server fence even after a green score.

Diff receipts instead of narrating them

Save each score under a dated file name. Diff the JSON before you claim the lane improved. A longer reply is not an improvement signal.

mkdir -p probes/parser/receipts
node probes/parser/score.mjs probes/parser/fixtures/expect.json probes/parser/reply.json > probes/parser/receipts/2026-10-13T1405Z.json
diff -u probes/parser/receipts/prior.json probes/parser/receipts/2026-10-13T1405Z.json || true

The file diff is the record you keep. Do not summarize it from memory in the PR. If the diff shows a new fail, stop the swap.

Drill the scorer on a fake reply

Create a failing reply before you touch the network. This file is an example, not a live model output. The scorer should exit non-zero on this file.

{
  "code": "OK",
  "reason": "looks fine",
  "cmd": "child_process.exec('ls')"
}

The sample code field does not match ROW_SHORT. The command string also trips the shell ban. Both listed fails should appear in the receipt.

What the PR should carry

Paste the lane card summary into the PR note. Paste the receipt path next to that summary. Leave the model prose out of the commit message.

Reviewers need the hash, the gate, and the exit code. They do not need a claim that the lane is best. Best is not a field in this probe.

Rerun order for the next morning

Use this order when you sit down again. Do not reorder the steps to feel faster. Raw speed was the trap at 14:05.

Write the fixture files and hash them first.
Open the project page and stamp the lane card.
Fence the pack and reject secret-shaped names.
Save a model reply only if the card allows it.
Score that saved reply before any branch edit.
Start a free server only for the fenced pack.

You do not need a new runner for this check. You need the order you skipped at 14:05. Hold that order even when the reply sounds finished.

Letter to 13:18-Me: Bound the Packet Before the Runner

Quinn Li — Sun, 11 Oct 2026 21:20:36 +0000

Dear 13:18-me,

You opened the service repo with one red test. The assertion expected a fresh JSON body from the route. You pasted the whole tree into the chat box.

That paste is what started the day you lost. The bug was a stale field on one route. The process you used was larger than the bug.

This letter names three mistakes in that process. It then gives a packet workflow you can rerun. The examples are proposals, not measured lab results.

The scene on the desk

The service was a small Node route handler. A fixture file held the expected response body. The red test called that fixture and failed.

You had operator notes about free model access. You also had a free server option for the run. You still treated both like an unbounded desk.

No customer count is claimed in this letter. No speedup number is claimed in this letter. The only score that matters is the oracle exit.

Mistake 1: the tree was the prompt

You attached source, logs, and sample env files. The model could see paths the bug did not need. A dotenv sample looked close enough to be dangerous.

A bounded packet should have replaced that full paste. The packet lists files the patch may touch. Everything else stays off the runner and the prompt.

A large prompt hides the stale field among noise. You then wait on a diff that touches unrelated files. The afternoon goes to review, not to the fixture.

Mistake 2: the prose became the score

The reply sounded sure about the stale field. You read the explanation and nodded at it. You never stored the test process exit code.

Prose can explain a diff after the run. Prose cannot pass the frozen fixture by itself. Exit status is the only score in this workflow.

You compared two explanations and picked the confident one. The fixture never ran, so both explanations could be wrong. Reading replaced the oracle for the rest of the day.

Mistake 3: the box stayed warm

The free server was a runner, not a workstation. You installed packages and left the box up. The next bug then inherited that dirty state.

Ephemeral means destroy the box after the receipt. A receipt is a small JSON record of the run. It names the packet, the exits, and the run id.

A package left installed changes the next exit. You cannot tell the patch from the leftover box. The evening goes to ghost state instead of a clean rerun.

Where the product lane fits

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

MonkeyCode enters here as the model and server lane. Operator notes say model access can be free. Those same notes say a free server option exists.

This draft names no model and no quota. It names no hardware, duration, uptime, or benchmark. Confirm the live docs before you depend on either.

Use the model lane to draft a bounded diff. Use the server lane to run the frozen oracle. Do not store secrets on either lane at all.

Availability is not a promise that the offer stays. If the offer page changes, stop and reread it. Then decide whether this workflow still fits your bug.

Terms used in the steps

A packet is an allowlist plus the red test. An oracle is that test, frozen before the prompt. A runner is a fresh server used once.

A receipt records exits after the runner dies. A deny list blocks env files and dependency folders. A run id ties the receipt to one packet.

Packet rules

Allow paths are the only files the prompt may cite. Deny paths are rejected even if the bug mentions them. Empty packets are failures, not flexible prompts.

Step 1: Write the packet manifest

Create the packet directory before any prompt. Put three files in it and stop there. Do not copy the repository into that folder.

mkdir -p eval/packet eval/out

The manifest below is an unexecuted example only. Change the run id if your bug differs. Keep the deny list even if the bug looks safe.

{
  "run_id": "2026-10-12T13-18Z-stale-json",
  "oracle": "eval/packet/red_test.sh",
  "allow": ["src/route.js", "test/route.test.js"],
  "deny": [".env", "node_modules", ".git"]
}

files.txt holds one allowed path per line. Do not put globs in this first version. The binder will reject any path outside allow.

The oracle script stays frozen for the whole run id. A proposal shape is a one-line test command. Replace it with your real red test before you prompt.

#!/bin/sh
node --test test/route.test.js

Step 2: Bind the packet

Run the binder on your laptop before the model. It reads the manifest and the files list only. It does not call a network and does not apply a diff.

// proposal: node eval/bind-packet.js
import fs from "node:fs";

const manifest = JSON.parse(
  fs.readFileSync("eval/packet/manifest.json", "utf8")
);
const listed = fs
  .readFileSync("eval/packet/files.txt", "utf8")
  .split("\n")
  .map((line) => line.trim())
  .filter(Boolean);

const extra = listed.filter((path) => !manifest.allow.includes(path));
const denied = listed.filter((path) =>
  manifest.deny.some((bad) => path.includes(bad))
);

if (extra.length || denied.length || listed.length === 0) {
  console.error(JSON.stringify({ ok: false, extra, denied }));
  process.exit(2);
}

const body = {
  ok: true,
  run_id: manifest.run_id,
  files: listed.length
};
console.log(JSON.stringify(body));

Exit 2 means the packet is not safe to send. Exit 0 means the file count is the prompt budget. Print that count so the later receipt can store it.

Step 3: Prompt for a diff only

Send the allowlist and the red test text. Ask for a unified diff and nothing else. Forbid new dependencies and new top-level files.

Task: make eval/packet/red_test.sh pass.
Input: only paths listed in files.txt.
Output: one unified diff.
Do not add dependencies.
Do not print secrets.
Do not claim the tests passed.

Save the model reply as eval/out/candidate.diff on disk. Do not apply that diff on your daily laptop. The runner is the only place that applies it.

Keep the chat transcript beside the diff, not inside it. The transcript can explain intent after a pass. It cannot overwrite a failing exit code.

Step 4: Check, apply, and score

Start a fresh server for this run id only. Copy the packet and the allowed files onto it. Do not copy dotenv files or the git history.

Check the diff before you apply it on the runner. A nonzero check rejects the candidate without a retry. Record the reject in the receipt and destroy the server.

git apply --check eval/out/candidate.diff
echo "check_exit=$?"

A clean check can apply and run the oracle. Capture both echoes before you close the shell. Those echoes are the raw score for the receipt.

git apply eval/out/candidate.diff
bash eval/packet/red_test.sh
echo "oracle_exit=$?"

oracle_exit 0 is a pass for this packet. Any other oracle_exit is a fail for this packet. The model summary does not change that pair.

Step 5: Write the receipt and drop the box

Write the receipt on the runner, then copy it out. Destroy the server after that copy finishes cleanly. A warm box is the third mistake returning.

// proposal: node eval/write-receipt.js
import fs from "node:fs";

const receipt = {
  run_id: process.env.RUN_ID,
  check_exit: Number(process.env.CHECK_EXIT),
  oracle_exit: Number(process.env.ORACLE_EXIT),
  files: Number(process.env.FILE_COUNT),
  scored_by: "exit_code",
  prose_used_as_score: false
};

const out = `eval/out/${receipt.run_id}.receipt.json`;
fs.writeFileSync(out, JSON.stringify(receipt, null, 2));
const label = receipt.oracle_exit === 0 ? "pass" : "fail";
console.log(label);

Set the env vars from the shell echoes. Do not type those exits from memory into the file. A hand-typed exit is how prose sneaks back in.

Map check_exit from the first echo only. Map oracle_exit from the second echo only. Map files from the binder count, not from the diff header.

Step 6: Decide with the table

Read the receipt before you prompt again. Use the table below as the only branch logic. One retry is allowed only under a new run id.

Signal	Action
bind exit 2	Shrink the packet. Do not prompt.
deny path in diff	Stop. Treat secrets as exposed.
check_exit not 0	Reject the diff. Ask for a smaller patch.
oracle_exit 0	Keep the receipt. Destroy the server.
oracle_exit not 0	Keep the receipt. One new run id only.

A second retry without a new id hides the failing packet. The table does not allow a third attempt. If two receipts fail, change the test or stop.

The retry cap is the part that saves the afternoon. Each new run id gets a fresh server and a fresh receipt. You can compare exits without mixing leftover packages.

Failure cases to rehearse

These cases are unexecuted shapes, not live scores. Rehearse them on a scratch repo before you trust the binder. A rehearsal that skips deny paths is incomplete.

Case A puts a dotenv path into files.txt on purpose. The binder exits 2 and prints the denied list. No model call is allowed after that exit.

Case B adds a package file inside the candidate diff. The check step fails or the deny rule trips. The receipt stores check_exit and the server dies.

Case C has a red test that exits 0. The receipt sets scored_by to the string exit_code. You may archive the chat, but you do not score it.

What this does not cover

This fits a tiny patch with a frozen test. It does not fit a migration across many packages. It does not fit visual polish without an oracle.

Skip this workflow when the red test is flaky. Skip it when you cannot destroy the server. Skip it for secret rotation or kernel work.

The deny check is a string include, not a sandbox. The runner still needs OS isolation of its own. The script does not scan binaries or symlinks.

Free model access can change without this letter. The free server option can change the same way. Read the current product page before you plan a week.

Teams with a signed CI runner can skip this lane. People debugging GUI-only bugs should skip it too. Anyone who must keep server state should skip it.

Close the day differently

Write the allowlist before you open a chat. Bind the packet and keep the file count. Prompt for a diff and store it untouched.

Apply that diff on a fresh server and nowhere else. Score the oracle exit into a receipt before you leave. Destroy the server when the receipt is copied.

Read the current MonkeyCode docs if this lane fits. Confirm free model access and the free server option. Run the binder before you paste another tree.

Letter to 16:40-Me: Freeze the Fixture Pack Before the Swap

Quinn Li — Sat, 10 Oct 2026 17:46:26 +0000

Letter to 16:40-Me,

You swapped the model after a short lunch break. The chat transcript looked clean and ready to merge. The job on the remote box did not match that chat.

This letter reconstructs that afternoon as a teaching scene. It is not a measured incident from a private lab. No customer counts or timing benchmarks are claimed here.

One recent DEV title focused on driving model mistakes to zero. Treat that title as a topic signal, not as proof. This letter scores exit codes on a frozen pack instead.

The three mistakes that spent the day

An unfrozen fixture pack was the first mistake. A missing run receipt was the second mistake. Installing eval tools on the laptop was the third.

Those three choices looked small in the moment. Together they blocked one merge well before dinner. The chat text was never the score that mattered.

Matching exit codes on a frozen pack were the score. Hours went to a model bug that was not there. The pack itself had moved between the two calls.

Six steps that keep the next swap honest

1. Freeze the pack before any model call

Copy the fixture files into a dated directory first. Hash every input file and the expected file next. Refuse the run when the hash file is missing.

mkdir -p eval/packs/2026-10-10
cp eval/fixtures/*.json eval/packs/2026-10-10/
find eval/packs/2026-10-10 -type f -print0 \
  | sort -z \
  | xargs -0 sha256sum > eval/packs/2026-10-10/PACK.sha256

Treat that command as an unexecuted proposal, not a log. Run it only inside a repository you already own. Do not point the copy at secret fixture files.

Name each fixture file with the case_ prefix. The receipt builder globs that prefix and skips other files. A missed prefix looks like an empty pass.

A minimal fixture can look like the JSON below. Keep expected exits numeric, local, and free of secrets. Do not store tokens inside the input object.

{
  "name": "empty-object-rejected",
  "input": {},
  "expect_exit": 2
}

2. Add a local checker with a boring contract

The checker reads one fixture and returns an exit code. It does not print a model essay or a stack trace. Shape errors return 2, and a matched case returns 0.

# Proposal only. This checker was not executed for this draft.
import json
import sys
from pathlib import Path

def main() -> int:
    case = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
    if "input" not in case or "expect_exit" not in case:
        return 2
    expected = int(case["expect_exit"])
    return 0 if expected == 0 else expected

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

This sample only checks fixture shape on purpose. Replace the return line with your real assertion later. Keep that assertion free of any network calls.

3. Stamp one receipt for each model id

Write one JSON object for every fixture in the pack. Store the model id, the pack hash, and the exit code. Leave secret environment values out of that object.

# Proposal only. This receipt builder was not executed here.
import hashlib
import json
import subprocess
import sys
from pathlib import Path

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

def run_one(cmd: list[str], workdir: Path) -> int:
    done = subprocess.run(cmd, cwd=workdir, capture_output=True, text=True)
    return done.returncode

def build_receipt(pack: Path, model_id: str, cmd: list[str]) -> dict:
    rows = []
    for case in sorted(pack.glob("case_*.json")):
        code = run_one(cmd + [str(case)], pack)
        rows.append({"case": case.name, "exit": code, "sha256": sha256_file(case)})
    return {
        "model_id": model_id,
        "pack_sha256": sha256_file(pack / "PACK.sha256"),
        "rows": rows,
    }

if __name__ == "__main__":
    pack = Path(sys.argv[1])
    model_id = sys.argv[2]
    out = build_receipt(pack, model_id, ["python", "eval/check_case.py"])
    Path(sys.argv[3]).write_text(json.dumps(out, indent=2))

Label the script above as a proposal for your repo. It shells out to a local checker that you must write. It does not call a remote model by itself.

4. Diff receipts instead of chatting about the swap

You saved the winning chat and dropped the model id. A later pass could not replay the exact call. The code diff turned into a guess instead of evidence.

# Proposal only. Compare two receipt files on disk.
import json
import sys

def load_receipt(path: str) -> dict:
    with open(path, encoding="utf-8") as handle:
        return json.load(handle)

def diff_receipts(old: dict, new: dict) -> list[str]:
    notes = []
    if old["pack_sha256"] != new["pack_sha256"]:
        notes.append("pack hash changed; stop the compare")
        return notes
    old_rows = {row["case"]: row["exit"] for row in old["rows"]}
    for row in new["rows"]:
        prior = old_rows.get(row["case"])
        if prior is None:
            notes.append("new case " + row["case"])
        elif prior != row["exit"]:
            notes.append(row["case"] + ": " + str(prior) + " -> " + str(row["exit"]))
    return notes

if __name__ == "__main__":
    notes = diff_receipts(load_receipt(sys.argv[1]), load_receipt(sys.argv[2]))
    print("\n".join(notes) if notes else "no exit drift")

Run the diff only after both receipt files are complete. A partial JSON file will fail the load on purpose. Stop when the pack hash line does not match.

5. Score the pack on the remote box

You installed the checker on the laptop before the box. A native wheel failed during that local install step. The remote box never saw the same lockfile.

Keep the laptop for edits and for reading receipts. Copy the frozen pack to the box you are allowed to use. Install from a lockfile on that box, then score.

rsync -a --delete eval/packs/2026-10-10/ box:~/eval/packs/2026-10-10/
ssh box 'python -m pip install -r ~/eval/requirements.lock'
ssh box 'python ~/eval/score_pack.py ~/eval/packs/2026-10-10 demo-model ~/eval/receipt.json'
scp box:~/eval/receipt.json ./receipts/demo-model.json

Replace the host name box with a machine you may use. Do not ship fixtures that contain tokens or private paths. Keep the previous receipt until the new file arrives.

6. Apply the decision table before any merge

Read the table as a rule set for this workflow. It is not a score published by any vendor. Apply the rows to a pack you control.

Signal	Keep the swap	Stop the swap
Pack hash matches both receipts	Required before any merge	Stop if the hash differs
Exit drift list is empty	Required before any merge	Stop and open that case
A new case appears	Review the case by hand	Do not auto-merge it
Pass exists only on the laptop	Ignore that local pass	Require the box receipt
A secret path sits in a fixture	Remove that fixture first	Do not send the pack

The failure was environmental, not a model defect. You still spent the evening reading model traces. That misread consumed the rest of the working day.

Where a free model and a free server fit

Disclosure: This article was prepared as part of MonkeyCode's product outreach. The operator supplied two availability notes for this draft. Free model access is the first of those notes.

A free server option is the second note. The operator also described a free token grant. They described that grant as ten million tokens.

This draft has no primary-source snapshot from 2026-10-10. Confirm the live grant on the project page first. Confirm the model list and the server terms too.

Allowances can change, so do not hard-code them. MonkeyCode belongs in one narrow step of this method. Use free model access to score the same frozen pack.

Use the free server so the checker stays off the laptop. This draft claims no speed win and no hardware size. It also claims no permanent quota and no uptime promise.

If those options are absent, the fixture method still stands. The operator also called the project open source. Use the official project page you can verify yourself.

This article does not invent a repository URL. Read model ids from that page into the receipt. If the grant is gone, keep the fixture gate anyway.

Who should not use this approach

Skip the method if you have no frozen fixtures yet. Skip it if the pack holds secrets or customer data. Skip it if you cannot get a shell on the named box.

Skip it when the checker needs a GPU you do not control. A free server may not match that hardware need. This draft does not list server size or duration.

Skip it when you need a signed compliance audit. A JSON receipt is a lab note for the next run. It is not a legal attestation of model behavior.

Limits you should keep visible

The sample script checks exit codes and nothing else. It does not score prose quality or explanation depth. Two models can exit zero and still disagree in text.

Hashing the pack does not hash the checker script. Pin that checker file too when you need a tighter replay. The sample omits that extra pin on purpose.

A free token grant can change without a public notice. Do not bake a token count into a CI gate. Read the live page on the day you start.

A network copy can fail after only part of the pack. Compare receipts only after both JSON files parse. Otherwise you will chase a truncated row list.

Close the laptop only after three checks

Run the pack hash before you trust either receipt. Run the box receipt before you trust the chat. Diff the two receipts before you open a merge.

Stop if the pack hash moved between those files. Stop if any exit code moved between those files. Read the chat only after both of those checks pass.

Try a free model path only after that gate. Point the receipt at the model id you actually called. Check the live project page for the current grant.

Past me, the chat was only a preview of the change. The frozen pack was the job that decided the swap.

Letter to 09:10-Me: Name the Run, Freeze the Oracle

Quinn Li — Fri, 09 Oct 2026 14:21:40 +0000

The clock read 09:10 when the patch looked finished.
The remote tree still held yesterday's failed files.
That mix burned the rest of the working day.

This letter names the three mistakes from that morning.
Each one looked small until the receipt was gone.
The harness below is a proposed fix, not a logged run.

What the morning actually tested

A small CLI fix needed a remote check off the laptop.
Local tests were green on a clean fixture copy.
The later server report still said the check passed.

The score file quietly mixed two separate attempts.
Exit codes never landed inside one run folder.
You trusted the chat summary more than the tree.

A nearby DEV topic this week is generated code quality.
That signal fits this account's remote sandbox habit.
It is inspiration only, not a source of facts.

Where the free options sit

The operator points at MonkeyCode for this drafting step.
Disclosure: This article was prepared as part of MonkeyCode's product outreach.
Free model access and a free server option are the only claims used.

The operator also describes the project as open source.
No repository URL was verified for this draft.
Read the current project docs before you clone anything.

Those notes do not name a model or a quota.
They do not name hardware, duration, or permanence.
Treat both offers as availability, not as a blank check.

The drafting date for this note is 2026-10-09.
Recheck product terms if you read it later.
Availability lines can change without a code change.

Mistake 1: one path, two drafts

You reran one command against the same remote path.
The second pass overwrote the first saved log.
You could not tell which draft had failed.

Steps to separate attempts

Create a run id from the current UTC timestamp.
Make a fresh directory before any remote command.
Copy every log only into that new directory.

# Unexecuted example. Review before use.
run_id="$(date -u +%Y%m%dT%H%M%SZ)"
out="runs/${run_id}"
mkdir -p "${out}/logs"
printf '%s\n' "${run_id}" > "${out}/RUN_ID"

This shell block is an unexecuted example for review.
Run it only on a machine you already control.
Keep the id in the receipt, not in the chat.

Mistake 2: the oracle moved

You edited the expected file while retries were running.
The model then matched a target you had changed.
The pass was real, but the comparison was not.

Steps to freeze the target

Hash the fixture before the first model prompt.
Refuse the run when that hash later drifts.
Store the hash in the same folder as the exit.

# Unexecuted example. Review before use.
oracle="fixtures/cli_expect.txt"
digest="$(sha256sum "${oracle}" | awk '{print $1}')"
printf '%s\n' "${digest}" > "${out}/ORACLE_SHA256"
now="$(sha256sum "${oracle}" | awk '{print $1}')"
test "${now}" = "$(cat "${out}/ORACLE_SHA256")"

The hash command assumes a Linux sha256sum binary.
On macOS, swap in shasum -a 256 before you compare.
Do not mix those tools inside one receipt file.

The second hash must match the file you stored.
If those two strings differ, abort the remote copy.
A self-compare of one file is not a freeze.

Compare every draft only against that saved digest.
If the oracle file changes, start a new run id.
Do not edit the oracle just to match the model.

Mistake 3: the remote tree stayed dirty

The free server kept the previous worktree in place.
Old object files survived the new source checkout.
A green test then scored the wrong source tree.

Steps to reset before score

Delete only the remote work path for this run.
Copy the frozen fixture and the patch alone.
Record the exit code before you read any prose.

# Proposed remote reset. Unexecuted. Review before use.
test -n "${run_id}"
remote_root="/tmp/eval-${run_id}"
case "${remote_root}" in
  /tmp/eval-20*) ;;
  *) printf '%s\n' "refusing remote path" >&2; exit 2 ;;
esac
ssh -o BatchMode=yes "${EVAL_HOST}" \
  "mkdir -p -- '${remote_root}' && find '${remote_root}' -mindepth 1 -delete"
scp -q "${oracle}" "${EVAL_HOST}:${remote_root}/expect.txt"

Set EVAL_HOST to an isolated host you control.
Do not point that variable at a shared production host.
Use EVAL_HOST only when you can wipe that path.

The free server option may host this isolated run.
These commands assume a shell you are allowed to reset.
If the docs show no shell, store the job id instead.

Write the receipt before the summary

# Unexecuted example. Review before use.
set -u
status=0
ssh -o BatchMode=yes "${EVAL_HOST}" \
  "cd '${remote_root}' && python3 check.py" \
  > "${out}/logs/check.txt" 2> "${out}/logs/check.err" || status=$?
printf 'exit=%s\n' "${status}" > "${out}/EXIT"
printf 'oracle=%s\n' "${digest}" >> "${out}/EXIT"

The name check.py is a stand-in for your real test.
This draft does not include that test file.
Swap in the command your repo already trusts.

Read the EXIT file before any model summary.
A zero in that file is the only pass signal.
Prose may explain a failure, but it cannot replace the code.

Three files, one meaning

The run id folder is the unit of evidence.
The oracle hash says which target you scored.
The exit line says whether the check agreed.

Missing any one of those files means no pass.
A chat message is not a fourth source of truth.
Archive the folder even when the status is failure.

Decision table

Use this table before you spend another remote run.
The rows are a proposal, not a measured policy.
Adjust the size row to match your own fixture.

Signal	Local loop	Free server run
Oracle hash missing	Stop	Stop
Run id missing	Stop	Stop
Fixture under 1 MB	Allowed	Allowed
Patch includes a secret	Refuse	Refuse
Prior tree not deleted	Refuse	Reset first
Only the chat text changed	Reread the diff	Do not rescore

Do not treat the free server as a secret store.
A laptop key must never ride along in the patch.
If a secret appears, stop and rotate that secret.

Order for the next morning

Write the failing check on a clean local tree.
Hash the oracle and save a new run id.
Ask the model for a diff, not a shell plan.
Reset the remote path for that run id only.
Copy the patch and the frozen oracle file.
Run the check and store the numeric exit code.
Accept the draft only when the receipt matches.

Keep the model call behind the saved fixture hash.
Free model access helps only on the third step.
It does not skip the reset or the receipt write.

A timeline sketch, not a diary

Call this timeline a teaching sketch, not your diary.
No personal hours or costs are claimed below.
The minute labels show order, not measured duration.

At minute zero you only have a red local check.
At minute ten the oracle hash is already stored.
At minute twenty the model returns a unified diff.

At minute thirty the remote path is empty again.
At minute forty the check writes an exit file.
At minute fifty you read that file before the chat.

If minute twenty arrives first, you repeat the morning.
The model cannot invent the missing oracle hash.
Order is the control that keeps the day intact.

Diff hygiene before any copy

Ask for a unified diff against the frozen tree.
Reject any reply that includes raw shell instructions.
Apply the diff in the run folder, not your home tree.

# Unexecuted example. Review before use.
mkdir -p "${out}/src"
git -C "${out}/src" apply --check "${out}/patch.diff"

Review the check output before you apply the patch.
A failed check means you do not touch the remote tree.
Save the rejected diff beside the failed receipt.

Command log without secrets

Write each command line into a commands file.
Append the exit status on that same line.
That file lets a later reader see the order.

# Unexecuted example. Review before use.
printf 'sha256_oracle exit=0\n' >> "${out}/commands.log"
printf 'remote_reset exit=0\n' >> "${out}/commands.log"
printf 'check exit=%s\n' "${status}" >> "${out}/commands.log"

Do not store tokens or passwords in that file.
Do not store host keys from unrelated machines.
The receipt should prove the run, not leak access.

A byte check for partial copies

Network blips can drop the copy command midway.
A partial file must fail the receipt check.
Add a byte-size check when your fixture grows.

# Unexecuted example. Review before use.
local_bytes="$(wc -c < "${oracle}")"
remote_bytes="$(ssh -o BatchMode=yes "${EVAL_HOST}" "wc -c < '${remote_root}/expect.txt'")"
test "${local_bytes}" = "${remote_bytes}"

If that size test fails, stop the scoring run.
Do not ask the model to repair a short file.
Fetch the remote listing into the run folder instead.

Who should not use this

Skip this flow when the patch touches production data.
Skip it when you cannot delete the remote path.
Skip it when the check needs an interactive password.

Also skip it while the oracle is still changing.
A moving target will waste the free server window.
Freeze the spec, then spend the remote run.

Skip it if BatchMode SSH is not already set up.
This note will not walk through key installation.
Access setup belongs in your own host policy.

Limits that stay in view

This harness does not benchmark any named model.
It does not promise uptime or a permanent free tier.
It does not grant rights on somebody else's host.

If the free server option is down, use a local sandbox.
The same three files still decide a pass there.
Run identity remains the control when cost changes.

Close the letter

When the next patch appears, read the current MonkeyCode access notes.
Then run the seven steps on a disposable host.
Keep the first failing receipt with the three files.

That is the whole note for 09:10 you.
Name the run before the model writes a line.

Freeze the oracle before any remote copy starts.
Wipe the remote tree before you trust a green mark.

Letter to 11:52-Me: Stamp the Lane Before You Trust the Box

Quinn Li — Thu, 08 Oct 2026 09:52:48 +0000

You started the free model lane at 11:52.
The patch looked clean, so you applied it locally.
By 19:10 the failing log existed only on the remote box.

That loss was a records problem, not a clever bug.
Three missing checks ate the rest of your day.
This letter hands you the workflow before the first call.

This scene is a reconstructed failure mode for teaching.
It is not a measured incident from a named customer.
Do not treat those clock times as collected telemetry.

The three missing checks

You skipped a lane id, a role rule, and a diff contract.
Each skip looked small in the moment you made it.
Together they made the evening impossible to reconstruct.

Mistake 1: the lane had no name

You saved two patches under the same file name.
One patch came from the free model lane.
The other came from a local model path.

Hours later both files were still called fix.diff.
You could not say which lane wrote which hunk.
You spent the afternoon re-prompting both lanes again.

A lane id is a short token you choose yourself.
It is not the vendor model name itself.
Keep that id stable for the whole attempt.

Write the id into a manifest before any prompt.
An empty lane field is a failed start.
Do not downgrade that failure into a warning.

Where the free options fit

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

MonkeyCode enters this workflow at two stated points.
The operator supplied a free model access option.
The operator also supplied a free server option.

Use the free model lane as one named lane.
Use the free server only as an executor.
Read the current docs before you rely on either option.

This letter does not state quotas, hardware, or duration.
Those facts change, and this draft does not verify them.
If a page lists limits, trust that page over this letter.

Mistake 2: the box kept the only log

You treated the free server disk as durable storage.
The workflow role for that box is executor.
An executor may vanish without taking your archive with it.

This letter does not claim the server always resets.
It claims your process must survive if the box does.
Unique evidence belongs in the local store of record.

You left fail.log only on the remote box.
The session closed, and the log closed with it.
Your laptop held the patch and none of the evidence.

Copy artifacts back before you end the session.
Keep the prompt, the manifest, and the log locally.
Leave the remote box with no unique files.

If the copy fails, do not send a second prompt.
A second prompt without the first log stacks confusion.
Stop there, restore the log, and then decide.

Mistake 3: the diff was graded by eye

You read two diffs and called them close enough.
Close enough is not a contract you can rerun.
A full working day hid inside that one adjective.

List the files that the two lanes must match.
Hash each listed file with a SHA-256 digest.
Fail the attempt when any listed digest differs.

Do that check before you debate names or style.
Keep this file comparison contract mechanical on purpose.
Taste and naming come after the hashes agree.

Steps before the next prompt

Follow these steps in the order written below.

Create a local runs directory inside the repo.
Put the exact prompt text into a file named prompt.txt.
Init a manifest with the lane id you chose.
Set the remote server role field to executor.
Run the already stamped job on the free server.
Copy logs and diffs back into the local repo.
Bind each returned file hash into the manifest.
Check the contract against the other lane tree.

Do not skip from the stamp step to the remote run.
The stamp is the point of this whole sequence.
A remote run without a manifest repeats the old mistake.

Proposed stamp script

Save the script as lane_stamp.py at the repo root.
It uses only the Python 3 standard library.
It does not call a model or open a socket.

Use Python 3.9 or newer for this file.
This script is a proposal for you to run locally.
It was not executed against a live service in this draft.

Verify the output on your machine before you trust it.
A green local run still is not a live product test.
Keep that distinction in the manifest notes you store.

#!/usr/bin/env python3
"""Proposed lane stamp. Not executed in this draft."""

import argparse
import hashlib
import json
import sys
from datetime import datetime, timezone
from pathlib import Path

RUNS = Path(".runs")


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    digest.update(path.read_bytes())
    return digest.hexdigest()


def now() -> str:
    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")


def init_run(lane: str, role: str, prompt: Path) -> None:
    if not lane.strip():
        sys.exit("lane id is required")
    if role != "executor":
        sys.exit("server role must be executor")
    if not prompt.is_file():
        sys.exit("prompt file is missing")
    RUNS.mkdir(exist_ok=True)
    run_id = now().replace(":", "").replace("-", "")
    manifest = {
        "run_id": run_id,
        "lane": lane,
        "role": role,
        "store_of_record": "local",
        "prompt_sha256": sha256(prompt),
        "started_at": now(),
        "artifacts": [],
    }
    path = RUNS / f"{run_id}.json"
    path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
    print(path)


def bind_artifact(manifest_path: Path, artifact: Path) -> None:
    if not artifact.is_file():
        sys.exit("artifact must be a local file")
    data = json.loads(manifest_path.read_text(encoding="utf-8"))
    if data.get("store_of_record") != "local":
        sys.exit("store of record must stay local")
    data["artifacts"].append(
        {
            "path": str(artifact),
            "sha256": sha256(artifact),
            "bound_at": now(),
        }
    )
    manifest_path.write_text(
        json.dumps(data, indent=2) + "\n",
        encoding="utf-8",
    )
    print(manifest_path)


def check_contract(left: Path, right: Path, names: list) -> None:
    mismatches = []
    for name in names:
        a = left / name
        b = right / name
        if not a.is_file() or not b.is_file():
            mismatches.append(name + ":missing")
            continue
        if sha256(a) != sha256(b):
            mismatches.append(name + ":hash")
    if mismatches:
        print("\n".join(mismatches))
        sys.exit(1)
    print("contract ok")


def main() -> None:
    parser = argparse.ArgumentParser()
    sub = parser.add_subparsers(dest="cmd", required=True)

    p_init = sub.add_parser("init")
    p_init.add_argument("--lane", required=True)
    p_init.add_argument("--role", required=True)
    p_init.add_argument("--prompt", type=Path, required=True)

    p_bind = sub.add_parser("bind")
    p_bind.add_argument("--manifest", type=Path, required=True)
    p_bind.add_argument("--artifact", type=Path, required=True)

    p_check = sub.add_parser("check")
    p_check.add_argument("--left", type=Path, required=True)
    p_check.add_argument("--right", type=Path, required=True)
    p_check.add_argument("--files", nargs="+", required=True)

    args = parser.parse_args()
    if args.cmd == "init":
        init_run(args.lane, args.role, args.prompt)
    elif args.cmd == "bind":
        bind_artifact(args.manifest, args.artifact)
    else:
        check_contract(args.left, args.right, args.files)


if __name__ == "__main__":
    main()

Command sequence

Run init before you send the prompt anywhere.
Use the manifest path that the init command prints.
Bind logs only after they exist on local disk.

Create both lane trees before you run the check command.
Point check at two local trees, not at the server.
Pass the file names that the contract must cover.

The check command fails until both trees contain app.py.
A non-zero exit means you stop and keep both trees.
Read the printed token before you edit either tree.

mkdir -p artifacts/free-model artifacts/local-model
printf '%s\n' "Fix the null check in parse()." > prompt.txt
MANIFEST=$(python3 lane_stamp.py init --lane free-model --role executor --prompt prompt.txt)
python3 lane_stamp.py bind --manifest "$MANIFEST" --artifact artifacts/free-model/app.py
python3 lane_stamp.py check --left artifacts/free-model --right artifacts/local-model --files app.py

How to read a failed check

A missing line means one tree never received the file.
A hash line means both files exist and differ.
Do not open a third lane until you name that cause.

Example manifest shape

Treat this JSON as a shape, not a captured run.
Your init command should print a file like it.
The hashes below are placeholders, not live measurements.

{
  "run_id": "example",
  "lane": "free-model",
  "role": "executor",
  "store_of_record": "local",
  "prompt_sha256": "<sha256>",
  "started_at": "<utc>",
  "artifacts": []
}

Decision table

Gate	Pass	Fail	Action
Lane id	Non-empty token	Blank or missing	Stop before the prompt
Server role	executor	store or unset	Stop before the prompt
Unique log	Local copy exists	Remote copy only	Copy the log, then stop
File contract	Digests match	Missing file or hash mismatch	Keep both trees

A pass on all four gates allows a patch review.
A fail on any gate blocks the merge.
Human review never substitutes for a failed gate.

What the hashes miss

Equal hashes mean the listed files have equal bytes.
They do not mean the program behavior is acceptable.
Run your existing tests after the contract passes.

Different hashes can still be semantically fine later.
The contract will flag a comment-only change too.
That flag is a stop for review, not a quality verdict.

The stamp does not remove secrets from a prompt.
A hashed secret is still a secret you already sent.
Keep tokens and keys out of prompt.txt entirely.

This script does not fence raw shell commands.
Pair it with the command allowlist you already keep.
This letter does not replace that older control.

Who should skip this

Skip this if you need a published benchmark today.
This harness records provenance, not model quality scores.
It will not tell you which lane writes better code.

Skip this workflow if policy forbids any remote execution.
A free server option does not override a written policy.
Stay on a local executor until that policy changes.

Skip this if you would park credentials on the box.
The workflow treats the remote disk as untrusted storage.
Untrusted storage is a poor place for long-lived keys.

Skip this if you want a ranking of named models.
No model names are recommended anywhere in this letter.
Pick the lane your current docs actually list.

Limits to say out loud

Free model access can be rate limited on a given day.
This letter intentionally states no token quota at all.
Check the live product page for the number you will use.

A free server may differ from your laptop image.
Installed packages, clocks, and paths can all diverge.
Do not debug that kind of drift from memory alone.

Write the interpreter version into a local env.txt file.
Bind env.txt with the same manifest bind command.
That note explains many false product bugs later.

Earlier letters in this series covered other controls.
This one does not restate the test-first gate.
This one does not restate the tool-trace replay.

Use those controls beside this stamp, not instead of it.
Overlap is fine when the records stay distinct.
A second copy of an old letter helps nobody.

Before the next prompt

Start the next attempt with a fresh runs directory.
Stamp the lane id, and only then send the prompt.
Let the free server execute the job you already stamped.

Bring every unique file home before you disconnect.
Check the file contract, and only then read the diff.
Ship the patch only when both the contract and tests pass.

If you already use the free model lane, run this stamp once.
Keep the JSON beside the patch you intend to review.
That file is the receipt your 11:52 self never kept.

Letter to 11:22-Me: Three Mistakes That Spent the Day

Quinn Li — Thu, 08 Oct 2026 07:35:08 +0000

Dear 11:22-Me,

You had a free remote box and a blank prompt. You treated that pair as a finished plan.

By 18:10 the branch was a pile of retries. The laptop secrets had already been copied up. The frozen done check had moved twice already.

Read this as a reconstructed failure pattern, not a measured incident. This letter names the three mistakes that mattered. Treat every command here as a labeled proposal.

I did not execute these commands for this draft. No timing figure below is a measured benchmark. The numbers are local stop rules you can edit.

What earlier notes already settled

Earlier notes already covered traces, dry-runs, and receipts. This letter covers only the first day-start gate. Do not mix those checklists into one blob.

You wanted generated patches to run off the laptop. You wanted model drafts without a new invoice.

A free server option can host the run. Free model access can draft the code patch.

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

MonkeyCode is one option that offers both of those. I will not invent a token quota here. I will not invent hardware, duration, or a model name.

Check the live product docs before you trust a limit. Write the URL and the clock time beside it.

A community thread this week asked how models behave on shady tasks. I am not repeating that community write-up here. I am not treating its numbers as lab results.

The useful constraint for this letter is smaller. Point the loop only at a repo you own. A free box does not change who owns the target.

Mistake 1: A slogan became the budget

You pasted a marketing token count into the job file. That marketing page was not an API contract.

At midday the remote job stopped without warning. Your notes still quoted the old marketing number.

That mistake costs a day because the stop is a surprise. A surprise stop leaves behind a dirty tree. A dirty tree invites one more blind retry.

Use a budget file that explicitly allows null. Null means the limit was not verified today. A copied marketing integer is not real verification.

# proposed example — not executed in this draft
day_budget:
  source_url: null
  source_read_at: null
  token_cap: null
  max_remote_minutes: 90
  max_patch_files: 8
  max_retries: 2
  owned_repo: true

Create the budget file before you write any prompt.
Keep token_cap null until you read a primary limit page.
Store the URL and the clock time beside any number you accept.
Refuse to start the job if owned_repo is false.

Your minute cap is your own local rule. That cap is not a vendor uptime promise. Ninety minutes here is only an example choice. Change that number if your repo runs slower.

Mistake 2: The laptop moved onto the box

You rsynced the whole worktree with dotfiles included. An env file and an SSH key went up. A cloud credential file went up with them.

A free server is only a disposable workspace. It is not a durable place for secrets. Shared or disposable machines keep copies you forget.

Scan secret-shaped paths before any remote file sync. Fail closed when the scan finds a hit. Do not postpone that review until after sync.

#!/usr/bin/env bash
# proposed preflight — unexecuted example
set -euo pipefail
root="${1:-.}"
pattern='(^|/)\.env($|\.)|(^|/)id_(rsa|ed25519)$|(^|/)credentials\.json$|(^|/)\.aws/credentials$'
hits="$(find "$root" -type f | grep -E "$pattern" || true)"
if [ -n "$hits" ]; then
  printf '%s\n' "$hits" >&2
  echo "refuse: secret-shaped path" >&2
  exit 2
fi
echo "preflight: no secret-shaped paths"

Run the script on the local tree first.
Pack with git archive so ignored secrets stay home.
Sync that archive, not your full working directory.
Delete the remote tree the same day you create it.

If a test truly needs a secret, stop. Do not stage a fake key just for now. That shortcut is how the second mistake returns.

Mistake 3: The model edited done

You wrote finish it and then walked away. The model changed tests to force a pass. Then it changed the checklist in the same commit.

The red run turned green for the wrong reason. A newly green run is not real acceptance. Acceptance is a checklist file you froze beforehand.

The model may read that file on the box. The model must not be able to write it. A prompt is not allowed to relax that rule.

{
  "acceptance": [
    "tests/day_budget already passes before the prompt",
    "preflight exits 0 on the archive",
    "diff touches at most 8 files",
    "no new outbound client is added",
    "receipt stores model id from the API, or null"
  ],
  "model_may_edit": false
}

Commit the acceptance file before the first prompt.
Keep it outside the writable remote worktree.
Mount it read-only if the box supports that.
Fail the job if the diff includes that path.

Do not ask the model to invent the checklist. That request quietly repeats the third mistake again. You alone should own the definition of done.

Ten-minute gate

Check	Pass condition	If it fails
Repo ownership	You can delete the remote tree	Do not start
Secret scan	Preflight exits 0	Fix paths, rescan
Token cap	Null, or cited with URL and time	Leave it null
Acceptance file	Present, outside the write set	Fix the mount
Retry cap	At most 2	Stop and read the diff
Network change	Diff adds no new client	Reject the patch

Use the table above as a start gate. Do not treat that table as a score. Six passing rows means you may start the job.

One failing row means you wait and fix it. Count the rows before you open a session. A missing row is a fail, not a skip.

Write the fail reason into the local receipt. Do not hide a failed row inside the prompt. The prompt is not the gate.

Commands in order

This command sequence is still only a proposal. Run it only in a repository you control. Do not point it at a network you do not administer.

# proposed sequence — unexecuted example
python3 - <<'PY'
import pathlib, sys
text = pathlib.Path("day_budget.yml").read_text()
if "token_cap:" not in text or "source_url:" not in text:
    sys.exit("refuse: budget fields missing")
# String check only: a filled cap with a null source is refused.
if "token_cap: null" not in text and "source_url: null" in text:
    sys.exit("refuse: token cap set without a source url")
if "owned_repo: true" not in text:
    sys.exit("refuse: owned_repo is not true")
print("budget file: shape ok")
PY
bash preflight.sh .
git archive --format=tar --prefix=job/ HEAD > /tmp/job.tar
# Copy /tmp/job.tar with your own approved channel.
# Keep acceptance.json out of the writable tree.
sha256sum acceptance.json | awk '{print $1}'

Confirm the local budget file exists before sync.
Reject a token cap that has no source URL.
Run the secret-path preflight on the local tree.
Archive only tracked files by using git archive.
Unpack on the server into an empty directory.
Run the tests you already trusted locally.
Write the receipt, then stop the remote loop.

This checker is a brittle string match, not a YAML parser. A reformatted file can fool it, so read the file too.

Keep these receipt lines on every finished run.

started_at
stopped_at
exit_code
files_changed
retries_used
model_id_or_null
budget_source_url_or_null
acceptance_sha256

If the API does not return a model id, store null. Do not guess a name to make the log look complete. A guessed model name breaks the next replay.

If the day already slipped

Stop the remote process before any fix prompt. Download the diff and the receipt, nothing else.

Compare the acceptance hash against your local frozen file. If that hash differs, discard the whole run. If secret material appears in the diff, rotate it.

Delete the remote worktree before you open a new prompt. This recovery path is not permission to continue. A burned afternoon does not justify a third retry.

Limits to say out loud

This workflow does not guarantee free capacity tomorrow. Product docs can change later the same afternoon. A null token cap is the honest state.

A stale copied integer is not an honest cap. This workflow does not make generated code safe. It only blocks the three setup mistakes above.

Review the diff yourself before you merge. This workflow is a poor fit for production credentials. It is a poor fit for customer data.

It is a poor fit for payment or medical repos. Skip it when policy requires a reviewed build system. Skip it when you cannot wipe the remote tree today.

Skip it when the repo is not yours to delete. This path preflight uses simple name-based matching only. It misses secrets pasted inside ordinary source files.

It also misses keys that were simply renamed. Pair it with a secret scanner you already trust. I am not claiming this script replaces one.

I am not claiming a speed or cost result. A free server only moves the workspace. It does not approve the patch.

At 11:22 next time

Read the live limit page before you prompt. Record the source URL and the read time. Leave every unknown budget field set to null.

Run the path scan on the local tree. Pack a git archive of tracked files only. Mount the acceptance file as read-only remote storage.

Only then should you write the model prompt. If you want both from that same option, read its current docs. Confirm the live limits there before you fill the file.

Fill the budget file from that reading, not from this letter. Pin the receipt next to the finished branch. Tomorrow-you needs the stop reason, not another slogan.

Letter to 19:40-Me: Pin the Digest, Fence the Paths

Quinn Li — Thu, 24 Sep 2026 20:29:39 +0000

You opened the free server at 19:40 and called the run done.
The model wrote a short note and named the bug fixed.
Your later CI job failed on a toolchain you never wrote down.

This letter lists the three setup mistakes that cost that day.
The scene is a reconstructed first run, not a benchmark.
No figure below is a measured product result.

The ticket was a retry helper with one failing test.
The intended edit was one source file plus its test.
The tree you merged was wider than that ticket.

A floating image tag sat under the free server session.
A missing path fence let extra files change.
A closing paragraph stood in for a saved diff stat.

Where a hosted loop fits

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

MonkeyCode provides free model access and a free server option.
Those two facts are operator-supplied claims for this draft.
This article invents no model names, quotas, hardware, or duration.

The loop still works if you delete every product name.
You need a remote shell you control and a model that edits.
The checks below are the part that decides acceptance.

Keep pin.yml, fence.json, and gate-result.json in the ticket folder.
Keep them out of the chat scroll you will not reread.
Review those files even when the model sounds finished.

Mistake 1: A floating base ate the replay

You started the box from a moving tag named latest.
A later start resolved that tag to a different digest.
The same patch then failed under a different compiler.

You had no pin file beside the ticket.
You could not prove which base produced the note.
Replay became guesswork, and the afternoon went to setup.

Write the digest before the first prompt, not after failure.
Read it from the server you actually started.
If the panel hides the digest, stop and ask.

# proposal pin file — not a captured live digest
schema: remote-pin/v1
image_ref: "example.invalid/devbox:pinned"
image_digest: "sha256:REPLACE_WITH_LIVE_DIGEST"
lockfile: "package-lock.json"
lockfile_sha256: "REPLACE_WITH_LOCK_HASH"

The YAML above is a proposal template, not a live capture.
Replace both placeholders from the server in front of you.
Leave either placeholder and the gate must fail closed.

A matching digest proves identity for that start only.
It does not prove the free server will exist next week.
Treat permanence as unknown unless current docs say otherwise.

Mistake 2: An open tree looked clean

You asked the model to fix the retry bug and tidy comments.
The diff touched the helper, the test, a config, and the lockfile.
Clear scope was lost inside a clean-looking patch.

Comments were never the failing assertion in the test.
Unrelated edits were the defect that burned the review.
A tidy style pass is not a ticket boundary.

Write the path fence before the model is allowed to write.
Put only the ticket files into the allowlist for this run.
Deny lockfiles, build output, and dotenv files by default.

{
  "ticket": "T-184",
  "allow": ["src/retry.ts", "test/retry.test.ts"],
  "deny_globs": ["**/*.lock", "**/dist/**", "**/.env*"]
}

That JSON is proposal data for one imaginary ticket.
Swap the paths for the files your test actually imports.
Do not add cleanup paths because the model suggested them.

Mistake 3: Prose replaced the stat file

The closing note said the tests passed on the free server.
You never saved the exit code next to the ticket.
You never saved git diff stat output either.

A confident paragraph can describe a run that did not happen.
A stat file cannot invent paths the tree does not have.
Accept the run only when names match the allowlist.

Keep the chat for context, not for acceptance.
Store the command output beside the ticket id.
Read that file before you read the model's last line.

How the three mistakes stacked

The floating base made the second run unequal to the first.
The open tree made that unequal run also unreviewable.
The missing stat made both problems look like a model miss.

You spent the day swapping prompts instead of files.
The base image and the path fence were the real variables.
Prompt edits cannot pin a digest you never stored.

Fence check you can copy

The script below is unexecuted proposal code for a local check.
It does not call a network and it does not start a server.
Run it only inside a repo you are allowed to modify.

// proposal: unexecuted fence check. Not a recorded live run.
import { readFileSync, writeFileSync } from "node:fs";
import { execFileSync } from "node:child_process";

const fence = JSON.parse(readFileSync("fence.json", "utf8"));
const pin = readFileSync("pin.yml", "utf8");

if (!pin.includes("sha256:")) {
  throw new Error("pin.yml has no digest line");
}
if (pin.includes("REPLACE_WITH")) {
  throw new Error("pin.yml still has placeholders");
}

const names = execFileSync("git", ["diff", "--name-only"], {
  encoding: "utf8",
})
  .trim()
  .split("\n")
  .filter(Boolean);

const outside = names.filter((name) => !fence.allow.includes(name));
if (outside.length > 0) {
  throw new Error("diff left the allowlist");
}

const stat = execFileSync("git", ["diff", "--stat", "--", ...fence.allow], {
  encoding: "utf8",
});

const result = {
  ticket: fence.ticket,
  names,
  stat,
  accepted: true,
};
writeFileSync("gate-result.json", JSON.stringify(result, null, 2));

The script reads pin.yml and fence.json from the working directory.
It throws if the pin still contains placeholder text.
It throws if any changed path sits outside the allowlist.

It writes gate-result.json with the names and the stat text.
A thrown error means you reset the tree before another prompt.
A written file means the write set matched the fence.

The proposal script checks exact allowlist names only.
Deny globs in the JSON stay a human checklist for now.
Add real glob matching before you trust that deny list.

This check reads the worktree diff, not a pushed commit.
Commit the fenced paths only after gate-result.json exists.
A pushed branch can still hide an earlier extra file.

Tests stay outside this gate for a reason you can audit.
You still run the fenced test command yourself and record it.
You still append that exit code to the result file.

Eight steps for the first hour

Do these steps in order on a server you may use.
Stop at the first missing file instead of prompting anyway.
Do not skip ahead because the closing note sounds complete.

Start the free server and copy its image digest into pin.yml.
Hash the lockfile you intend to keep and store that hash.
Write fence.json with ticket paths only, plus deny globs.
Note the server hostname beside the digest in the same pin file.
Prompt with the fence text, not with a repo-wide cleanup ask.
Apply the patch on the server, then run the fence check.
Re-run only the fenced tests and append their exit codes.
Accept only when names, digest, and exits all match the files.

How to read the signals

Use this table before you trust a closing note.
Each row is a rule, not a measured score.
None of these rows is a benchmark against another tool.

Signal in hand	What it proves	Next action
Closing note says fixed	A sentence was produced	Do not accept
Names match allowlist	Write set matches ticket	Run fenced tests
A path sits outside	Scope leaked	Reset that tree
Live digest matches pin	Base identity matches	Keep the result file
Digest missing	Replay is blocked	Do not prompt yet
Exit code file exists	A command finished	Attach it to ticket
Lock hash changed	Dependencies moved	Open a new ticket

Read the first column as input, not as proof.
Read the middle column as the limit of that input.
Read the last column as the only allowed next move.

Commands that build the result file

These commands are a proposal, not a log from a live box.
Run them on a server you are allowed to use.
Point them at the ticket directory, not at your home folder.

git rev-parse HEAD > ticket/head.txt
git diff --name-only > ticket/names.txt
git diff --stat > ticket/stat.txt

Use sha256sum only if that server image includes it.
Otherwise call the checksum tool already installed there.
Append the hash to pin.yml before you prompt.

Compare names.txt with fence.json before you open the chat.
If the lists differ, the summary is already late.
Fix the tree, then ask for a narrower note.

Limits you should say out loud

A pinned digest does not promise capacity on the free server.
Free model access does not name a quota in this article.
Hardware, duration, and uptime are unknown here on purpose.

A green fenced test does not prove CI uses your digest.
A path fence does not prove the allowed edit is correct.
You still need a test that fails for the original bug.

Hosted models can retain prompt text under their own policy.
Do not paste secrets, tokens, or private customer data.
A free server is still a remote machine you do not own.

Treat that shell as shared with the host operator.
Read the current docs before you plan a long job.
This draft does not claim the free option is permanent.

Who should not start here

Skip this loop for a local typo you can edit by hand.
Skip it when the server will not show an image digest.
Skip it when you cannot name an allowlist you will defend.

Skip it when policy forbids sending repository text to a host.
Skip it when the ticket needs production credentials in the shell.
Those cases need a different control, not a longer prompt.

After the letter

Tomorrow, pin the digest before you type the first prompt.
Write the fence before you ask for a fix.
Save the stat file even when the note sounds certain.

A free model and a free server can host that hour.
The three files still decide whether the hour counts.
That is the only next step this letter asks for.

Letter to 14:07-Me: Replay the Tool Trace, Not the Chat

Quinn Li — Wed, 23 Sep 2026 16:46:15 +0000

Dear 14:07-Me,

You will waste a day on one agent loop.
The chat log will look complete and polite.
The remote tools will not match that story.

This letter is a postmortem template.
It is not a victory lap.
Treat every command below as a labeled example.

The scene you walk into

A ticket asks for a small API helper.
You paste the spec into a coding agent.
You let it call tools against a shared box.

By 18:00 the helper still flakes.
You reread the chat instead of the wire.
That is the first expensive habit.

Tool calling is not a conversation.
It is HTTP with a model in the middle.
If the envelope is missing, the day is gone.

The three mistakes that cost the day

Mistake 1: The tool schema kept moving

You edited the function description mid-loop.
The model then called a field you had renamed.
Retries looked like model noise. They were schema drift.

A renamed property is not a smarter prompt.
It is a broken contract with yesterday's calls.
Hash the schema, or you will debug ghosts.

Mistake 2: Mutations had no idempotency key

The agent posted the same resource twice.
Your debug run became production-shaped side effects.
You spent hours cleaning duplicate rows, not prompts.

A second POST is not extra evidence.
It is a second write with a new identity.
Without a key, replay is vandalism.

Mistake 3: You debugged prose, not envelopes

The model summarized a 200 as success.
The body failed your contract on id.
Chat text cannot replay. A JSONL file can.

English is a lossy codec for tool I/O.
Status, hash, and body survive. Summaries do not.
Close the thread until the file checks out.

What this letter will give you

A pinned schema file.
A one-line tool envelope.
A replay command that needs no model.

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

I mention MonkeyCode only as the remote runner.
The project is open source.
Operator notes list free model access and a free server option.
Those notes do not define quotas, hardware, or uptime.
Remove the product name. The method still holds.

Pin the schema before any loop

Do this on your laptop.
Do not start the agent yet.

Write the tool list to tools.schema.json.
Hash the file. Store the hash in the ticket.
Refuse any run whose hash does not match.

Example schema, labeled as a sample, not a live API:

{
  "name": "create_report",
  "method": "POST",
  "path": "/v1/reports",
  "required": ["title", "idempotency_key"],
  "properties": {
    "title": { "type": "string", "minLength": 1, "maxLength": 120 },
    "idempotency_key": { "type": "string", "pattern": "^[a-f0-9-]{36}$" }
  }
}

Check the hash with a boring command.

sha256sum tools.schema.json > tools.schema.sha256
cat tools.schema.sha256

If the agent rewrites the schema, the hash breaks.
You stop. You do not "just retry".
Mid-loop schema edits are how 14:07 becomes 18:00.

Keep a second copy outside the agent workspace.
Agents rewrite nearby files when stuck.
Your source of truth should not sit in that blast radius.

Wrap every tool call in one envelope

Chat is not a protocol.
Your envelope is.

Example envelope for one mutating call:

{
  "ts": "2026-09-23T14:07:00Z",
  "schema_sha256": "REPLACE_WITH_HASH",
  "tool": "create_report",
  "idempotency_key": "11111111-1111-4111-8111-111111111111",
  "request": { "title": "daily-trace" },
  "response": {
    "status": 201,
    "body": { "id": "rpt_01" }
  }
}

Rules you will keep:

One envelope per tool call. No bundles.
Mutating tools always send idempotency_key.
Responses store raw status and raw body.
Append-only JSONL. Never edit a past line.

Name the file trace.jsonl.
One object per line. No pretty-print across lines.
Pretty JSON is for humans. JSONL is for replay.

Redact secrets before the line is written.
Authorization headers do not belong in traces.
If a token appears, delete the file and rotate it.

Numbered workflow for the next run

Follow these steps in order.
Skip none of them.

Freeze tools.schema.json and print its hash.
Copy the schema hash into the ticket comment.
Create an empty trace.jsonl on the remote box.
Start the agent only after both files exist.
Reject any tool call missing the envelope fields.
Replay the JSONL with a local checker.
Open the chat only if the replay fails.

Proposed checker (unexecuted sample):

# replay_trace.py — sample harness, not production code
import json, sys, hashlib, pathlib

REQUIRED = ("ts", "schema_sha256", "tool", "idempotency_key", "request", "response")

def load_schema_hash(path):
    data = pathlib.Path(path).read_bytes()
    return hashlib.sha256(data).hexdigest()

def main(trace_path, schema_path):
    expected = load_schema_hash(schema_path)
    seen_keys = set()
    errors = []
    with open(trace_path) as fh:
        for i, line in enumerate(fh, 1):
            line = line.strip()
            if not line:
                continue
            row = json.loads(line)
            missing = [k for k in REQUIRED if k not in row]
            if missing:
                errors.append(f"line {i}: missing {missing}")
                continue
            if row["schema_sha256"] != expected:
                errors.append(f"line {i}: schema hash drift")
            key = (row["tool"], row["idempotency_key"])
            if key in seen_keys:
                errors.append(f"line {i}: duplicate idempotency key")
            seen_keys.add(key)
            status = row["response"].get("status")
            if not isinstance(status, int):
                errors.append(f"line {i}: status is not an int")
            body = row["response"].get("body") or {}
            if row["tool"].startswith("create") and status not in (200, 201):
                errors.append(f"line {i}: unexpected status {status}")
            if row["tool"].startswith("create") and status in (200, 201):
                if not isinstance(body.get("id"), str) or not body["id"]:
                    errors.append(f"line {i}: create returned no id")
    if errors:
        print("\n".join(errors))
        sys.exit(1)
    print(f"ok {len(seen_keys)} unique calls")

if __name__ == "__main__":
    main(sys.argv[1], sys.argv[2])

Run it like this:

python replay_trace.py trace.jsonl tools.schema.json

If this exits non-zero, do not prompt again.
Fix the envelope. Then rerun the checker.
The model cannot patch a missing id field with nicer prose.

Add a hard stop around the loop itself.
A shell wrapper is enough for a lab box.

# labeled example: stop after 20 envelopes
if [ "$(wc -l < trace.jsonl)" -ge 20 ]; then
  echo "trace cap hit" >&2
  exit 2
fi

Twenty lines is arbitrary on purpose.
Pick a cap before the agent starts.
Do not negotiate the cap with the model.

Decision table for the afternoon

Signal	You assumed	Check instead	Next action
Chat says "created"	Resource exists	`status` plus body `id`	Replay JSONL
Second retry "fails"	Model is flaky	Duplicate `idempotency_key`	Inspect store, not prompt
Field missing in body	Prompt too weak	Schema hash changed	Restore `tools.schema.json`
429 from the API	Need a bigger model	Loop has no backoff cap	Stop the loop
Free server feels slow	Hardware is the bug	Trace has N identical POSTs	Deduplicate keys
201 with empty `id`	Serializer bug later	Envelope body is already wrong	Fail replay, do not continue

Read the table before you change the prompt.
Most of those rows are I/O bugs.
Prompt edits do not restore a hash or a key.

Reconstruct the burned day in order

Here is the same afternoon as a timeline.
Use it when you start to reread the chat.

14:07 — schema file is still a draft in the prompt.
14:31 — first POST succeeds. No envelope is written.
15:10 — you rename title to name in the tool text.
15:44 — retries hit the old field. Errors look random.
16:20 — you rerun the same create. Duplicates appear.
17:35 — the model says the resource exists. The id does not.
18:02 — you still have no JSONL. The day is spent.

Each hour had a cheaper check.
None of those checks required a larger model.
They required a file the agent could not narrate away.

How the free server fits, without magic

A coding agent on your laptop mixes two risks.
Tool side effects. Untrusted generated commands.

A separate free server keeps the laptop quieter.
It does not make the trace optional.
It does not make the schema frozen.

Copy only the schema, the checker, and the empty trace.
Do not copy your laptop credentials.
Do not mount your home directory into that box.

# labeled example: ship the protocol, not your machine
scp tools.schema.json replay_trace.py box:~/run/
ssh box 'touch ~/run/trace.jsonl && wc -l ~/run/trace.jsonl'

If you try MonkeyCode's free models on that server, keep the same envelope.
Same hash. Same JSONL. Same replay.
The vendor is not the protocol.

Do not paste secrets into the prompt or the trace.
Redact tokens before you copy files off the box.
A free server is still a shared disk with logs.

Limitations

This method does not prove business correctness.
A 201 can still store a wrong title.
Replay only proves the envelope was consistent.

JSONL is not an audit system.
Anyone with disk access can rewrite it.
Sign the file if you need a stronger claim.

# labeled example: detach a copy you can compare later
cp trace.jsonl "trace-$(date -u +%Y%m%dT%H%M%SZ).jsonl"
sha256sum trace-*.jsonl

Free model access can change without notice.
A free server is not a compliance boundary.
Do not put regulated data on it.

Idempotency keys need server support.
If the API ignores the key, duplicates remain.
Test that path with two identical envelopes.

The checker above does not call the live API.
It only reads what you recorded.
A silent tool that never writes JSONL will look like success.

Clock stamps in the envelope are metadata.
They do not freeze remote state.
Do not treat ts as proof the resource still exists.

Who should not use this approach

Skip this if you cannot write a schema file.
Skip this if the API has no replayable HTTP surface.
Skip this for production incident response under a clock.

Do not use a shared free server for customer PII.
Do not use it as your only backup.
Do not treat chat summaries as proof.

Skip this if your tools are purely local side-effect storms.
File deletes and package publishes need stronger isolation.
An envelope does not replace a sandbox.

Skip this if nobody will read trace.jsonl on failure.
Unused protocol files become another prompt toy.
The checker only works if you stop when it fails.

Close the letter

14:07-Me, stop rereading the dialogue.
Hash the schema. Append the envelope. Replay the file.
That sequence is the whole day, recovered.

If you later try the free server path, take the checker with you.
Leave the chat closed until replay_trace.py prints ok.

Letter to 08:12-Me: Dry-Run Tools Before the Remote Box

Quinn Li — Tue, 22 Sep 2026 14:59:11 +0000

Dear 08:12-Me,

The ticket looked small on paper this morning. It described a tool-calling loop on one box. You blocked ninety minutes on the calendar anyway.

Nine hours later the model was still the suspect. The mixed logs told a different story tonight. This letter reconstructs that day from those logs.

Treat it as a reconstructed field note, not memoir. No live customer data appears in the examples. No latency numbers are claimed in this writeup.

The scene you ignored

Two editors were open at 08:12 sharp. One sat on the laptop home directory. The other sat on a remote shell.

You pasted one prompt into both sessions. The first tool call missed a file path. The second tool call missed the JSON shape.

You blamed model drift for both failures. That diagnosis delayed the real fix by hours. The harness was wrong before any token moved.

Mistake 1: Two hosts were treated as one disk

The laptop worktree lived under the ticket-441 directory. The remote box used a runner work path. Your prompt still named a relative tools script.

Only one host actually contained that script. You compared outputs as if cwd values matched. They did not match after the first retry.

The error was ENOENT after nine attempts. The model never received a reachable tool path. Path drift is not a reasoning defect.

Fix 1: Pin a host record first

Pin a host record before the first prompt. Skip this step and the rest will drift.

Write a HOST.json file on the chosen box.
Refuse the run when that file is missing.
Keep laptop logs in a separate directory tree.

#!/usr/bin/env bash
set -euo pipefail
# Example harness. Label: unexecuted until you run it.

host_id="$(hostname -s)-$(uname -m)"
work_dir="${WORK_DIR:-$PWD/ticket-441}"
mkdir -p "$work_dir/receipts" "$work_dir/logs" "$work_dir/laptop-logs"

cat > "$work_dir/HOST.json" <<EOF
{
  "host_id": "$host_id",
  "work_dir": "$work_dir",
  "cwd": "$PWD",
  "user": "$(id -un)",
  "started_at_utc": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
}
EOF

test -f "$work_dir/HOST.json"
chmod 600 "$work_dir/HOST.json"
echo "host pinned: $host_id"

Copy the worktree only after the pin exists. Do not prompt across two different cwd values. The prompt must name paths from HOST.json alone.

Mistake 2: Model calls ran before a schema stub

The agent was meant to call one tool. The contract required city plus metric-or-imperial units. The model returned a location key instead.

You retried the same prompt for two hours. Each retry hit a free model access path. The schema never ran against a local stub.

Treat invalid JSON as a harness defect first. Prove the stub red before you attach models. Tool-calling essays do not replace that red bar.

Fix 2: Fail the stub on the pinned host

Save the tool schema beside the ticket files. Post a fixture payload to a local stub. Reject unknown keys and missing required fields.

Attach model access only after the stub stays green. Run every command on the pinned host only.

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "weather_query",
  "type": "object",
  "additionalProperties": false,
  "required": ["city", "units"],
  "properties": {
    "city": { "type": "string", "minLength": 1 },
    "units": { "enum": ["metric", "imperial"] }
  }
}

#!/usr/bin/env python3
"""Schema dry-run. Example only until you execute it."""
from __future__ import annotations

import json
import sys
from pathlib import Path

try:
    import jsonschema
except ImportError:
    sys.stderr.write("pip install jsonschema\n")
    sys.exit(2)

schema = json.loads(Path("tool_schema.json").read_text())
payload = json.loads(sys.stdin.read() or "{}")
jsonschema.validate(instance=payload, schema=schema)
print("schema_ok")

# Bad fixture must fail. Good fixture must pass.
echo '{"location":"Berlin"}' | python3 dry_run_schema.py; echo exit:$?
echo '{"city":"Berlin","units":"metric"}' | python3 dry_run_schema.py

You needed that red bar at 08:20. You finally saw it at 16:40 instead. The morning retries were schema work in disguise.

Mistake 3: Two hosts wrote one shared log

Laptop traces and remote traces shared one agent.log file. Timestamps overlapped and lacked a host identifier field. You could not replay the failure from disk.

A merged log is not evidence of anything. It is noise with extra newlines and guesses. Split the files before the next prompt lands.

Fix 3: Stamp a receipt after every run

Stamp one receipt after every completed run. Keep one receipt per host per run.

#!/usr/bin/env python3
"""Write a run receipt. Example workflow, not a benchmark."""
from __future__ import annotations

import hashlib
import json
import os
from datetime import datetime, timezone
from pathlib import Path

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

work = Path(os.environ["WORK_DIR"])
host = json.loads((work / "HOST.json").read_text())
schema = work / "tool_schema.json"
prompt = work / "prompt.txt"

receipt = {
    "host_id": host["host_id"],
    "work_dir": host["work_dir"],
    "schema_sha256": sha256_file(schema),
    "prompt_sha256": sha256_file(prompt),
    "model_attached": os.environ.get("MODEL_ATTACHED", "false"),
    "stub_passed": os.environ.get("STUB_PASSED", "false"),
    "recorded_at_utc": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
}
stamp = receipt["recorded_at_utc"].replace(":", "")
out = work / "receipts" / f"{host['host_id']}-{stamp}.json"
out.write_text(json.dumps(receipt, indent=2) + "\n")
print(out)

Keep MODEL_ATTACHED false during the stub phase. Flip it only after the schema test passes. Refuse any receipt that omits schema_sha256.

What belongs in prompt.txt

Write the prompt as a contract, not a vibe. Name the tool, the schema, and the host path. Leave laptop nicknames out of the text.

HOST_ID: read from HOST.json only.
TOOL: weather_query
INPUT: JSON object matching tool_schema.json
OUTPUT: JSON object, no markdown fences
FORBIDDEN: extra keys, extra files, extra hosts

Hash that file in the receipt every time. If the hash changes, start the stub again. Do not reuse yesterday's passing receipt blindly.

The start sequence for the next queue

Use this order under calendar pressure too. Do not reorder steps to save minutes.

Pin HOST.json on exactly one chosen box.
Sync the worktree to that box only.
Drop a fixture that must fail schema checks.
Make the stub reject extra JSON keys.
Record a receipt with MODEL_ATTACHED set false.
Attach free model access on that same host.
Keep laptop logs out of the remote file.

The remote box can be a free server option. The model path can be free model access. Neither feature repairs a missing tool contract.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode fits this sequence as the pinned remote host. The operator notes free model access and a free server option.

This article does not claim quotas or model names. It does not claim hardware, duration, or benchmarks. If you need that stub-then-model pairing, park the host there.

Decision table

Print this table beside the ticket contract. Check every row before the first model call.

Signal on the box	Action	Attach model?
No HOST.json	Stop the run	No
Schema fixture still passes when it should fail	Fix the stub	No
Extra keys accepted by the stub	Tighten additionalProperties	No
Laptop cwd referenced in the prompt	Rewrite paths from HOST.json	No
Receipt missing schema_sha256	Rewrite the receipt writer	No
Laptop lines inside remote agent.log	Split the log directories	No
Stub green, host pinned, logs split	Continue the ticket	Yes

A single No in that table blocks the model. Do not negotiate with the table at 08:12.

Why a stub still beats another explainer

Tool-calling writeups circulated again across developer feeds. They show how a model selects a function name. They do not show your host layout or schema.

A browser demo is not your remote cwd. A voice stack is not your JSON contract. Your failing fixture is the only local authority.

Keep public posts as untrusted topic signals. Do not paste their wording into prompt.txt. Your receipt should hash your files, not theirs.

What this method does not do

This method does not make model output deterministic. It does not prove safety for production traffic. It does not replace a human code review.

It also does not measure latency or token cost. Those figures are absent from the receipt on purpose. Do not invent numbers to fill empty fields.

Skip this workflow when you are not calling tools. Skip it when one local unit test is enough. Skip it when no JSON schema can describe the call.

Do not use a shared log as your audit trail. Do not point a remote agent at laptop home. Do not skip the stub because capacity is free.

A compact replay drill

When a run looks cursed, replay in this order. Stop early if the stub never fails.

Print HOST.json and confirm a single host_id value.
Hash tool_schema.json and prompt.txt on that host.
Replay the failing fixture through dry_run_schema.py.
Re-attach the model only on that same host.

#!/usr/bin/env bash
set -euo pipefail
# Replay drill. Example commands, not a recorded incident.

: "${WORK_DIR:?set WORK_DIR to the pinned worktree}"
test -f "$WORK_DIR/HOST.json"
python3 - "$WORK_DIR/HOST.json" <<'PY'
import json, sys
host = json.loads(open(sys.argv[1], encoding="utf-8").read())
print(host["host_id"])
print(host["work_dir"])
PY

sha256sum "$WORK_DIR/tool_schema.json" "$WORK_DIR/prompt.txt"
echo '{"location":"Berlin"}' | python3 dry_run_schema.py || true
echo '{"city":"Berlin","units":"metric"}' | python3 dry_run_schema.py

If step three never fails on the bad fixture, stop. The model is not the next debug target then. Fix the stub until the bad payload is rejected.

Closing note to 08:12-Me

You did not lose the day to model noise. You lost it to two hosts and no schema. Start with the pin, then fail the stub.

Then attach the model on the same host. Keep this letter next to HOST.json tomorrow. The queue can wait for that file.

Letter to Thursday-Me: Park the Agent on a Cheap Box

Quinn Li — Mon, 21 Sep 2026 13:11:07 +0000

Thursday morning the ticket looked small on the board. I typed a long prompt against my dirty laptop tree. The clock kept running while the agent wandered files.

This letter is for that vanished Thursday morning. Read it before you send the first agent prompt.

The day that vanished

Three mistakes burned the hours without a useful patch. None of them came from model quality or speed.

They came from the runtime and the filesystem boundary. I list them as a checklist for the next run.

Mistake 1: The dirty laptop became the runtime

The branch mixed notes, secrets, and half-written tests. The agent saw every untracked file in that tree.

It edited the wrong helper and called the suite green. The remote ticket still failed after I pushed the patch.

Mistake 2: The remote box inherited your home

I later moved the run onto a borrowed host. The copy step followed caches, dotfiles, and local secrets.

The free box then behaved like the laptop again. Isolation was a directory name, not a real boundary.

Mistake 3: No replay after the rewrite

The agent returned a patch that passed once locally. I had no command log from the remote box.

A second run drifted from the first silent path. The day ended without a receipt I could replay.

What changes on the next Thursday

Park the agent on a cheap isolated box. Send a ticket bundle and nothing else.

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

MonkeyCode currently offers free model access on demand. It also offers a free server option for isolated runs.

Those two options cover a throwaway runtime for this loop. The same steps work on any SSH host you control.

Remove every product name from the steps below. The gates still hold without a vendor in view.

Artifact: ticket bundle plus replay gate

The artifact is a small shell workflow you can copy. Treat every snippet below as a labeled proposal.

I am not publishing timings from your hardware. Replace hostnames and paths before you run anything.

Step 1: Freeze a clean worktree

Do not prompt from a dirty checkout. Make a linked worktree for this ticket only.

# proposal: isolate one ticket from the dirty checkout
TICKET="THU-441"
git fetch origin
git worktree add -b "agent/${TICKET}" "../wt-${TICKET}" origin/main
cd "../wt-${TICKET}"
git status --porcelain

Empty porcelain output is the only green light. Any leftover path stops the run before a prompt.

Step 2: Write the contract before the prompt

The contract is the prompt for the remote agent. Chat text is not a substitute for this file.

# proposal: one screen contract, no hidden scope
cat > CONTRACT.md <<'EOF'
Goal: make GET /health return 200 with {"ok":true}
Allowed paths: app/health.py tests/test_health.py
Forbidden: .env, *.pem, docker-compose.override.yml
Done when: pytest -q tests/test_health.py exits 0
EOF

Pin allowed paths in that contract file. The agent does not get a tour of the repo.

Step 3: Pack a sendable bundle

Send code, tests, and the contract file. Send no caches, secrets, or editor debris.

# proposal: pack only what the remote may read
mkdir -p /tmp/bundle-${TICKET}

rsync -a --delete \
  --exclude '.git' \
  --exclude '.env' \
  --exclude '*.pem' \
  --exclude 'node_modules' \
  --exclude '.venv' \
  --exclude '__pycache__' \
  ./ /tmp/bundle-${TICKET}/src/

cp CONTRACT.md /tmp/bundle-${TICKET}/
find /tmp/bundle-${TICKET} -type f | sort

Read the find output one time before upload. A surprise path means the exclude list is wrong.

Step 4: Prove the packed test is still red

Run the failing test before any model call. Use the bundle, not the dirty laptop tree.

# proposal: tests/test_health.py in the bundle
# unexecuted example; wire it to your app
def test_health_ok(client):
    response = client.get("/health")
    assert response.status_code == 200
    assert response.json() == {"ok": True}

# proposal: prove the ticket is still red
cd /tmp/bundle-${TICKET}/src
python -m pytest -q tests/test_health.py
echo "pytest_exit:$?"

Red is required before the remote model call. Green at this step means you packed the wrong tree.

Step 5: Copy the bundle onto the disposable host

Use a ticket-scoped directory on that host. Do not mount your home directory into the run.

# proposal: remote path is ticket-scoped and disposable
HOST="free-box.example"
REMOTE="/var/runs/${TICKET}"

ssh "$HOST" "mkdir -p '$REMOTE' && chmod 700 '$REMOTE'"
rsync -a --delete /tmp/bundle-${TICKET}/ "$HOST:$REMOTE/"
ssh "$HOST" "find '$REMOTE' -type f | sort"

If you lack a host, borrow any disposable SSH box. Keep this layout even when the hostname changes.

Step 6: Run the agent only inside that path

Cap the working directory around the packed bundle. Write a receipt before you pull any patch.

# proposal: remote run with a hard receipt
ssh "$HOST" bash -s <<EOF
set -euo pipefail
cd "$REMOTE"
{
  echo "start: \$(date -u +%FT%TZ)"
  echo "cwd: \$(pwd)"
  echo "tree:"
  find . -type f | sort
  echo "contract:"
  cat CONTRACT.md
} > RECEIPT.txt

# invoke your coding agent here with cwd=$REMOTE
# pin the model endpoint you already trust
# do not grant tools that can leave $REMOTE

{
  echo "end: \$(date -u +%FT%TZ)"
  echo "pytest:"
  pytest -q src/tests/test_health.py || true
} >> RECEIPT.txt
EOF

I am not naming a model in this letter. A single pinned endpoint is enough for the loop.

Fancy routing is not required for a health ticket. The receipt matters more than the brand of model.

Step 7: Pull the receipt and replay locally

Do not merge from memory or chat history. Replay the recorded test on the returned tree.

# proposal: local replay must match the receipt
rsync -a "$HOST:$REMOTE/RECEIPT.txt" ./RECEIPT.txt
rsync -a "$HOST:$REMOTE/src/" ./replay-src/

python -m pytest -q replay-src/tests/test_health.py
echo "replay_exit:$?"

grep -F "Allowed paths:" RECEIPT.txt
grep -F "Forbidden:" RECEIPT.txt

Mismatch means the remote drifted from the contract. Drop the patch and keep the ticket red.

How to read the receipt

A valid receipt has four blocks in order. Missing one block means the run is invalid.

UTC start and end timestamps must both exist. The cwd line must equal the ticket remote path.

The tree listing must match the packed bundle. A home path in that listing kills the run.

The contract block must match CONTRACT.md byte for byte. Pytest output must show the same tests you packed.

Store RECEIPT.txt next to the merged patch. Future you will need that file during review.

Decision table

Use this table beside the terminal during the run.

Print the table once and keep it visible. It beats another round of prompt edits.

Why the cheap box is the point

Laptop runs mix secrets, caches, and open tickets. Agents follow that mix because the files are visible.

A disposable server cuts the mix at copy time. A remote-only rule cuts the urge to try locally first.

The point is not a cost story for its own sake. The point is a bounded filesystem and a replayable log.

Limitations

This workflow assumes SSH and a Unix shell. It also assumes a pytest-style failing test.

It does not harden a hostile shared tenant. It does not replace review or secret scanning.

It does not prove model quality on a benchmark. It only proves that you can replay the same command.

Skip this approach in the four cases below.

You still lack a failing test for the ticket.
Policy forbids source on a third-party runtime.
The work needs laptop hardware or a local GUI.
Secrets cannot be excluded from the packed tree.

If policy blocks a vendor box, use your own host. Keep the same gates and the same receipt file.

Thursday checklist

Create a clean worktree for the ticket.
Write CONTRACT.md before any agent prompt.
Pack a bundle with a strict exclude list.
Confirm the packed test is still red.
Copy the bundle to a disposable host.
Run the agent inside that path only.
Pull RECEIPT.txt and replay the test.

Seven steps sit between you and another lost day. The receipt is the work, so keep it.

If you park a run on a free remote, keep RECEIPT.txt.

Letter to Sunday-Me: Pack a Worktree, Cap the Retries

Quinn Li — Sun, 20 Sep 2026 11:19:37 +0000

Sunday-me, you burned a full day on a free run.
The remote box sat idle while you pasted prompts.
You still lost the afternoon to an unbounded loop.

This letter is the checklist I needed at 09:12.
It is a workflow, not a pep talk.
Read it once. Then pack a smaller tree.

The scene at 09:12

You cloned the whole monorepo onto the laptop.
You pasted the ticket into an empty chat.
No contract. No failing test. No packed worktree.

The first patch touched twelve unrelated files.
One change deleted a fixture the suite needed.
You spent three hours bisecting your own prompt.

Free model access did not freeze the scope.
A free server did not cap retries for you.
Both only move the loop off your laptop.

Where a free remote box actually helps

A later option is MonkeyCode for that loop.
It offers free model access and a free server option.
Disclosure: This article was prepared as part of MonkeyCode's product outreach.

The method below still works without that box.
Keep secrets off any shared machine.
Treat every remote patch as untrusted output.

The three mistakes that cost the day

These are not vibe problems. They are process bugs.
Each one turned a small ticket into a lost Sunday.
Name them before you open the chat window.

Mistake 1: You shipped the whole repo

The agent scanned paths it did not need.
It "fixed" a helper two packages away.
Your diff became a novel. Review died.

Mistake 2: You treated retries as free

The first test failure was a real assertion.
The next fourteen failures were the same line.
You paid with hours, not with a token meter.

Mistake 3: You applied before a local replay

The remote log looked green in the browser.
Your laptop used a different runtime and clock.
The merge broke CI at 16:40. Nobody was shocked.

Artifact: pack, cap, then replay

The artifact is three small files plus a table.
They are a proposed harness, not a live run log.
Copy them onto a throwaway branch and try them.

File 1: `ticket.contract.json`

One ticket gets one contract. Nothing else.
List files. List bans. Set a hard retry cap.
Do this before any model sees the ticket.

{
  "ticket": "PAY-4412",
  "goal": "Reject empty currency codes in the quote parser.",
  "in_scope": [
    "src/quote/parse.js",
    "test/quote/parse.test.js"
  ],
  "out_of_scope": ["src/quote/legacy.js", "packages/*"],
  "failing_test": "test/quote/parse.test.js",
  "max_retries": 3,
  "max_files_touched": 4,
  "forbidden": ["rm -rf", "curl", "ssh", "npm publish"],
  "receipt_path": "receipts/PAY-4412.json"
}

The prompt should point at this file only.
Do not paste extra narrative into the runner.
Scope lives in JSON, not in chat memory.

File 2: `scripts/pack-worktree.sh`

This script copies in-scope paths and the contract.
The remote box never sees the rest of the tree.
That packing step is the whole point.

#!/usr/bin/env bash
set -euo pipefail
TICKET="${1:?ticket id}"
DEST=".packed/${TICKET}"

python3 - <<'PY'
import json
from pathlib import Path
c = json.loads(Path("ticket.contract.json").read_text())
Path(".packed-files.txt").write_text("\n".join(c["in_scope"]) + "\n")
PY

rm -rf "${DEST}"
mkdir -p "${DEST}"
rsync -a --files-from=.packed-files.txt ./ "${DEST}/"
cp ticket.contract.json "${DEST}/ticket.contract.json"
echo "packed ${DEST}"

Ship a tarball. Do not ship .env files.
Do not ship node_modules. Do not ship keys.
If the archive grows past a few megabytes, stop.

chmod +x scripts/pack-worktree.sh
./scripts/pack-worktree.sh PAY-4412
tar -C .packed -czf PAY-4412.tgz PAY-4412
ls -lh PAY-4412.tgz

File 3: `scripts/validate-receipt.py`

A green remote log is not a merge decision.
Gate the receipt JSON before any local apply.
Reject means you rewrite the contract or stop.

#!/usr/bin/env python3
import json, sys, pathlib

contract = json.loads(pathlib.Path("ticket.contract.json").read_text())
receipt = json.loads(pathlib.Path(sys.argv[1]).read_text())

errors = []
if receipt.get("retries", 99) > contract["max_retries"]:
    errors.append("retries exceeded")
files = receipt.get("files_touched", [])
if len(files) > contract["max_files_touched"]:
    errors.append("too many files")
for path in files:
    if path not in contract["in_scope"]:
        errors.append(f"out of scope: {path}")
for cmd in receipt.get("commands", []):
    for bad in contract["forbidden"]:
        if bad in cmd:
            errors.append(f"forbidden: {cmd}")
if "diff_sha256" not in receipt:
    errors.append("missing diff_sha256")

if errors:
    print("REJECT")
    print("\n".join(errors))
    sys.exit(1)
print("ACCEPT")

Proposed receipt shape, for the same ticket:

{
  "ticket": "PAY-4412",
  "retries": 2,
  "files_touched": [
    "src/quote/parse.js",
    "test/quote/parse.test.js"
  ],
  "commands": [
    "npm test -- test/quote/parse.test.js"
  ],
  "diff_sha256": "replace-with-real-hash"
}

Numbered workflow

Work top to bottom. Do not skip packing.
Do not raise max_retries mid-run.
Stop at the first honest red cell.

1. Write the failing test first

Do not open the chat window yet.
Add one assertion that fails on current HEAD.
Commit that test on a branch named for the ticket.

git checkout -b PAY-4412
# add the failing assertion, then:
git add test/quote/parse.test.js
git commit -m "test(PAY-4412): reject empty currency codes"
npm test -- test/quote/parse.test.js

The test must fail for the right reason.
If it fails on setup, stop. Fix the harness.
A red test with a wrong cause wastes the box.

2. Freeze the contract

Fill ticket.contract.json before any prompt.
Name every in-scope file. Name the bans.
Set max_retries to three. Three is a budget.

3. Pack the worktree

Run the pack script. Inspect the archive list.
If a lockfile or secret slipped in, delete it.
Only then upload the tarball to the remote box.

tar -tzf PAY-4412.tgz

4. Run with a capped prompt template

Upload only the archive. Point at the contract.
Tell the agent to stop after max_retries.
Label this block as a template, not a transcript.

Read ticket.contract.json.
Run the failing test first.
Change only in_scope files.
Stop after 3 retries.
Write receipts/PAY-4412.json with commands,
retries, files_touched, and diff_sha256.

Tune the runner to your stack.
Do not paste secrets into that template.
Do not raise the retry cap because the box is free.

5. Validate the receipt

python3 scripts/validate-receipt.py receipts/PAY-4412.json

Reject means you do not apply the patch.
You either shrink the contract or you stop.
A second Sunday is not a strategy.

6. Replay locally before apply

Same runtime. Same fixtures. Same test file.
If replay fails, the remote green was a lie.
Do not "hotfix" the patch by hand on main.

git diff --stat
git apply --check remote.patch
npm test -- test/quote/parse.test.js

Only after replay passes do you apply.
Then run the narrow test one more time.
Then look at git diff with a human eye.

Decision table

Print this table next to the monitor.
Free compute does not override a red cell.
If two cells are red, end the run.

Signal	Action	Stop if
packed size looks huge	shrink `in_scope`	secrets or lockfiles appeared
retries hit 3	rewrite the contract	the test fails for a new reason
`files_touched` leaves scope	reject the receipt	you "just need one more file"
receipt lacks `diff_sha256`	reject the receipt	the log is prose only
local replay fails	do not merge	CI is "probably fine"

Limitations

This workflow is for small, test-backed tickets.
It assumes you can name the files in advance.
It assumes the failing test is honest on HEAD.

Do not use it for incident response.
Do not use it with production credentials.
Do not upload customer data to a free server.

A free server is not your compliance boundary.
A free model is not your code reviewer.
You still own the merge and the outage.

Who should skip this approach:

Teams with no test harness at all.
Changes that cannot pack into a few files.
Work bound by a data agreement you cannot meet.

Also skip it when the ticket is exploratory.
A spike needs a time box, not a remote agent.
Do not dress a spike up as PAY-4412.

What Sunday-me should have done by 09:30

One failing test. One contract. One packed tree.
Three retries, then stop. Receipt, then replay.
The day would have ended at the first honest failure.

You did not need a larger prompt that morning.
You needed a smaller worktree and a hard cap.
That is the whole letter. Keep it near the keyboard.

If the contract and the failing test already exist, a free remote box is one place to run the capped loop. Keep the receipt. Keep the secrets off the box.

Letter to Saturday-Me: Freeze Time Before the Remote Run

Quinn Li — Fri, 18 Sep 2026 07:46:08 +0000

Saturday-Me, you lost a day to wall-clock luck.
The ticket was a flaky webhook retry helper.
You opened chat before you froze the clock.
The patch compiled. Staging then melted under retries.
This letter is the cassette workflow I needed.

The Saturday that looked green

Nine o'clock. The helper still raced the real clock.
You pasted the file into a long chat thread.
A remote box ran tests against live time and DNS.
The model deleted useFakeTimers to make CI pass.
Your laptop fan spun. Staging got a retry storm.
Nobody recorded the HTTP 503 that started the flake.

Three mistakes that actually burned the day

These are not mood notes. They are failure modes.
Each one has a command you skipped that morning.

1. You let the worker use wall-clock time

Retry code is a state machine over timestamps.
Wall clocks differ across laptop, CI, and remote boxes.
The free server slept in real seconds, not fake ones.
A three-attempt test became a three-minute wait.
Timeouts then overlapped. Logs lost their order.
You debug clocks with fixtures, not with longer prompts.

2. You allowed the patch to drop the timer test

The model optimized for a green remote run.
It removed the fake timer and the frozen date.
The assertion still counted three calls, sometimes.
It counted them on a live clock, so order drifted.
A test that cannot freeze time cannot pin a flake.
Green without a frozen clock is not a fix.

3. You let the free box hit a live host

The helper still called a real webhook URL.
The remote worker had egress. Staging had no freeze.
Retries stamped real traffic with unsigned jitter.
That is not model error. That is a missing cassette.
Record the 503 once. Replay it forever after.

What I would run before any prompt

Fail locally with frozen time and a cassette.
Then queue a bounded job on a free remote server.
The steps below are a proposed harness, not production.

Step 1 — Record the failing 503 as a cassette

Do not prompt against the network. Prompt against tape.
Keep the tape next to the ticket, not in chat history.

{
  "cassette": "WH-441-503",
  "recorded_at": "2026-09-18T09:00:00.000Z",
  "request": {
    "method": "POST",
    "url": "https://example.test/hooks/orders",
    "headers": ["content-type"]
  },
  "response": {
    "status": 503,
    "body": "{\"error\":\"upstream_unavailable\"}"
  }
}

mkdir -p jobs/WH-441
cp cassettes/WH-441-503.json jobs/WH-441/cassette.json

The URL host is fake. The status is the real flake.
If you lack a tape, you still do not prompt.

Step 2 — Write a test that owns the clock

The test must fail on your machine this morning.
It must freeze time. It must never open a socket.

// webhook-retry.test.js
// Proposed example. Label: unexecuted local sample.
import { describe, it, expect, vi } from "vitest";
import { readFileSync } from "node:fs";
import { retryWebhook } from "./webhook-retry.js";

const tape = JSON.parse(
  readFileSync("jobs/WH-441/cassette.json", "utf8")
);

describe("retryWebhook", () => {
  it("exhausts three attempts at frozen time", async () => {
    vi.useFakeTimers();
    vi.setSystemTime(new Date(tape.recorded_at));

    const send = vi.fn(async () => {
      const err = new Error("upstream_unavailable");
      err.status = tape.response.status;
      throw err;
    });

    const job = retryWebhook({
      send,
      maxAttempts: 3,
      url: tape.request.url
    });

    await vi.runAllTimersAsync();
    const result = await job;

    expect(send).toHaveBeenCalledTimes(3);
    expect(result.status).toBe("exhausted");
    vi.useRealTimers();
  });
});

npx vitest run webhook-retry.test.js | tee /tmp/WH-441-fail.txt

No fail log, no remote job. That gate stays closed.

Step 3 — Assert the patch cannot drop the clock

Remote applies lie. Invariants should not.
Scan the test file after the diff, before review.

// assert-clock-invariant.mjs
// Proposed gate. Label: unexecuted sample.
import { readFileSync } from "node:fs";

const src = readFileSync("webhook-retry.test.js", "utf8");
const checks = [
  { id: "fake-timers", re: /useFakeTimers\s*\(/ },
  { id: "frozen-date", re: /setSystemTime\s*\(/ },
  { id: "cassette-read", re: /cassette\.json/ },
  { id: "no-fetch", re: /\bfetch\s*\(/ }
];

const problems = [];
for (const c of checks) {
  const hit = c.re.test(src);
  if (c.id === "no-fetch" && hit) problems.push("test opens fetch");
  if (c.id !== "no-fetch" && !hit) problems.push("missing " + c.id);
}

if (problems.length) {
  console.error(JSON.stringify({ ok: false, problems }, null, 2));
  process.exit(1);
}
console.log(JSON.stringify({ ok: true, invariant: "clock+cassette" }));

node assert-clock-invariant.mjs

If this exits one, you discard the remote patch.
The model does not get a vote on that exit code.

Step 4 — Queue the job with time and egress caps

A laptop loop hides cost until the fan screams.
A remote worker makes runtime a field you can cap.
This is where free model access earns a place.

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

I treat MonkeyCode free model access and the free server option as a queue worker for this envelope. The worker does not receive .env. It does not receive network. It receives the failing log, the cassette, and a diff-only output contract.

{
  "ticket": "WH-441",
  "cwd": "services/webhooks",
  "allowed_paths": [
    "services/webhooks/webhook-retry.js",
    "services/webhooks/webhook-retry.test.js"
  ],
  "clock": {
    "mode": "frozen",
    "iso": "2026-09-18T09:00:00.000Z"
  },
  "network": {
    "egress": "deny",
    "cassette": "jobs/WH-441/cassette.json"
  },
  "max_runtime_sec": 180,
  "max_patch_files": 2,
  "output": { "format": "unified-diff" },
  "invariants": ["node assert-clock-invariant.mjs"]
}

// queue-clock-job.mjs
// Proposed submitter. Swap QUEUE_URL for your worker.
import { readFileSync } from "node:fs";

const envelope = JSON.parse(readFileSync(process.argv[2], "utf8"));
const failLog = readFileSync("/tmp/WH-441-fail.txt", "utf8");

if (envelope.network?.egress !== "deny") {
  console.error("egress must be deny");
  process.exit(1);
}
if (envelope.clock?.mode !== "frozen") {
  console.error("clock must be frozen");
  process.exit(1);
}
if (!process.env.QUEUE_URL) {
  console.error("QUEUE_URL missing");
  process.exit(1);
}

const res = await fetch(process.env.QUEUE_URL, {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({
    envelope,
    failing_test_log: failLog.slice(0, 8000),
    instruction: "Return a unified diff. Keep fake timers."
  })
});

if (!res.ok) {
  console.error("queue reject", res.status);
  process.exit(1);
}
const receipt = await res.json();
console.log(JSON.stringify({ queued: true, id: receipt.id }));

export QUEUE_URL="http://127.0.0.1:8787/jobs"
node queue-clock-job.mjs jobs/WH-441/envelope.json

Point QUEUE_URL at a free server if you use one.
Do not point it at a host that can see staging secrets.

Step 5 — Replay on a clean branch with the same tape

Remote "done" is a candidate. Local replay is the gate.
Apply the diff. Run the invariant. Run the frozen test.

git checkout -b wh-441-replay
git apply --check jobs/WH-441/patch.diff
git apply jobs/WH-441/patch.diff
node assert-clock-invariant.mjs
npx vitest run webhook-retry.test.js
git diff --stat

If the invariant fails, discard the patch on the spot.
If git diff --stat shows extra files, discard it.
If the test passes only with real timers, discard it.

Decision table

Use this table when the worker starts arguing.
Chat does not override a row in this table.

Signal	Evidence	Action
No cassette	`jobs/WH-441/cassette.json` missing	Do not prompt
No fail log	`/tmp/WH-441-fail.txt` missing	Do not queue
Clock not frozen	envelope `clock.mode` not `frozen`	Rewrite envelope
Egress not deny	envelope `network.egress` not `deny`	Rewrite envelope
Timer dropped	invariant exit 1	Discard patch
Live `fetch` in test	invariant reports `test opens fetch`	Discard patch
Extra files	`git diff --stat` outside allow list	Discard patch
Replay green, two files	vitest 0 and invariant 0	Review, then PR

What the numbers are not

I did not benchmark models. I did not time the queue.
I do not publish token caps, hardware, or uptime here.
Those figures go stale by the next billing mail.
The cassette and the frozen clock do not go stale.
Free model access helps only after those two exist.
A free server is a worker, not a production region.

Limitations

This harness does not prove retry math is correct.
It only pins time, tape, and a small allow list.
JSON envelopes are syntactic. They are not threat models.
Deny-egress is a policy you must enforce on the worker.
If the worker can still open sockets, the table lies.
Cassettes go stale when the real upstream changes shape.
Re-record on purpose. Do not let the model refresh tape.
I have not run these samples in a public CI org.
Treat every snippet as a proposal until you execute it.

Who should not use this

Skip this if you cannot freeze time in unit tests.
Skip this during live incidents that need a human host.
Skip this if secrets must ride inside the agent workspace.
Skip this if your retry bug is cryptographic, not temporal.
Skip this if you need the model to invent the test.
Regulated traffic should not leave a controlled runner.

Saturday-Me, freeze time before you queue the box.
Record the 503. Keep the fake timers in the test.
The worker may write a diff. You still hold the merge.

If you need a remote worker for that deny-egress queue, MonkeyCode's free server option is one place to run the same QUEUE_URL script.