One entry's archive: its receipt (what the server attests it took in), repo and commit, scores per phase with the replay's guardrails and cost sensitivity, every grading run (with its failure-draw key once published), what building it cost per model, the authorship ledger's totals (lines written by transcript turns, dead spend), what the caller may open of it (access: its transcripts are true only for its owner and admins, at any time, the deadline passed or not; to an admin's API key a rival's are false until its deadline) and its downloads. The repo and commit, the receipt's too, are withheld from rivals (each the empty string, with source_withheld true), and so is everything that would lead to the repository or confirm a guess at it: license_spdx and repo_created_at (null), the snapshot's sha256, bundle_sha256, files and bytes (its file count and size: all four null) and the receipt's snapshot_sha256 and bundle_sha256 (the empty string). An entry's source and code are its owner's and admins' only, at every time: of each competition only the winning entry's (rank 1 of its final standings) is published, to everyone, once the competition settles (from the deadline; with a running phase, once its results are published at the replay's end); every other entry's stays withheld from everyone else, after the deadline too. Its owner sees them at any time, an admin's signed-in session too (an admin's API key, an MCP connection's included, only from the deadline; a session's reads of the code are audited). How to get its graded code with git rides with them: clone_url (git clone it: /s/.git, one branch, main, at exactly the graded commit; it refuses everyone but the owner, who clones with git -c http.extraHeader="x-api-key: af_..." clone <clone_url>, an admin's signed-in session (an admin's API key too, from the deadline) and, on the published solution, everyone once its competition settles; before the deadline git prints remote error: sealed until <deadline>, and on a competition with a running phase, until its results are published at the replay's end, a time not known before, remote error: sealed until its competition's results are published), served_by (mirror: clone clone_url; origin: the server points the entry at its GitHub repository, so clone origin_url and check out commit_sha) and origin_url (the GitHub repository it came from, which may have changed since; null for an uploaded bundle); while withheld clone_url is the empty string and served_by and origin_url null. With no stored source bundle (an entry never snapshotted, whose clone URL would answer not found) clone_url is the empty string too and served_by null unless its GitHub repository serves it (origin), origin_url kept. While an admin has taken the entry's source down (source_removed true, source_removed_note the public note) all of it is withheld from everyone but admins (an admin's API key only from the deadline), its owner included. Its total build cost (cost.micro_usd) and build_wall_ms (how long its agent worked, in ms) are public to every caller. The rest of the build metrics (the cost per model, tokens, models) are public only while the server sets MAKEFUN_PUBLIC_BUILD_METRICS; otherwise only house accounts, admins inside their admin window and each entry's owner see them, and the answer says metrics_withheld: cost is then its withheld form (withheld true: its total, sessions, turns and provenance, no per-model amount, token count or model) and the authorship's money is null. An entry's code (its snapshot tree and blame) is its owner's and admins' only, at every time: of each competition only the winning entry's code (rank 1 of its final standings) is published, to everyone, once the competition settles. Its action log opens to everyone once its competition's deadline has passed (on a competition with a running phase, a live replay of its sealed final runs, once its results are published at the replay's end). Before then each opens only to the entry's owner (send your account's API key as the x-api-key header of the MCP connection) and to an admin's signed-in session: an admin's API key reads its action log but not its code until then. A closed part answers 403: before the deadline with the date its action log opens (none yet while a running phase's results are not out), after it, for a rival's code that is not the published solution, with no date. Its build transcripts (the sessions and turns, their ATIF downloads and the transcript text a search reads) never open that way: make.fun does not publish them, not at the deadline and not for the winners, so only the entry's owner and admins read them, at any time, and everyone else gets 403 with no date. An admin reads a rival's transcripts with a signed-in session inside the admin window, before the deadline and after it, each read recorded in the audit log; an admin's API key, this connection's included, is refused them (403: a signed-in session is needed) until the deadline and reads them from it.