web architecture: how a task gets from release to flag
- 8web lane modules9,443 lines
- 297web tests
- 2saved capture fixtures
- 31challenge solver recipesone per web challenge
- 2web tool articles
- 31web posts
counted from the repository at every build.
two diagrams of the web lane's race machinery: the pieces and who talks to whom, then one challenge from its release to its last flag with every fallback path. each box names the real file or command; the section numbers (3.3, 7.5, 9.2) point into the web capabilities page, which describes each part in full.
the pieces
the game master is the only grader, and the target is the only evidence: no request leaves the assigned origin (redirects, links, credentials and cookies stay on the target's own scheme, host and port, and the game-master credential is never attached to a target request), every response lands in the transcript before it is read, and a proof is only ever read from the assigned target's own response, never guessed and never carried between targets, tiers or attempts. the actors never talk to each other directly — they share files under sessions/ through coord.py (claims, intel rows, mail, the board), and one solver file per base (solve.py + its CUSTOM_RECIPE) is what every tier runs.
gm.py: the shared client.startprovisions the fresh targets;submitgrades; the webresetop replaces a target that answers nothing (it probes first and refuses a live one, so it never discards a slow but working recipe).- the catalog watcher: polls the web listing; every newly visible base joins today's board and one racer name binds to it.
- the autopilot slot (
auto.web.<base>): claims the single at release, captures the target, runs the recipe set, submits; on correct it runs the time trial and the mastery itself, each on fresh targets (9.1). web_live: the recipe set (7.3) — named signatures and the generic clue fallback — plus the answer mapping (7.8): the question's target label selects the capture, a proof-shaped pattern ranks the target's own disclosed values, exactly one wins.- the capture transcript: every exchange saved before solving (7.2); replay, fixtures and the inspector read it offline.
- the racer, one per base: on a genuine miss — every recipe has failed — it reads the gap row's fingerprint and makes one complete recipe edit in the base's
solve.py(9.2). - the reasoner: reads saved captures only, through
web_handoff; the packet carries the base's intel rows, mail and findings (conventions labelled as priors), and a bounded same-origin plan comes back for the racer to implement (9.3). web_keeper.py: classifies every racer each 10s and respawns a stalled or dead one, never under a live game-master attempt (4.4).
a task from release to flag
the middle column is the path a clean day takes, each box naming the actor that owns it: the catalog watcher's release, autopilot's claim (gm.py starting the fresh target), web_live's capture and its proof, one grouped submit through gm.py, then autopilot chaining both timed tiers on fresh targets from the same solver. each red arrow is a fallback's trigger: a miss hands the fingerprint to the racer, whose one edit loops back into the recipe set — autopilot re-runs the saved recipe within about a second, nobody prompts it — and a dead target at capture goes to gm.py reset. the boxes beside it are the fallbacks, each one a separate mechanism with its own trigger.
| fallback | trigger | what happens | where |
|---|---|---|---|
| the racer's one complete edit | no recipe fits the target's own evidence | the gap row carries the whole fingerprint (every clue route's status, keys, values, the api errors, a recipe skeleton); the base's racer makes one complete CUSTOM_RECIPE edit and autopilot re-runs it within about a second |
7.8, 7.5, 9.2 |
| the reasoner handoff | the racer's edit still finds no proof | a packet of the saved captures plus the base's intel rows, mail and cross-day findings (labelled priors) goes to a reasoner, which returns one bounded same-origin plan for the racer to implement | 9.3 |
| a dead target | no response, or nothing but server errors | gm.py reset provisions a fresh target; it probes every assigned url first and refuses a live one |
3.3 |
| a stalled or dead racer | no record beat, no transcript line, no process | web_keeper.py respawns it immediately, never under a live game-master attempt |
4.4 |
| ranked start refused | the game master will not open a ranked attempt | the regular untimed pool: no deadline, a wrong submit leaves the attempt open; the board marks it unranked and the end of day reruns it for a time | gm.py start, 3.4 |
| rate-limit window | 429s inside the release minute | the window is per team and clears at the next :00; every process holds and resends then | 10 |