Agents

Each agent does one stage of the method or one task, with its skills preloaded, and ends with a hand-off that names the next agent. Agent teams shows them working together.

Agent	Skills	What it does
re-surveyor	re-setup, re-inventory	First stage for a game. Checks the toolchain, takes the first look at the game's files (which binaries hold its own code, engine, packing, data containers, saves), classifies the kind of game, and records it in docs/FINDINGS.md. Use at the start of a project or when a new binary or file type appears.
re-observer	re-observe	Runs the original game where it can be watched, driven and captured (GameFrame's emulators, DOSBox-X, Wine, a streamed PC) and records frames, state, inputs, file reads and sound as measured evidence; lists every input and screen. Use before porting a system whose behaviour must be seen.
re-decompiler	re-ghidra, re-rea	Exports the game's own binaries with Ghidra in headless mode (decomp.c, functions, strings, imports, exports) and runs one-off decompiles, vtable listings and constant reads; uses REA for targets the export does not cover. Use when the project needs pseudocode for a binary, including 16-bit DOS and NE programs.
re-tracer	re-trace, re-ghidra, re-rea	Finds how the original implements one thing, from a string, resource name, import, export, class name or known caller to the function, its inputs, the fields it reads and writes, its constants and the loop that calls it, and writes the result down as evidence. Use for any 'how does the game do X?' question.
re-decoder	re-format	Decodes one of the game's data files (archives, compressed entries, resources, assets, saves) by finding the code that reads it, prototyping a decoder, and proving it against every file of its type with all bytes consumed. Use when a file type is not yet understood or a decoder fails on some files.
re-measurer	re-emulate	Runs chosen functions of the original under the Unicorn emulator (Windows x64 or 16-bit DOS/NE) to capture exact ground truth for chosen inputs, and records the calls they make, such as random draws. Use for anything a reimplementation must match bit for bit.
re-porter	re-port	Reimplements traced and measured game behaviour in new code that behaves exactly like the original: same structure, numeric types, order of operations, random draw order, iteration order and integer semantics, citing the original function on every item. Use when writing the reimplementation of anything traced.
re-verifier	re-verify	Proves that a reimplementation matches the original: bit-exact parity against emulator ground truth, random-draw order, determinism with digests, recordings and replays, real save files, pictures against the original. Use after every reimplemented slice and before landing it.
re-lander	re-land	Finishes a slice of work: writes findings into docs/ in the evidence style, adds function and field labels, updates the checklist, then commits only its own files (never game material or decompiled code) and pushes. Use at the end of every slice.
re-identifier	re-inventory, re-ghidra, re-rea	Identifies the engine, the middleware, the compiler and the libraries linked into a game from its files, strings, imports, RTTI and magic numbers, labels the library code so tracing skips it, and records each with its evidence. Use at the start of a project, or when an unknown library turns up.
re-randomiser	re-trace, re-emulate	Finds every random number generator in a game, its state, its seeding and every caller, then measures the draw order with call traces so a port can draw the same numbers in the same order. Use before porting anything that draws random numbers.
re-listener	re-observe, re-trace	Lists every input a game reads from outside: controls, clocks and timers, random seeds, files and configuration, hardware detection, window messages and network messages, with the address of each read, and proposes the port's input record. Use before porting the main loop or anything that must replay exactly.
re-cataloguer	re-observe	Makes an inventory of every screen of a game's interface: how to reach it, the code or layout that draws it, its states, inputs, the changes it makes, its text and font, with a capture of each state. Use before porting the interface or a menu.
re-mapper	re-trace, re-ghidra	Maps how a game uses its machine: hardware registers and ports, memory banks and overlays, video and sound chips, and the variables in RAM, with a name and evidence for each address. Use for DOS, home computer, console and arcade games before tracing their logic.
re-typer	re-trace, re-ghidra	Recovers the game's structures, classes and enumerations from the code that uses them: sizes from allocations, fields from constructors, serialisers and every access, the C++ containers they hold, and names from evidence, written to Ghidra and labels/fields.tsv. Use when pseudocode is full of param_1 + 0x24 offsets, or before porting a system whose data the port must lay out exactly.
re-matcher	re-emulate, re-verify	Checks whether a ready implementation matches the game's own version: a GameFrame crate (OPL2, WMA, MSVC CRT, Turbo Pascal), a released engine source or a library, by running the original on many inputs and comparing bit for bit. Use before depending on code you did not port from this game.
re-editor	re-land	Edits documentation, skills and posts to GameFrame's writing rules: plain English, one idea per sentence, and none of the patterns to avoid (colon reveals, "X, not Y" endings, matched pairs, paired clauses, "and the" chains, signposts, figures of speech, statements about how a page was made). Changes wording only, never facts. Use after writing or before publishing.
re-checker	re-land, re-trace	Checks the claims in documents: every finding has an evidence label and points to its evidence, every cited address and file exists, every external fact matches its source, and unconfirmed claims are marked. Reports or fixes what is wrong. Use before publishing documents or after research.