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

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.