The Upload Set a Senior Signed Before Any Free-Server Run

This workflow starts from a pairing scenario, not from a measured production incident. In that scenario the block had forty minutes left. A webhook verifier had grown a new signature check, and the laptop suite was already busy with an unrelated package install. A free server seat sat unused. Free model access was already open in the editor.

The faster path looked obvious. Upload the fixture tree, ask the model to rerun the suite, and treat a green log as the end of the hour. The senior did not ban the tools. The senior banned that shortcut.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. Free model access and a free server option are treated here as operator-supplied availability claims. This draft does not name models, quotas, hardware, regions, or retention periods, because no primary source for those details was attached.

Commands below are unexecuted examples. Paths are illustrative. No speedup figure is claimed, and no customer incident is described.

What the hour had to protect

The diff itself was small. verify_signature had to reject a stale timestamp and a bad digest. The risk was not line count. The risk was letting a hosted run define done while fixtures still held a local capture, a clock assumption, and hostnames the team was not allowed to copy off the laptop.

Published pieces on this account already covered retry budgets, replay exit codes, and path denylists. This workflow keeps a different object. It keeps a host-split manifest: which files a model may read, which tests a free server may execute, and which checks stay on the laptop even when the remote seat is idle.

That split is the technical subject. Hosted capacity sits around it. Capacity does not replace the split.

Questions written down before any remote command

The senior required answers in the pairing notes, not in the chat window.

1. Which paths contain tokens, customer payloads, signing keys, or internal hostnames?
2. Which tests depend on clock, locale, DNS, or outbound network, so a different host can pass for the wrong reason?
3. Which failures must be reproduced by a command both people can rerun after the session closes?
4. What is the stop rule if the free server returns empty, skips the new test, or resets mid-run?
5. Who initials the upload set before anything leaves the laptop?

The answers took longer than the patch. A model paragraph cannot initial an upload set. The junior owns the draft. The senior owns the signature. Either person can stop the remote run.

Dead ends that did not survive

A skip looked like success. The first remote attempt ran the package target on the free server. The log ended at exit code 0. The new test never started. The server image had no stub for the local signer, and the runner treated the missing extra as a skip. Green meant not collected. It did not mean the verifier held.

Filename optimism classified a capture as safe. Asked which fixtures could be uploaded, the model marked payload.sample.json as fine. A comment inside that file said the bytes came from a production capture and only the outer name had been sanitized. The classification was discarded. Safety is a content decision, not a suffix decision.

A bypass header appeared from nowhere. With the diff and a fixture pasted into the free model session, the edit proposed X-Verify-Bypass: 1 for local debugging. No such header existed in the repository. Accepting it would have taught the suite to pass by disabling the check. The senior reverted the buffer and kept the original assertion.

Each dead end failed the same local test. Could both people rerun the claim after the chat closed, without trusting the transcript? If the answer was no, the claim did not enter the notes.

The decision that stayed

Three host classes. One manifest. Fail closed.

• local-only stays on the laptop. Keys, captures, internal hosts, and clock-bound tests live here. They never enter an upload set.
• server-eligible may run on the free server. Pure functions and synthetic fixtures belong here, with no outbound network and no copied captures.
• model-visible may appear in the editor session. This class is for the diff, public interfaces, and synthetic examples. It is a subset of server-eligible, not a third dumping ground.

A file can be useful and still be local-only. Usefulness is not a transfer permit. The free server is a capacity valve for the server-eligible subset when the laptop is busy. Free model access is a drafting aid for names and comments. Neither class inherits trust from the other.

The hour's rule was written in one sentence and left in the notes. Nothing remote starts until the checker accepts the upload list and both names sit beside that list.

Sequence the pair followed

1. Freeze the diff. No further product edits until the host split exists.
2. Assign classes by hand. The model may suggest file names. Humans assign the class.
3. Write the candidate upload list as plain text, one path per line.
4. Run the checker. A non-zero exit stops the remote plan.
5. Run local-only tests on the laptop and record that exit code.
6. Only if the checker is clean, run one explicit server-eligible target on the free server. Record that exit code on a separate line.
7. If the codes disagree on a synthetic test, treat it as a host-class bug. Do not edit the assertion until collection, skip, and dependency causes are known.
8. Store the manifest and both codes. Do not store the model summary.

The laptop code wins for local-only tests. The free server never adjudicates those. A disagreement on a synthetic test is information about the host, not permission to weaken the check.

Unexecuted checker

The Python below is a proposal for the notes. It has not been timed. It does not call a network API. It reads a manifest and a candidate upload list, then exits non-zero when a local-only path is included, when an upload path lacks a server-eligible mark, or when model-visible is not a subset of server-eligible.

#!/usr/bin/env python3
"""Fail closed if an upload list violates a host-split manifest.

Unexecuted example. Paths and class names are illustrative.
"""
from __future__ import annotations

import sys
from pathlib import Path

REQUIRED = ("local-only", "server-eligible", "model-visible")


def parse_manifest(text: str) -> dict[str, set[str]]:
    classes: dict[str, set[str]] = {name: set() for name in REQUIRED}
    current = None
    for raw in text.splitlines():
        line = raw.strip()
        if not line or line.startswith("#"):
            continue
        if line.endswith(":") and line[:-1] in classes:
            current = line[:-1]
            continue
        if current is None:
            raise SystemExit("path before class header: " + line)
        classes[current].add(line)
    return classes


def main(argv: list[str]) -> int:
    if len(argv) != 3:
        print("usage: host_split_check.py MANIFEST UPLOAD_LIST", file=sys.stderr)
        return 2
    classes = parse_manifest(Path(argv[1]).read_text(encoding="utf-8"))
    upload = {
        line.strip()
        for line in Path(argv[2]).read_text(encoding="utf-8").splitlines()
        if line.strip() and not line.strip().startswith("#")
    }
    local_only = classes["local-only"]
    server_ok = classes["server-eligible"]
    model_ok = classes["model-visible"]
    errors: list[str] = []
    leaked = sorted(upload & local_only)
    if leaked:
        errors.append("local-only paths in upload set: " + ", ".join(leaked))
    unmarked = sorted(upload - server_ok - local_only)
    if unmarked:
        errors.append("upload paths missing server-eligible mark: " + ", ".join(unmarked))
    bad_model = sorted(model_ok - server_ok)
    if bad_model:
        errors.append("model-visible but not server-eligible: " + ", ".join(bad_model))
    overlap = sorted(local_only & (server_ok | model_ok))
    if overlap:
        errors.append("local-only overlaps another class: " + ", ".join(overlap))
    if errors:
        print("\n".join(errors), file=sys.stderr)
        return 1
    print("upload set ok: %d path(s)" % len(upload))
    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv))

Illustrative manifest:

# host-split.manifest
local-only:
  fixtures/captures/prod-replay.json
  tests/test_clock_skew.py
server-eligible:
  src/verify_signature.py
  tests/test_digest_synthetic.py
  fixtures/synthetic/good-digest.json
model-visible:
  src/verify_signature.py
  tests/test_digest_synthetic.py

Candidate upload list that should fail:

src/verify_signature.py
tests/test_digest_synthetic.py
fixtures/captures/prod-replay.json

Local command shape, still unexecuted:

python3 host_split_check.py host-split.manifest upload.txt
# non-zero expected: prod-replay.json is local-only

# after a clean upload list, laptop synthetic check:
python3 -m unittest tests.test_digest_synthetic

The free-server command is intentionally not scripted. The pairing rule was to submit one explicit test target after the checker printed upload set ok, then copy the remote exit code into the notes. A model retelling of that log does not replace the code.

Where the free options actually helped

Free model access had one narrow job. It drafted manifest comments and proposed synthetic fixture names. The bypass header and the filename classification were rejected. The useful residue was a shorter list of synthetic files, which the junior then wrote by hand.

The free server option was the place to run tests.test_digest_synthetic once the upload set was clean and the laptop was still busy. It was not the place to run tests.test_clock_skew. It was not evidence that production would behave the same way. A different host can pass because a test was skipped, not because an assertion held.

Remove every product mention and the workflow still stands. Split the suite. Check the upload set. Record two exit codes. The hosted seat only matters after that split exists, and only for the class the manifest allows.

Limitations, and who should skip it

• The checker matches path strings. It does not scan contents for secrets. A server-eligible path can still hide a token. Content review stays human.
• ./fixtures/a.json and fixtures/a.json are different strings here. Do not drop this example into a production upload pipeline without path normalization.
• Environment parity is out of scope. Locale, clock, CPU, and network still differ. Clock-bound and network-bound tests stay local-only.
• This split is not a data-processing agreement. Teams that must keep customer data, regulated payloads, or signing keys off shared hosts should not treat a free seat as an approved destination.
• Numeric allowances, model names, session length, and log retention were not verified for this draft. Availability changes. Current product docs outrank this article.
• A solo rush with nobody to initial the manifest should skip the remote half. The second signature is the control. The script is only the latch.
• Flaky timing suites and air-gapped repositories are a bad fit. So is any team that wants one green badge to cover both hosts.

What the notes closed on

The hour ended with a rejected upload list, a clean synthetic subset, and two exit codes written on separate lines. The model's paragraph about the verifier was not stored. The initialed manifest was.

Readers who already have a free model seat and a free server option can run this checker on a throwaway repository first. Only a clean synthetic subset should be aimed at the remote host. If current docs disagree with these availability assumptions, the docs win.