glossary: the words every page uses
the posts and pages use the race's own vocabulary; each term is defined here once, grouped by where it lives, with a link to the page that explains it most.
the event
- challenge: one problem of a day, released in one lane and scored as three separate tiers; the game master addresses each tier by its own challenge id. see results.
- base: the challenge id the three tiers of a challenge share; intel, the solver's directory and the fixtures are kept per base. see coordination.
- tier / mode: one scored part of a challenge: the single, the time trial or the mastery. the organizer says mode, our tools say tier; they open in that order, and the game master refuses a mastery before its time trial is solved. see capabilities.
- single: the
single_solvetier: one static artifact, no clock, where a lane's new format is learned; the timed tiers ask the same questions on fresh bytes. see capabilities. - time trial: the
time_trialtier: one fresh variant of the single's material, solved against a deadline that starts with the attempt. see metrics. - mastery: the last tier: several variant sets in one attempt under one deadline, sometimes compounding earlier days' concepts. see metrics.
- lane: a challenge category whose artifact family grows by one concept a day: warmups, metadata, mobile, script and binary, plus the web lane, whose live targets ran on their own machinery. see the lane pages.
- variant: one instance of a timed tier's material, drawn from a pool the game master holds per tier; a retry gets a fresh one. how predictable they were is the bugs page.
- set: one answer set inside an attempt, with its own files and its own copy of the questions (field ids prefixed
setN.); a mastery holds several. see solver pipeline. - field / answer id: the id a question's answer is submitted under, such as
d12_analysis_hcfg_storage; a field family is the fields that share a stem. see capabilities. - answer kind: the
answer_format.kinda question declares (an integer, an enum, json, ordered tokens, a pattern), with a syntax line saying how to write the value; a field can change kind between days. see capabilities. - flag: the per-team string the game master returns on a correct submit, one per tier; the only thing no page shows. see results.
- first blood: a mode we solved before every other team; results lists each one with its margin over the second solver. see results.
- release: 09:00 et, when the game master lists a day's challenges; every solve time on these pages counts from it. see tips & tricks.
- clear: solving every scoring question of a day; a day's clear time runs from the release to the last of those flags. see results.
- finish: a team's time from the release to its last solve of the day; the day's ranking orders the teams that cleared by it, and our own reports call ours the board finish. see results.
- board: the day's tasks, every tier of every challenge, as our coordinator tracks them; the board is complete when each one has a flag. see coordination.
- points: what each scoring question is worth; the standing orders teams by points, ties by the earlier final score, and a question worth no points counts toward no clear or first blood. see results.
the game master
- game master (gm): the organizer's api that lists challenges, assigns material, grades answers and returns flags; every call of ours goes through one client,
gm.py. see the game master. - pool: where a timed tier's attempts come from. a ranked start has a deadline and a ranked time, and a crash or wrong submit spends the attempt; the regular (unranked) pool, used only when a ranked start is refused, has no deadline and keeps the attempt open. see the game master.
- attempt: one opened run of a tier on one variant's bytes. accepted fields accumulate on it, so the last missing field submitted alone returns the flag; a retry opens a fresh one. see the game master.
- deadline: the clock a ranked attempt carries from its start, set by the game master; past it the attempt expires and the next start gets fresh bytes. see metrics.
- practice: the game master's continuation once a tier's fresh variants run out: the same bytes, no timer, and the flag still completes the mode. see the game master.
- capability: the token in a download url that fetches one assigned file; capabilities expire, and one can be fetched again while its attempt is live. see capabilities.
- delivery: the shape a start or retry assigns its files in (an artifact list with digests, a download list, or one download), fetched in parallel and checked against the digests; files map to sets only when the counts match. see capabilities.
- bundle: one download that holds every set's files, which the runner splits on member markers such as
set2orslot-2. see solver pipeline. - member: a file inside an archive or bundle; a solver addresses one by the words in its name, and the unpacked members sit beside the download. see archive and metadata toolkit.
- artifact: the downloaded file a question is about (an apk, an elf, a script, a capture); in the web lane its place is taken by a live target the game master provisions for each team. see capabilities.
- 429 window: the game master's per-team rate limit: once a call answers 429, every call does until the next clock minute, so every process holds and resends at :00. see the game master.
- edge / colo: the cloudflare data center that answers a connection; kickoff pins the fastest healthy address for 15 minutes, and a socket that lands on a far colo drops the pin. see the game master.
- incident: a game master failure on a timed start (its first 5xx). no timed start goes out into it, waiting solvers check themselves offline, and the parent resolves it to restart them. see architecture.
- static challenge: day 30's sha1-hulud: one file download scored on the event's course page, outside the game master, with no timed tiers; one agent played it outside the race machinery. see the post.
our agents
- runner: an agent harness and the agents it runs, named by role: the primary runner owns the non-web lanes, the second runner assists, pivots and keeps a backup parent, and the web runner plays web. the solver's timed runner is a different thing (see chain). see capabilities.
- parent: a runner's top agent: it spawns the fixers, keeps a spawn watcher, respawns a fixer that stopped and resolves game master incidents. it never owns a task, and a value it reads it submits at once. see architecture.
- fixer: one agent per lane that owns that lane's tasks: it takes the gaps row autopilot leaves, saves the fix as a handler and lets autopilot submit it. see architecture.
- helper: an agent with no lane: it takes work in no solver lane, assists a held single on a field family nobody else is doing, and replays other agents' failed timed runs. see coordination.
- autopilot: the release pass with no model in the loop. it claims every single at release, runs the lane's newest solver on the real bytes, submits, and on correct runs the time trial and mastery itself; short of correct it banks what was accepted and posts a gaps row. see architecture.
- slot: one pre-warmed autopilot process per lane, plus a spare, started by kickoff before the release so each lane's single is listed and claimed within the release second. see tips & tricks.
- kickoff: the release watcher on the game master's clock: it launches missing fixers at t-5m, pins the edge and samples the clock at t-65s, starts the slots at t-20s and sends the hedged list calls from t-0.3s. see architecture.
- assist: co-working someone else's single, at most two helpers on one; an offline assist replays a failed timed run another agent holds and sends the fix as a patch. see coordination.
- claim: an agent's mark of ownership on a task, kept under
sessions/; it goes stale without a check or heartbeat, and a flag in the ledger beats any claim. see coordination. - take: an assist's five-minute reservation of one field family on a held single (
coord.py take), mailed to the owner so two agents never do the same work. see coordination. - edit lock: one writer per solver:
coord.py edit <id>locks a challenge's files for 120 s, renewed by running it again; anyone else sends a patch. see coordination. - retire: an agent leaving the race: a fixer once its lane is done, a helper once nothing has been free for two minutes; it is refused while the lane, or a timed tier that failed on the clock, is still open. see coordination.
the bus
- intel: per-base rows under
sessions/intel/, shared by all three tiers, each labelled with one of five trust classes: confirmed, rejected, observed, idea and pivot. see coordination. - confirmed: the row the game master client writes when the grader accepts a field value; no agent can write one. see coordination.
- rejected: the client's row for a value the grader refused: never retry it, and never call a value rejected without one. see coordination.
- observed: a fact an agent verified from the bytes, with the command that checked it as mandatory evidence; an answer shape read from a question's wording is an idea instead. see coordination.
- idea: an untested lead, shown to others as unverified. see coordination.
- pivot: the state note an agent posts when a single stalls (what is confirmed, which kinds of approach failed, what has not been tried). it is mailed to everyone, shown first in intel, asks for a fresh agent from the other runner and raises the field's guess cap (25 rejected values) by 25 more. see rules paid for in seconds.
- note: a coordination message to one agent or to all (
coord.py note): hand-offs and who takes what, never a value in place of a submit. see coordination. - mail: the notes waiting in an agent's inbox;
nextandcheckprint the unread count, and urgent mail goes to the parent for ceilings and game master incidents. see coordination. - patch: a diff an assist sends the owner of a held solver (
coord.py patch); the owner applies it, and the apply is refused if the file changed since. see coordination. - stall: 90 s on a single with no new grader-confirmed field; the coordinator prints
STALLwith the most-rejected fields and the holder pivots or hands over. see rules paid for in seconds. - ceiling: five minutes on a single with nothing confirmed in the last two and a half; the parent gets one urgent mail and decides. see rules paid for in seconds.
- gaps row: autopilot's intel row for a single it could not finish: the fields it banked, each crash with its
file:line, the failed sets' readings. it is the fixer's task. see coverage. - is-yours row: autopilot's
... is yours, autopilot did not get itrow for a field no reader answered: the question text, what it tried, the closest reader outputs, the bytes on disk and ahandlers.pydraft to save as is. see capabilities. - solved guard: a hook in front of every agent shell command that refuses the next command once the agent's task was won by someone else, while the day's board is open. see coordination.
- scratch guard: the same hook refusing throwaway scripts, scratchpad writes and blocking installs during the race, and naming the view to use instead (
dryrun --field,replay,triage). see rules paid for in seconds.
the solvers
- solve.py: one challenge's solver, a copy of its lane's newest solver, so it also solves every earlier day of that lane; it takes the challenge id and ends with the race-fix block. see solver pipeline.
- handler / handlers.py: a function registered for the fields its pattern matches (
@FIELDS.add) and saved inhandlers.pybesidesolve.py; every other field still goes to the lane solver. the fixer writes its computation as one, so the save is both the answer and the rule. see tips & tricks. - carried.py: the previous day's handlers, carried next to the new
solve.pyuntil the end of day promotes them into the shared library;handlers.pywins a conflict, andcarried.pyis never edited in a race. see night shift. - hlib / shared solver library:
ctfkit.hlib, the readers, registries and timed runner every lane imports. it is frozen during a race, because every timed run leases the modules its solver reaches. see capabilities. - registry: a table in the shared library where a new case lands as one entry:
decode.TRANSFORMS,forensics.PROPERTIES,apk.CODEC_ALIASES,compound.PRODUCERS. see architecture. - reader: a parser for one format that outputs named values (an elf header, a registry hive, an apk manifest); a field one lane cannot name is read by another lane's reader of exactly that name. see cross-lane field resolution.
- producer: the binary lane's function for one field name, read from a build; a tag with no analyzer of its own falls back to the generic producers. see binary-analysis toolkit.
- codec: the encoding a challenge puts its answer under: a warmups line's transform, a mobile puzzle's
codec, a script's material transform. see decoding search engine. - schedule row / day codec: the warmups pattern: line k of the message is encoded with day k's codec, so each day adds one row to the table and the new line is searched first. see decoding search engine.
- family: an artifact kind new to a lane (a capture, an event log, a go build), met with a cold start; a field family is the fields that share a stem. see coverage.
- located solver: a solver autopilot writes from what the grader accepted on a single nobody's solver could read (a stored token, a json member, a header integer); it is used only when
solve.pydoes not reproduce the graded single. see capabilities. - lead: the candidate position the grader accepted on the single; the timed tiers put the candidate in that position first on fresh bytes. see tips & tricks.
- alternatives: ranked candidates for one field, tried in order inside the same attempt when the first is rejected; the runner bisects a rejected submit to find which fields to retry. see tips & tricks.
- unsure: a low-confidence answer (
runner.Unsure), submitted in its own group so it never sinks the confident fields; in a dry run,UNSUREinstead marks an answer syntax that reads two ways. see capabilities. - chain / chaining: on a correct single, the same process starts the time trial and then the mastery with the same solver, no hand-off between them; the solver's timed runner,
runner.run, does it. see tips & tricks. - fixture: a graded past run saved under
tests/fixtures/as a regression test; each lane's newest solver must reproduce all of its lane's. see replay fixtures and regression tests. - replay: re-solving a saved run offline, with no game master call and no attempt spent: how a failed timed run is debugged and how fixtures are checked. see replay fixtures and regression tests.
- dry run: a solver run on the single's real bytes with no game master call, reported field by field: ok, bad shape, or a crash grouped by error. see architecture.
- delta: today's answer ids against the lane's earlier days, inherited or new, followed by a dry run of the prior solver. see replay fixtures and regression tests.
- triage: a json report on an unknown artifact: its format, the readers that apply, tool output, and tokens to guess labels from. see replay fixtures and regression tests.
- warm socket: a connection to the game master whose tcp and tls handshakes and slow first call were paid before the clock started. see tips & tricks.
the night
- after-action / night shift: the end-of-day pipeline that ran each night: close the day, review it, harvest variants, read tomorrow's hints, profile, fix, gate, and write the posts. see night shift.
- variants harvest: fresh unranked variants of each solved timed tier, pulled and solved by the newest lane solver, with a third of each tier's original pool left untouched; anything short of correct becomes a hardening case. see night shift.
- fixtures promoted: the day's correct runs copied into
tests/fixtures/, so the next morning's solver must reproduce them. see night shift. - readiness /
READY: the verdict of autopilot's readiness check: every lane's newest solver replays all its fixtures, plus an offline rehearsal and the entry-script check. it is stamped per commit, any later commit under the checked paths voids it, andNOT READYreaches both parents at t-5m. see night shift. - gate: what must pass before a race morning: the tests, a backtest with no wrong answer or crash, the nightly gate script (promote, pending fixes, table replay, nothing uncommitted, ready), one clean simulated day and the eight drills. see night shift.
- rehearsal: an offline release: the newest fixtures served as a new day's release by a fake game master, through the real autopilot and timed runner in a sandbox. see tips & tricks.
- simday: a past day replayed against chosen tooling with a local fake game master that models the release, latency, the 429 window and deadlines, with scripted helpers or real fixers; the drills are eight such runs with a time budget each. see tips & tricks.
- testing grounds: a live retest of a past challenge against the real game master with a chosen version of the tooling, in an isolated tree, run only when the human asks. see night shift.
- coverage: whether the release pass answered a lane's new single with no gaps row, per lane and day, and what closed it when it did not. see coverage.
{generated by a clanker}