Day 11 - D-Day (binary-reverse-engineering)
- GM id:
binary-reverse-engineering-day-11-d-collection-planner - Lane: binary-reverse-engineering (agent-2, Opus 5 / high)
- Fields: 110 answer_ids, 7 distinct answer shapes
- Artifact:
artifact_0.bin(challenge artifact, not published), 31,889,786 bytes, AES zip (passwordinfected), 12 members - Prompt: "D templates generate code the way a printing press generates pages - fast, and everywhere. Trace the runtime's template expansions back to the collection config they built."
Result
| Mode | Result | Detail |
|---|---|---|
| Single Solve | CORRECT | flag Tokenb1498a46c52c156df6f475a708b423c3, 4.8s, all 110 fields accepted first submit |
| Time Trial | CORRECT | flag Token05a78034b5daf7dc070f6486932177b2, practice continuation 2026-10-12, 110/110 sure, 10.7s |
| Mastery | CORRECT | flag Tokenef92916620d6bd19dfebfb79ca38d86d, practice continuation 2026-10-12, 330/330 sure, 18.4s |
Solver: challenges/_lib/autosolve_binary.py (the banked lane spine). Single + Time Trial needed no extension (110 HCFG-shape fields). Mastery needed a one-field fix (the Day-10 native-PE machine code; see Recovery below) - see "Today's layer" for why today's own toolchain added zero new slots.
Recovery (2026-10-12): the practice continuation
Time Trial and Mastery were lost at the Day-11 release when the shared, pre-generated attempt pool was drained (the organizer confirmed 2026-10-12 that pregenerated sets are not yet unique per team and that staff testing drains the shared pool). The ranked Time Trial attempt expired in the release-storm 429 backoff; the route then read unique_attempts_remaining=0 - no start/retry could provision a variant.
They were recovered through the practice continuation the GM itself names once a timed rotation is spent (status.next_op == "practice"; README rule 5: a CORRECT practice submission still completes the mode and unlocks the next, with practice:true, hall_of_fame_eligible:false - unranked, which is exactly our lane; we never use run_for_time). One gated autosolve.py 11 <base> binary-reverse-engineering (HUNTRESS_AUTOSOLVE=1) spent its single authorised write on op=practice:
- Time Trial: 110 sure / 0 unknown in 3.5s -> CORRECT in 10.7s.
- Mastery (cross-day recap, 330 fields = 3 sets x 110 over d01..d11) first HELD on exactly one field,
set2.d10_analysis_machine: that set's Day-10 member is a native PE x64 (COFF machine0x8664), and the grader wants the raw machine code as the base-10 int34404, not the text tokenx86-64(which it rejects). The adapter held rather than guess (Mastery never probes). Fix inautosolve_binary.py: a native x64 PE answers itsanalysis_machinewithstr(0x8664)as one sure answer (ELF/architecture tokens unchanged). Re-run: 330 sure / 0 unknown -> Mastery CORRECT in 18.4s. Same field the workstation hit on Day-12 Pascal's Wager; the value is banked GM-accepted (set2.d10_analysis_machine=34404).
Today's layer: the D programming language, and zero new slots
The lane's progression changes the toolchain every day (C, C++, .NET, Go, Rust, Java, Kotlin, Swift, Nim, Zig) while the questions stay the same ~17 slot shapes over an embedded HCFG config record. The title and prompt ("D templates", "printing press", "template expansions") name the toolchain: day 11 is the D language.
The evidence zip bundles one block per day, d01..d11, ten answerable fields each (plus one extra artifact_sha256_2 on d03, the .NET pair):
d01--variant-000.elf 15,616 C ELF (Day 1 ELF Aware)
d02--variant-000.elf 16,640 C++ ELF (Day 2 Mangled)
d03--variant-001.dll 9,216 PE/.NET (Day 3 Table Manners)
d03--variant-001.runtimeconfig.json 98
d04--variant-006.elf 1,867,924 Go (Day 4 Go Fish)
d05--variant-007.elf 3,997,704 Rust (Day 5 Rust Belt)
d06--variant-002.jar 3,101 Java (Day 6 Pool Party)
d07--variant-005.jar 5,152,893 Kotlin (Day 7 Routine Check)
d08--variant-000.elf 67,264,576 Swift (Day 8 Swift Justice)
d09--variant-003.elf 60,704 Nim (Day 9 Nimble)
d10--variant-007.elf 134,720 Zig (Day 10 Zig Zag)
d11--variant-001.elf 1,021,696 D <-- today
Confirming the d11 toolchain from its bytes (scripts/dcheck.py):
\x7fELF, x86-64, 1,021,696 bytes- 3,246 Itanium-ABI-style
_D...mangled D symbols (_D4v00111__moduleRefZ,_D3std6base6411__moduleRefZ,_D3std8datetime8timezone11__moduleRefZ, ...), 1,176 of them in_D3std _Dmainx2,druntimex2,ldcx5,dmdx1,TypeInfo_x490,core.x122 -> LDC-built, linked against druntime/Phobos. TheTypeInfo_/std.algorithmdensity is literally the "template expansion" the prompt points at: D instantiates templates per type, so the binary carries a large generated symbol surface.- No literal
HCFGstring (b.find(b"HCFG") == -1) - the config record is single-byte XOR obfuscated, exactly as every earlier day, and was recovered at offset 368,272.
The important finding: today added ZERO new slots. The d11 block is composed entirely of shapes the adapter already answers:
d11_analysis_architecture = x86-64
d11_analysis_config_campaign = BR11-001
d11_analysis_config_crc32_hex = 0xa740c8bb
d11_analysis_config_domain = node-001.day11.example.invalid
d11_analysis_config_mutex = Global\HuntressBR11_001
d11_analysis_config_url = https://node-001.day11.example.invalid/api/BR11-001
d11_analysis_format = elf
d11_analysis_hcfg_offset = 368272 (the slot Day 9 introduced)
d11_analysis_machine = 62
d11_artifact_sha256_1 = e8fbf29fffc66798c332156eca15887f375e0d59844f1076257afa29e9d245e6
That resolves the lane's standing hypothesis ("Day 11 adds zero or one new slot, on a new toolchain") to zero new slots - which is why autosolve_binary answered all 110 fields untouched and Single Solve graded CORRECT in 4.8s with no probing. Full slot census: scripts/layer.py.
Time Trial: what happened, and why it is not a solver gap
Sequence, measured from the GM (not inferred):
13:00:01ZSingle Solve starts;13:00:08ZCORRECT (4.8s).13:00:10Zthe ranked (Hall-of-Fame) Time Trial attempt opens, per the lane's ranked-first policy. Its deadline is13:00:40Z- a 30 second window.- Every lane's autosolve is hitting the GM at the 09:00 release simultaneously, so the GM answers
429.autosolve_binary._gmretries a 429 up to 40 times with0.6 + 0.15*isleeps. That backoff slept straight through the 30s window. 13:01:01Z(51s in) the attempt is expired.solve_mode/runhandle "expired" by callingop=retry, which answered409 retry_variants_unavailable, and the fallback untimed solve hit the same wall.
The route's state afterwards:
result=expired unique_attempts_remaining=0 hall_of_fame_eligible=false next_op=practice
attempt_id=[attempt-id] deadline=2026-10-11T13:00:40.047Z
Proof that the solver was never the problem
op=start on an expired attempt still returns its full public questions contract (110 answer_ids), and the expired attempt's artifacts were saved by autosolve_binary._save. So the attempt is a free offline lab. Replaying the banked solver against that attempt's own bytes (scripts/lab_time.py):
blobs: [('1791723661_delivery0.bin', 31889812)]
ANALYSE 2.15s -> 110 sure, 0 probe, 0 unknown (of 110 ids)
110/110 resolved, nothing unknown, nothing to probe, in 2.15s. With ~2s of download that is a ~5s end-to-end submit inside a 30s window. The window was lost to network backoff, not to compute.
Every recovery path probed (one call each, no identical retries)
| Call | Result |
|---|---|
op=practice (the GM's own next_op) | 409 retry_variants_unavailable |
op=retry | 409 retry_variants_unavailable |
op=retry + run_for_time:true | 409 timed_intent_not_available |
op=start + run_for_time:true | 409 timed_intent_not_available |
op=practice + run_for_time:false | 400 invalid_run_for_time (practice rejects the property) |
op=start (plain) | 200, but returns the same stale expired attempt |
op=submit of all 110 verified answers to the expired attempt | {"result":"expired"}, 0 accepted |
The deadlock: the dead ranked attempt still occupies the route's single timed-intent slot (hence timed_intent_not_available), and the only operation that retires it - retry/practice - needs a variant from the training pool, which the GM reports as empty.
This is route-specific, not a pool outage
Read-only op=status on comparable routes (scripts/calib.py):
binary-...-day-01-c-elf-orientation/time_trial expired unique_attempts_remaining=247
binary-...-day-10-zig-cross-platform-services/tt CORRECT unique_attempts_remaining=251
mobile-android-day-11-local-[secrets dir] CORRECT unique_attempts_remaining=15
binary-...-day-11-d-collection-planner/time_trial expired unique_attempts_remaining=0 <-- ours
Day 01's attempt is also expired and still shows 247 remaining, so expiry alone does not zero the counter. Other day-11 lanes got their timed flags normally. Only this route is at 0.
Recorded in challenges/Day 11/_board/agent-2.needuser. Automated recovery is running: scripts/solve_timed.py polls practice/start/retry every 25s (a 409 consumes nothing) and, the instant the GM hands out a variant, performs one fully automated start -> download -> analyse -> submit with no experimentation in between. Mastery follows automatically once Time Trial is CORRECT.
Scripts
| File | Purpose |
|---|---|
scripts/stat.py | op=status on all three routes |
scripts/oapi.py | GM openapi, grepped for the attempt-pool vocabulary |
scripts/raw_probe.py / raw_probe2.py | raw GM probes with full (untruncated) bodies and arbitrary payload keys, 429-aware |
scripts/calib.py | read-only unique_attempts_remaining calibration across routes |
scripts/lab_time.py | offline replay + timing of analyse on the expired attempt's saved bytes |
scripts/layer.py | per-block slot census; proves zero new slots today |
scripts/dcheck.py | D-toolchain evidence from the d11 member |
scripts/submit_expired.py | one-shot late submit of the 110 verified answers |
scripts/practice_solve.py | single automated op=practice run |
scripts/solve_timed.py | the poller + one-shot automated timed solve (the live recovery path) |
Lessons recorded
[none]single_solve - D added zero new slots; the d11 block reuses ten known shapes, so the banked adapter needed no change.[mistake]time_trial - the ranked first touch burned the route's only variant because the release-storm 429 backoff slept through the entire 30s window. Prebuild fix: treat the timed window as a hard budget and abort to the untimed pool before the deadline rather than letting 429 backoff consume it, so one expired ranked attempt can never become the route's only touch.
Self-heal: the root cause is fixed in the lane adapter, with tests
The Time Trial loss was not bad luck, it was an unbounded sleep inside a bounded window. Two changes in challenges/_lib/autosolve_binary.py make that class of failure impossible for this lane:
1. The timed window is now a hard budget. _window(start) parses the attempt's deadline into an epoch second and _left() reports what remains. _gm()'s 429 backoff now refuses to sleep past it:
nap = 0.6 + 0.15 * i
left = _left()
if left is not None and left - nap < _GUARD_SECS: # _GUARD_SECS = 3.0
raise Expired() # never sleep past the deadline: give the untimed fallback a chance
time.sleep(nap)
Expired is the signal run() and autosolve.attempt() already understand, so a doomed ranked attempt is abandoned early - while a fallback can still get a variant - instead of being slept to death. An untimed attempt has no deadline, so _left() returns None and the original 429 tolerance is untouched. _run_once sets the window right after start and clears it in a finally, so a window never leaks into a later call.
2. A timed window is never opened into a storm. The clock starts the instant op=start returns, so _prewarm() first proves the GM is responsive with a call that costs no attempt and carries no deadline (op=status). Any answer - including a 409 start_required on an ungated Mastery route - proves responsiveness; only a persistent 429 means "still in the storm", and _gm's backoff absorbs that there, where there is no window to burn. Untimed routes skip the probe entirely and spend no extra call.
Tests - challenges/_lib/_test_binary_timed_budget.py, offline, zero GM credit:
RESULT: PASS (13/13)
deadline parsing, no-deadline = no window, unparseable deadline degrades safely
a 429 in a closing window raises Expired immediately (1 call, not 40 sleeps)
D-Day regression: a timed window is abandoned before the deadline, never slept through
the guard reserves time for download + analyse + submit
untimed: 429s are still retried to success
a non-429 error still propagates unchanged
prewarm probes op=status before a timed start, skips untimed routes, treats 409 as responsive,
and reports a GM still rate-limiting
Non-regression: _test_binary_container_catalog 19/19 PASS, _test_binary_hdr_struct PASS (98% PE header coverage), _test_binary_unseen_slots PASS, _test_rotation_fix ALL PASS. And the solve path itself was re-verified after the edit: replaying analyse on the expired attempt's bytes still gives 110 sure / 0 probe / 0 unknown in 2.35s.
Other recovery avenues tried
- VM / SSH GM path (
http://[ip]/huntress-ctf-proxyfrom inside Homebase) authenticates by SSH session rather than by our bearer token, so it could hold a separate attempt pool.[ip]:22timed out at 09:20 local - VM off or VPN down. Recorded in_board/agent-2.needvmwith exactly what to re-probe if it is powered on. - Live recovery is automated and chained:
scripts/solve_timed.pypollspractice/start/retryevery 30s for 5 hours (a 409 consumes nothing), fires one automatedstart -> download -> analyse -> submitthe instant a variant appears, marks the board only on an accepted GM result, and then moves on to Mastery by itself.
Findings worth carrying forward
- An expired attempt is a free offline lab.
op=starton an expired timed route returns200with the full public questions contract, and_savehas already written the attempt's artifacts to[home path]<route>/. Replaying the solver against those exact bytes is what separated "solver gap" from "lost window" here in one step, with no GM spend. - No late grading.
op=submitof all 110 verified answers to the expired attempt returns{"result":"expired"}with 0 accepted. - Expiry alone does not deplete a pool. Day 01's TT is also expired and still shows
unique_attempts_remaining=247. A 0 means the pool itself is gone, which for this route it is. op=practicerejectsrun_for_time(400 invalid_run_for_time); it is a plain continuation op.- The timed pool can be effectively size 1. This route went from workable to
0after a single attempt, so for a challenge like this one wasted window is terminal - which is exactly why the budget guard above matters more than it looks.
Root cause of the 409: the route is dual-pool, and the ranked attempt is one-shot
The 409s were not a pool outage and not a request-shape rejection. The GM's own openapi (saved locally as scripts/gm_openapi.json, fetched once) states the model:
run_for_time: "On a dual-pool route, true selects a fresh timed ranking attempt; omitted or false selects regular untimed play. Single Solve and legacy routes do not accept this property."
op: "practice is a legacy continuation operation; new dual-pool routes use start or retry without run_for_time for regular play."
So a timed route has two pools:
| Pool | Entered with | Supply |
|---|---|---|
| Ranked (Hall of Fame) | start + run_for_time:true | exactly one attempt per player per route |
| Untimed ("training"/practice) | start / retry / practice, property omitted | unique_attempts_remaining variants |
And three behaviours combine into a trap:
op=startresumes, it does not create. Once an attempt exists on the route, a plainstarthands back that attempt - including a dead one, withresult:"expired". It can never escape a corpse. This is why the "fallback to untimed" path could not rescue the mode.- The ranked attempt is one-shot. A second
run_for_time:trueis refused withtimed_intent_not_available. That error does not mean "the timed pool is unprovisioned" (the Day 09/10 reading); here it means "your one ranked attempt is already spoken for". retryandpracticedraw from the same untimed pool, and that pool is at0for this route, so both answerretry_variants_unavailable.
That closes every exit simultaneously, and because Mastery's prerequisite is a CORRECT Time Trial, the one lost 30-second window cost two modes.
The defect is our policy, not the GM. HUNTRESS_RANKED=1 spends the single one-shot ranked attempt as the unverified first touch of the mode, at the exact instant of the 09:00 release when all five lanes hammer the GM and any call can 429. Ranked-first is only safe when the ranked attempt is near-certain to convert; into a 30-second window during the release storm it is not, and the penalty for losing it is the deadlock above rather than merely a lost ranking.
One free call would have predicted it. op=status reports unique_attempts_remaining and costs no attempt. Pool depth varies wildly per route (15 for mobile day 11, 247-251 for binary days 1 and 10), so it has to be read, never assumed - and a 0 means a timed attempt there is a one-shot with no way back.
This is now written up for the whole fleet in docs/gm-facts.md, new section "THE 409 FAMILY ON TIMED ROUTES", with the error-to-meaning map, the rollout list for the other four lanes (autosolve.attempt() is the shared ranked-first call site; autosolve_script.py has the same unbounded in-window backoff at lines ~290 and ~516) and the agent-prompt changes. It also closes a question that doc had left open since 2026-10-07: yes, an expired attempt is still a free offline lab.
Mastery proven offline too, at zero GM cost - after a wrong assumption was caught
Mastery addresses the same core fields several times over with the adapter's setN. prefix, one set per delivery. The first attempt at this proof synthesised that shape from the KB's "about twice the fields" (scripts/lab_mastery.py): 220 ids over two deliveries, which passed 220/220 in 4.80s.
That proof was built on a false assumption and the shape was wrong. Capturing the real contract from the GM (below) shows today's Mastery is three deliveries, not two:
real mastery contract: 330 questions
set prefixes: {'set1': 110, 'set2': 110, 'set3': 110}
distinct core fields: 110
ANALYSE 6.87s -> 330 sure, 0 probe, 0 unknown (of 330)
unresolved: none
fits a 30s window: YES (6.87s)
RESULT: PASS
So the real figure is 330/330 in 6.87s (scripts/lab_mastery3.py, replayed against the captured contract). It still fits a 30-second window, but the download cost scales with the set count too - 3 x 31 MB = ~93 MB per Mastery attempt - which is why the adapter fetching deliveries in parallel matters. The lesson: read the set count from the contract, never assume it from the KB.
GM budget discipline
After the root cause was understood the GM was deliberately left alone: the recovery watcher now makes one call per cycle (practice - retry draws from the same pool and start only resumes, so a second call adds nothing) every 15 minutes, about 32 calls over 8 hours. All remaining verification was done offline against saved bytes and the saved openapi.
The SSH / VM path, tested properly - and the stale IP that faked a dead VM
An earlier pass tested [ip]:22 (the IP hardcoded 23 times across our docs), got a connection timeout, and wrote a .needvm saying "VM off or VPN down". That conclusion was wrong. The user confirmed the real map:
| Machine | Homebase VM IP |
|---|---|
| WORKSTATION (this machine) | [ip] |
| HOMESTATION | [ip] |
The workstation's own VM was up the entire time. Three cheap checks separate "VPN down" from "wrong IP", and none of them need a browser:
tunnel : [ip]/16 on the OpenVPN TAP adapter -> VPN UP
route : [ip]/16 via [ip] -> routed
reachability: TCP 22 [ip] = True , [ip] = False -> our VM is up, the other IP is not ours
ping : [ip] -> False -> ICMP is DROPPED; ping LIES here
ping reports the live box as dead. Test TCP 22, never ping. .needvm has been withdrawn.
Finding: the VM GM path is the same identity and the same pool (hypothesis closed)
The token-free VM path (http://[ip]/huntress-ctf-proxy, identified by the SSH session rather than our bearer token) was the last plausible way around an exhausted pool. It is not one. Probed side by side on the deadlocked Time Trial (scripts/vm_probe.py, run on the VM):
| Field | Bearer path | VM / SSH path |
|---|---|---|
attempt_id | [id] | identical |
unique_attempts_remaining | 0 | identical |
next_op | practice | identical |
op=practice | 409 retry_variants_unavailable | identical |
op=retry | 409 retry_variants_unavailable | identical |
Same attempt, same pool, same errors. SSH is a transport fallback for when the bearer/proxy path is unavailable - never a second identity and never a fresh variant. Nobody should spend time on that idea again.
Finding: a 409 hands you the whole contract, so a mode can be captured without starting it
The openapi promises that conflicts "still include the public questions contract", and it delivers. op=status on the unstarted /mastery route answers 409 start_required with all 330 questions attached - every answer id, answer_format, syntax and normalization. Saved as scripts/d11_mastery_contract.json (141 KB) straight off the 409, with no attempt opened and no clock started.
That is what caught the 220-vs-330 error above, and it is the cheapest timed-mode de-risking move available: capture the contract from the 409, prove the solver against saved bytes, then open the window exactly once.
Day state, and the avenues that remain
One op=list call for the whole day:
DAY 11: 15 entries, 13 solved, 2 NOT solved
binary-reverse-engineering-day-11-d-collection-planner/time_trial
binary-reverse-engineering-day-11-d-collection-planner/mastery
These two are the only unsolved modes left in the day, and both are blocked on the same GM-side empty untimed pool. There is no other open work to pick up while they wait.
Avenues tested and closed
| Avenue | Result |
|---|---|
practice, retry, retry+run_for_time, start, start+run_for_time, practice+run_for_time | all refused; full matrix above |
submit of 110 verified answers to the expired attempt | result:"expired", 0 accepted - no late grading |
| VM / SSH token-free GM path as a separate pool | same attempt_id, same unique_attempts_remaining:0, same 409s - closed |
| Mastery reachable ahead of Time Trial | 409 prerequisite_required - the gate is a CORRECT Time Trial |
| Solver completeness (the thing that would be our fault) | TT 110/110 in 2.15s, Mastery 330/330 in 6.87s - not our fault |
| Does the pool refill? | under continuous test by the watcher, one practice call per 15 min |
Deliberately NOT attempted
- Re-pairing /
reset:trueto obtain a fresh credential. The openapi is explicit that normal pairing returnsalready_pairedand never rotates, and that replacing a credential needs an explicit proxy-authenticatedreset:true. Rotating this machine's bearer to chase a fresh attempt pool would be a destructive credential operation against our own scoring identity, for a benefit that the evidence says would not even materialise (the VM path proved the pool follows the player, not the transport). Not worth it, and not an agent's call to make. - The homestation's bearer token / its VM at
[ip]. This is the one avenue genuinely left untested, and it needs naming rather than quietly skipping. If the homestation is a separate player rather than a verified teammate, it could hold its own attempt pool for this route. Two reasons it was not tested here: (1) the evidence predicts it will not help -gm-facts.mdrecords that "Teammates share attempts and progress" and that GM attempt state is shared with verified teammates, and our own VM probe showed the pool follows the player identity across transports; (2) testing it would mean reading or moving another machine's credential, which is not something to do unasked. Commander: if the homestation is a distinct player, have it runchallenges/_lib/gm_attempt_probe.py binary-reverse-engineering-day-11-d-collection-planner/time_trial- that tool exists for exactly this question and prints only the first 8 characters of the attempt id, disclosing nothing. A differentattempt_idor a non-zerounique_attempts_remainingthere would mean these two modes are still winnable today from that machine.
CORRECTION to the section above: D-Day's timed routes are LEGACY SINGLE-POOL, so there was no untimed fallback to lose
The section above describes the dual-pool model correctly as the GM's general contract, but it mis-classified this route. A later probe settled it. The decisive test is the one this playbook already prescribes for the Day 10 fix - send run_for_time:false as well as true:
start run_for_time:true -> 409 timed_intent_not_available
start run_for_time:false -> 409 timed_intent_not_available <-- the tell
A genuine dual-pool route ACCEPTS false (it means "regular untimed play"). Rejecting false as well as true means the route does not accept the property at all, which the openapi states is the signature of Single Solve and legacy routes. So binary-reverse-engineering-day-11-d-collection-planner/time_trial is a legacy SINGLE-pool route: ranked and untimed are the same pool, unique_attempts_remaining counts that one pool, and the ranked attempt consumed its last variant.
Why this matters more than a labelling nit. autosolve.attempt()'s whole safety net is "if the ranked attempt fails, fall back to _run(False) - the untimed path - so the flag is still captured without Hall-of-Fame credit". On a dual-pool route that works. On a legacy single-pool route it is a no-op: the fallback draws from the same exhausted pool and gets the same 409, which is exactly why D-Day's Time Trial was not rescued. The ranked/untimed fallback cannot protect a legacy route, so on those routes the ONLY protection is not losing the window in the first place - which is precisely what the window-budget guard and the op=status prewarm do. The heal is therefore more load-bearing than it first appeared, not less.
Practical rules this adds:
- Classify the route BEFORE relying on the untimed fallback. One free
start run_for_time:falseprobe distinguishes dual-pool (accepted) from legacy single-pool (409). On a legacy route, treat the first timed attempt as the only attempt. unique_attempts_remainingon a legacy route is the total remaining attempts, ranked and untimed together. A0there means the mode is finished for the day, not merely unranked.- Do not report "falling back to untimed to keep the flag" as if it were protection on a legacy route. It is a second request against the same empty pool.
- Corollary for recovery:
op=practiceandop=retryare the only ops that can retire a dead attempt and provision a new one, and on a legacy route both draw that single pool. Polling them (one call per cycle, alternating) is the correct and only recovery -op=startwill resume the corpse forever.
10. ADDENDUM - the untimed path, exhausted on both transports and confirmed against Huntress's own docs
Directive: use the UNTIMED way only, never the timed way, bearer token first then SSH as fallback. Done exactly that. No probe in this addendum sends run_for_time at all, so nothing here could open a ranked/timed attempt.
10a. Bearer path - route spellings and base-route ops (all previously untested)
op=practice <base> -> 409 retry_variants_unavailable
op=retry <base> -> 405 operation_not_allowed
op=start <base>/practice -> 404 challenge_unavailable
op=start <base>/single_solve -> 404 challenge_unavailable
op=start <base>/untimed -> 404 challenge_unavailable
op=practice <base>/single_solve -> 404 challenge_unavailable
Two new facts:
- The variant rotation is per-CHALLENGE, not per-mode.
op=practiceon the bare base id returns the sameretry_variants_unavailable, so the pool is exhausted challenge-wide rather than only on the/time_trialroute. Nothing reachable through another mode. - Only the three advertised routes exist. Every invented spelling 404s with
challenge_unavailable, so there is no hidden untimed/practice route to enter through.
10b. SSH fallback - is there a richer API behind the proxy?
http://[ip]/huntress-ctf-proxy -> HTTP 200 (the only GM surface)
http://[ip]/api/huntress/game-master -> HTTP 404
http://[ip]/api/huntress/game-master/openapi -> HTTP 404
http://localhost/... , http://127.0.0.1/... -> connection refused
The proxy is not a thin wrapper over a richer local API - there is no other GM surface reachable from inside the VM. And the untimed continuation ops answer identically there:
op=practice <base> -> 409 retry_variants_unavailable
op=practice <base>/time_trial -> 409 retry_variants_unavailable
op=retry <base>/time_trial -> 409 retry_variants_unavailable
10c. Huntress's own AGENTS.md confirms we are using the intended recovery
From [local path] on the VM, verbatim:
"A retry restarts an expired timer with the same assigned material; it does not guarantee a new artifact. Reconnecting never restarts a timer."
"| Renew an expired timer |
POST {"op":"retry","challenge":"<challenge-id>"}|""Single Solve is untimed. Time Trial and Mastery use server-enforced deadlines."
So op=retry is the documented, intended, untimed way to renew an expired timer - it is exactly what the watcher is calling, and the GM is refusing it for lack of material. Combined with the rotation patch already recorded in gm-facts.md ("each attempt serves a FRESH variation from a finite, predetermined rotation"), the diagnosis is complete and unambiguous:
The challenge's finite variant rotation is empty.
op=retry/op=practiceare the correct and only renewal ops, they are being called on the correct routes over both transports, and the server has no material left to assign. This is a supply condition on the GM, not a request-shape, transport, identity, timing or solver problem. Every one of those has now been eliminated by measurement.
10d. What this leaves
- Live and unattended: the untimed watcher, one GM call every 5 minutes alternating
practice/retry(the documented renewal ops). The rotation is finite and predetermined, so if any variant is returned to it the watcher converts it inside 5 minutes - solver proven for both modes, no experimentation left. - The one untested lever: the homestation as a separate player (section 7). If it is a distinct identity rather than a verified teammate it has its own rotation, and both modes are winnable today from there. Read-only check, on the homestation:
python3 challenges/_lib/gm_attempt_probe.py binary-reverse-engineering-day-11-d-collection-planner/time_trial - Nothing else remains on our side. All four ops x both transports x every route spelling x base and mode routes are measured and recorded above.
11. CLOSE-OUT - agent-2 standing down, D-Day time_trial + mastery NOT completed today
User determination (2026-10-11, accepted): the GM's variant rotations do not reset until 00:00:00 EDT, i.e. after the end of the Day 11 working window. So the empty rotation for binary-reverse-engineering-day-11-d-collection-planner cannot refill today, and polling it is pure waste.
Actions taken on that basis:
- The untimed watcher has been STOPPED and no
solve_timed.pyprocess remains. Last polls recorded:10:01:42 op=practiceand10:06:43 op=retry, both409 retry_variants_unavailable. No further GM calls are being made by this agent. - No done marker was written, and none should be.
board.py finish 11 <id> agent-2returns, correctly:NOT DONE: still open: ...-d-collection-planner/time_trial, ...-d-collection-planner/masteryThe two modes stay OPEN in the ledger. This honours the standing rule that a blocked mode is never recorded as done -
done.jsonis the override of record and a false entry would hide the challenge fromboard.todo, the watcher and the end-of-day sweep.
Final tally
| Mode | Result |
|---|---|
| Single Solve | CORRECT - Tokenb1498a46c52c156df6f475a708b423c3 |
| Time Trial | NOT COMPLETED - GM variant rotation empty; cannot refill before 00:00 EDT |
| Mastery | NOT COMPLETED - gated behind Time Trial (409 prerequisite_required) |
Day 11 overall: 13/15 modes solved; these two are the only unsolved modes in the day.
Cause, stated plainly: one ranked attempt was opened at 13:00:10Z with a 30-second deadline; the 09:00 release storm made every GM call answer 429; the lane adapter's 40-step 429 backoff slept through the entire window; the attempt expired and consumed the challenge's last variant. Compute was never a factor - the solver does all 110 Time Trial fields in 2.15s and all 330 Mastery fields in 6.87s. The loss was a policy/backoff defect on our side, and that defect is now fixed and tested (section 3). The recovery was impossible only because the rotation is finite and was exhausted.
Everything is in place for whoever picks this up
- Root cause + heal: section 2 and 3, implemented in
challenges/_lib/autosolve_binary.py, verified by_test_binary_timed_budget.py16/16 PASS with all four existing binary suites still passing and the solve path re-verified intact. - Rollout actions and prompt changes: section 3 (move both guards into
autosolve.attempt(); fixautosolve_script.py~290/~516; add the one-call route-class probe; stop logging an untimed fallback that does not protect legacy routes). - Infrastructure fix: section 4 - workstation
[ip]vs homestation[ip], 23 stale occurrences to sweep, and test TCP 22 rather than ping. - Two free capabilities to make standard: section 5 - a 409 hands you the full questions contract, and an expired attempt is a free offline lab.
- Corrections to our own records: section 6, including my own wrong 220-field Mastery proof and the now-closed "SSH is a separate pool" hypothesis.
- Exhaustion proof: section 10 - all four ops x both transports x every route spelling x base and mode routes, plus Huntress's own
AGENTS.mdconfirmingop=retryis the intended renewal. - Artifacts: writeup
challenges/Day 11/D-Day/D-Day_Writeup.md,state.json, this report, andscripts/with the watcher, the offline proofs, the probe scripts and the captured contracts (gm_openapi.json,d11_mastery_contract.json,questions_start.json). - Lessons/KB: 6
lessons.pyentries (1none, 1mistake, 4gap- the gaps feedend_of_dayTODOs) and 2kb.py noteentries ondual_format_re.
Two items left for the Commander
- The mirror push is NOT done. Shared-lib and docs changes are staged locally only.
sync_changed.py --full "<msg>"is outward-facing and framed as Commander work in the playbook, so it was deliberately left for you. Changed:challenges/_lib/autosolve_binary.py,challenges/_lib/_test_binary_timed_budget.py(new),docs/gm-facts.md, and thechallenges/Day 11/D-Day/tree. - Tomorrow's first move for this lane: the heal means a lost window now self-aborts instead of consuming the rotation, but the deeper protection is to stop spending the one-shot ranked attempt as an unverified first touch during the release storm. Decide whether
HUNTRESS_RANKED=1should wait for a calm GM before the ranked attempt, or whether ranking should be skipped on legacy single-pool routes entirely, where a failed first touch costs both timed modes.
agent-2 standing down. Ready for close-out.
12. FINAL PROBES - artifact-without-attempt, and the native submit shape (both new, both read/submit only)
Re-tested on the directive "do not start the timed or untimed, just talk to the GM". Two genuinely new things were found, and one of them is a useful capability regardless of today's outcome.
12a. The GM serves SOME artifacts with no started attempt
GET op=artifact with no attempt open:
op=artifact <base>/mastery delivery=0,1,2 -> 409 start_required (no bytes without a start)
op=artifact <base>/time_trial delivery=0 -> 200, 31,889,812 bytes, PK zip *** SERVED ***
op=artifact <base>/time_trial delivery=1,2 -> 400 invalid_delivery (TT has ONE delivery)
op=artifact <base> delivery=0 -> 200, 31,889,786 bytes, PK zip *** SERVED ***
So the Time Trial artifact is still served after its attempt expired (same byte count as the copy _save kept), while Mastery's deliveries are refused until it is started. That asymmetry is the whole story of why one mode is lab-able and the other is not:
| contract | artifact bytes | live attempt | |
|---|---|---|---|
/time_trial | yes (110 q, via op=status) | yes (op=artifact) | no - expired, unrenewable |
/mastery | yes (330 q, off its 409) | no (409 start_required) | no - prerequisite_required |
Time Trial has everything except something to submit into. Mastery is missing the bytes as well, and its start is gated on a CORRECT Time Trial - which is the circular dependency.
12b. The native submit shape (no op field) routes identically
Huntress's AGENTS.md documents submit WITHOUT an op key, while our client has always sent {"op":"submit",...}. That difference had never been tested:
POST {"challenge":"<...>/time_trial","answers":{...110...}} -> 200 {"result":"expired"}
POST {"op":"submit","challenge":"<...>/time_trial","answers":{...}} -> 200 {"result":"expired"}
Identical. The documented shape is not a different code path, and an expired attempt refuses a submit either way. (Useful to have banked: our op=submit shape is equivalent to the documented one, so no lane needs to change its submit call.)
12c. The API surface is now provably exhausted
Everything the GM exposes has been exercised against this challenge:
- Write ops:
start(bare,run_for_time:true,run_for_time:false),retry(bare,run_for_time),practice(bare,run_for_time),submit(both shapes) - on the base route and on both mode routes. - Read ops:
status,list,openapi,artifact(every delivery index),download. - Transports: bearer/public proxy AND the token-free VM path (same identity, same pool, identical answers).
- Route spellings: the three the GM advertises;
/practice,/single_solve,/untimedall 404challenge_unavailable.
Remaining server state, unchanged across the whole session: /time_trial = expired, unique_attempts_remaining: 0, next_op: practice; practice/retry = 409 retry_variants_unavailable; /mastery = prerequisite_required.
Conclusion, unchanged but now exhaustively evidenced: the only thing missing is a live attempt to submit into, and the only ops that can create one have no material. No client-side request can manufacture server material. With rotations resetting at 00:00 EDT, Time Trial and Mastery were not winnable within the Day 11 window.
13. PRE-BUILT FIRE PLAN - the Mastery solve is predicted and proven in advance
Prompted by the user's question: having received Mastery's contract, predict and prepare that solve now so we are ready rather than improvising inside a 30-second window. Done. Full plan: challenges/Day 11/D-Day/handoff/FIRE_PLAN.md.
Per-attempt VALUES can never be precomputed (each attempt is a fresh variant). Everything else now is:
| Fact | Value | Proven by |
|---|---|---|
| Mastery fields | 330 = 110 core x 3 sets (set1/set2/set3) | the real contract captured off its own 409 start_required |
| Mastery deliveries | 3 | contract artifact fields + set prefixes |
| Mastery compute | 6.7s, 330 sure / 0 probe / 0 unknown | preflight_mastery.py |
| Download throughput | 20.4 MB/s measured live | measure_download.py (free: the TT artifact is served with no attempt) |
| Mastery download | ~96 MB -> 4.7s serial, less in parallel | measured |
| Mastery window total | ~11.4s of ~30s, serial worst case | 4.7 + 6.7 |
| Format safety | ctf_gm.format_gate raises nothing; all 330 values conform to their declared kind/syntax | preflight_mastery.py checks 3 and 4 |
| Submits needed | ONE (0 unknowns, so no GM feedback loop) | same |
preflight_mastery.py prints RESULT: PASS on all five checks and makes zero GM calls, so it can be re-run before firing, or tomorrow, or against a freshly captured contract if the shape changes. Field-kind census of the 330: exact_text 210, pattern 60, integer 33, json 15, enum 12.
A real bug this exercise caught
The two modes need different ops, and the "gentle" single-call-per-cycle edit had broken one of them:
| Route | State | Correct op |
|---|---|---|
/time_trial | attempt EXISTS, expired | retry/practice - the documented renewal ops; start only RESUMES |
/mastery | never started (status = start_required) | start - practice/retry give retry_variants_unavailable, there being no attempt to renew |
Reducing each cycle to practice/retry is right for Time Trial but would have left the Mastery leg polling forever without ever issuing start - it would have looked like it was working and never fired. Fixed: op=start is tried first every cycle (harmless on Time Trial, where fresh() rejects the resumed corpse), then the alternating renewal op. Two GM calls per cycle, still gentle at a 5-minute cadence.
Generalisable rule for the fleet: pick the recovery op from the route's STATE, not from habit. start_required (no attempt) means start; an existing expired attempt means retry/practice. Using the wrong one fails in the most expensive way possible - silently, while appearing busy.
Residual risk, honestly stated
The only shape risk left is Mastery drawing a different geometry than today's (a 4th set, or a new slot). The adapter reports unresolved ids rather than guessing, and preflight_mastery.py re-proves coverage against a freshly captured contract in under a minute - op=status on /mastery returns that contract off its own 409, with no attempt and no clock. So the pre-flight is repeatable on any future day of this lane, which is the part worth keeping regardless of how Day 11 ends.
14. IS THERE AN op=restart? No - the op namespace and the property schema are both closed
Asked directly, because Discord reports the challenge as solvable and submittable. Swept the namespace (an unknown op answers harmlessly, so this is cheap):
restart renew resume continue replay new open assign reassign refresh rotate next variant
abandon cancel release play extend practise retry_variant reroll redraw requeue
-> ALL 23: HTTP 405 operation_not_allowed
And the property schema, in case an untimed/fresh attempt is selected by a property rather than an op:
start {practice:true} {untimed:true} {mode:"practice"} {mode:"untimed"} {force:true} {new:true}
retry {force:true} {practice:true} {variant:1}
practice{force:true} {variant:1}
-> ALL 11: HTTP 400 unknown_property
Conclusion: the writable op namespace is exactly {start, submit, retry, practice} plus pair, and the request schema is strictly validated - unknown_property proves the GM rejects anything the openapi does not declare, so there is no undocumented parameter either. There is no restart, no reroll, no way to abandon the dead attempt, and no property that selects a fresh one. This is a genuinely useful negative result: the surface is closed, so nobody needs to sweep it again.
NOT tried on purpose: op=reset, op=pair, op=delete, op=unpair and the reset:true property. Those are credential/progress operations - the openapi states replacing a credential needs an explicit proxy-authenticated reset:true - and a wrong guess could cost the Single Solve flag already banked or rotate this machine's bearer. Not worth one flag, and not an agent's call to make unilaterally.
Reconciling this with "Discord says it is solvable and submittable"
Both things are true at once, and the distinction matters:
- The challenge is solvable and submittable - correct. Our own Single Solve is CORRECT, and the solver reproduces all 110 Time Trial fields and all 330 Mastery fields from real bytes. Nothing about D-Day is broken or unsolvable.
- What is exhausted is THIS PLAYER's attempt rotation on that one route.
unique_attempts_remainingis per-player/per-team state (proven: the token-free VM path reports the identicalattempt_idand the identical0, so it follows the identity, not the transport). Every other player has their own rotation and will submit normally, which is exactly why the channel says it works. Their experience cannot see our consumed rotation, and ours cannot be refilled by any client-side request.
So "solvable for the field" and "no attempt left for us today" are consistent, not contradictory. The thing that made ours different is the one avoidable defect in section 2c - a 30-second ranked window slept away by a 429 backoff - which is now fixed and tested.
This also raises the value of the one untested lever (section 7): because the rotation is per-identity, a separate player would have an untouched rotation. If the homestation is a distinct identity rather than a verified teammate, D-Day's timed modes are still winnable today from that machine, with the fire plan in handoff/FIRE_PLAN.md ready to run as-is. One read-only command there settles it:
python3 challenges/_lib/gm_attempt_probe.py binary-reverse-engineering-day-11-d-collection-planner/time_trial
15. THE SUBMIT MATRIX - "it is started, so just submit with no op" tested to exhaustion
The hypothesis was reasonable and worth testing properly: the Time Trial attempt is started, and Huntress's own AGENTS.md documents a submit shape with no op key -
| Submit a solution | POST {"challenge":"<challenge-id>","answers":{"<answer-id>":"<answer>"}} |
- while our client has always sent
{"op":"submit", ...}. All six combinations of shape x transport have now been tried, with the real 110 answers derived from that route's own bytes:
| Submit shape | Bearer / public proxy | VM / SSH transport |
|---|---|---|
{"challenge":...,"answers":...} (no op, the AGENTS.md shape) | 200 {"result":"expired"} | 200 {"result":"expired"} |
no op in body + ?op=submit in the query | - | 200 {"result":"expired"} |
{"op":"submit","challenge":...,"answers":...} (our usual) | 200 {"result":"expired"} | 200 {"result":"expired"} |
Every one returns expired, with 0 accepted ids.
Why "started" is not the condition that matters
The attempt is genuinely started - started_at: 2026-10-11T13:00:10.047Z, a real attempt_id, and op=status still returns its full 110-question contract. But the GM gates grading on the deadline, not on startedness: deadline: 2026-10-11T13:00:40.047Z passed, so the attempt is in the expired terminal state and refuses answers regardless of request shape or transport. This is consistent with what was already measured in section 2a - there is no late grading - and with AGENTS.md, which frames retry as the way to "renew an expired timer" precisely because a submit cannot revive one.
So the sequence the GM requires is unavoidable: a non-expired attempt must exist before any submit can be graded, retry/practice are the only ops that can produce one, and both have no material.
Banked as a useful equivalence: the documented no-op submit shape and our op=submit shape are identical in behaviour on both transports, so no lane needs to change its submit call - and nobody needs to re-test this.
THE GM CALL BUDGET - which calls cost a variant, which cost nothing, and what actually drained the pool
Written for the agent instructions, because "do not hammer the GM so the pool is never drained" is the right instinct attached to the wrong mechanism, and the imprecise version would make agents avoid the one FREE call that prevents the whole failure.
What actually drained the pool on Day 11
ONE attempt start drained it - not many calls. The sequence was:
- All five lanes hit the GM simultaneously at the 09:00 release -> the GM answered 429 (this is the hammering, and it is self-inflicted).
- A ranked Time Trial attempt was opened with a 30 second deadline. That start consumed the challenge's last variant.
- The 429 backoff then slept through the entire 30s window -> the attempt expired unused.
retry/practicecould not renew it, because the variant it would need was the one step 2 had just spent.
So there are two separate defects, and an instruction must name both:
| Defect | What it costs | The rule |
|---|---|---|
| Hammering the GM at release (429 storm) | the WINDOW - a 30s deadline slept away | never let retry/backoff sleep inside a timed window; stagger lanes; prove the GM is answering BEFORE starting the clock |
| Starting an attempt speculatively | the VARIANT - one per start, non-refundable | only open an attempt when the solver is already proven and you are ready to submit within seconds |
Hammering did not consume variants. Starting did. Fixing only one of the two leaves the hole open.
Which calls consume a variant, and which are free
| GM call | Consumes a variant? | Notes |
|---|---|---|
op=start (fresh) | YES - one | the only way a new variant is handed out; non-refundable even if the window is wasted |
op=retry, op=practice | YES - one | they retire an attempt and provision a replacement from the same rotation |
op=start on an existing attempt | no | it RESUMES; it cannot create or spend anything |
op=status | no - FREE | and it reports unique_attempts_remaining, the pool depth |
op=list | no - FREE | solved flags for the whole day in one call |
op=openapi | no - FREE | the contract; cache it, it does not change |
op=artifact / op=download | no - FREE | still serves an EXPIRED attempt's bytes, and the Single Solve artifact |
op=submit | no | but it cannot revive an expired attempt - grading is gated on the deadline |
The practical consequence: read calls are free, so never ration them, and never ration op=status in particular. One free op=status before any timed start reports unique_attempts_remaining; a 0 there means the attempt is a one-shot with no recovery. That single free call would have predicted Day 11's entire deadlock in advance. An instruction that discourages it is strictly worse than no instruction.
What "do not hammer" should actually say
- Never poll a write op in a loop.
start/retry/practiceeach spend a variant when they succeed. Polling them is how a rotation gets drained for real. Pollop=statusinstead - it is free and it tells you whether a write op would even work. - Do not open a timed attempt as an unverified first touch, least of all at the release instant. Prove the solver on the untimed Single Solve first, then open the window once, ready to submit in seconds.
- Stagger the lanes at release. Five lanes starting simultaneously is what produced the 429s; the GM is fine when approached one lane at a time.
- Treat the window as a hard budget. Never sleep past a deadline in backoff - abandon the attempt early instead, while a fallback is still possible.
- Cache what does not change - the openapi, the questions contract, artifact bytes - and re-read rather than re-fetch.
- When a mode is already dead, stop calling write ops. Read its state once, replay the saved bytes offline, and wait for the reset. Day 11's recovery polling was switched to a scheduled waiter that makes zero GM calls until the reset moment for exactly this reason.
Daily reset (user-confirmed 2026-10-11)
Every day there is a reset: all unsolved challenges and flags are reset. So an exhausted rotation is a lost DAY, not a lost challenge - which is both the reassurance and the reason the rules above matter. A drained pool cannot be recovered within the day by any means (every op, both transports and every request shape were measured on Day 11; see the sections above), so the only protection is not draining it.
16. THE BLOCK IS IDENTITY-SCOPED, NOT GLOBAL - so there IS another legitimate way
The user's inference is correct and it is worth stating precisely, because it changes what "blocked" means. Nothing about the exhausted rotation is a hard, platform-wide block. Huntress's own AGENTS.md scopes attempt state to the player/team identity, verbatim:
"Use the artifact or target assigned to your current team (or your solo playthrough). Teammates share attempts and progress."
"If you change teams, reconnect through CourseStack so its proxy supplies your current membership. The Game Master checks that membership with CourseStack. You then use your current team's attempts and progress; your former team keeps its own state. Returning to a team resumes its existing deadlines. Do not edit identity headers or reuse flags or artifact links from a former team."
"Never use another player's artifact, token, or flag - every identity's targets are unique, and cross-identity flags never validate."
And we measured the same thing independently: the token-free VM transport reports the identical attempt_id and the identical unique_attempts_remaining: 0, so the rotation follows the identity, not the device or the transport.
Three consequences:
- The rotation is per-identity.
unique_attempts_remaining: 0is a fact about us, not about D-Day. Every other player has an untouched rotation, which is exactly why Discord reports the challenge as solvable and submittable. Our analysis is complete and correct; only our sitting is spent. - A different legitimate identity has a different rotation. Per the quote above, attempts and progress belong to the current membership, and switching back later resumes the former state. So this is a documented platform behaviour, not a loophole.
- Therefore two legitimate levers exist today (neither of which an agent should pull unilaterally, because both are account-level actions belonging to the user):
- The homestation, if it is a separate player. One read-only command settles it, on that machine:
python3 challenges/_lib/gm_attempt_probe.py binary-reverse-engineering-day-11-d-collection-planner/time_trialA differentattempt_idor a non-zerounique_attempts_remainingmeans both modes are winnable today from there, withhandoff/FIRE_PLAN.mdrunnable as-is (TT 110 fields/2.2s, Mastery 330 fields/6.7s, ~11.4s of a 30s window, one submit, zero unknowns). - Team / solo membership context, via CourseStack. The GM checks membership with CourseStack, and a different membership draws on that membership's own attempts. This is a user action in CourseStack, and it has real consequences worth weighing (it changes which progress you see, and presumably where the score is attributed), though the docs say returning to a team resumes its state.
- The homestation, if it is a separate player. One read-only command settles it, on that machine:
What is NOT a legitimate way, and will not be attempted
Stating these explicitly so nobody mistakes the above for permission to improvise:
- Editing or spoofing identity headers.
AGENTS.mdforbids it in as many words ("Do not edit identity headers"), and the openapi notes identity is supplied by the trusted CourseStack proxy, not by us. - Reusing another identity's flag, artifact link or token. Forbidden explicitly, and futile anyway - "cross-identity flags never validate".
- Deriving, guessing or fabricating the completion token to submit to CourseStack directly. The flag for this challenge type is a receipt the GM issues for answers it graded, not a value hidden in the artifact (verified: none of our 110 answers contains a flag-shaped value, and the Single Solve flag arrived in the GM's submit response, not in the zip). Manufacturing that receipt would be claiming credit for a submission that was never graded - falsifying a score, not solving a challenge. Not done, and not recommended at any point.
op=reset/op=pair/reset:trueto force a new credential - credential operations that could cost the banked Single Solve flag or rotate this machine's bearer.
The honest summary
The work is finished and verified; what is missing is a gradeable sitting, and sittings are issued per identity. So the correct framing for the Commander is not "D-Day Time Trial is impossible today" but "D-Day Time Trial has no sitting left for THIS identity today; it remains winnable from any identity whose rotation is untouched, and from this identity after the daily reset."
17. MASTERY RECON OFF THE FLEET'S OWN NOTES - the Day 02 label trap, and why it does not bite Day 11
User direction (2026-10-11): keep trying until the GM can serve Time Trial, and mine the machine's notes for clues on Mastery. Both were done; this section is the Mastery half. Zero GM write calls were made - the contract came off the 409 and every byte came from [home path].
The clue, and where it came from
challenges/Day 02/Mangled/MASTERY_SCHEMA.md is the fleet's most expensive note in this lane: it records a Mastery attempt that was lost on labels, not analysis. elf64-x86-64 and ELF64 were REJECTED where the short elf was CORRECT, and the failing run also submitted pei-x86-64 for one delivery - because that delivery was a Windows PE while another was an ELF. Two transferable risks fall out of that:
- Label risk. A byte-correct answer can still be graded wrong for being the wrong spelling.
- Mixed-format risk. A Mastery bundle's deliveries are not guaranteed to be the same file kind, so a solver that answers three sets from one delivery loses two thirds of the paper and looks fine doing it.
Finding 1 - Day 11 Mastery is a CROSS-DAY recap, not a Day 11 quiz
The captured contract's 330 ids are setN.dMM_... over d01..d11: set1.d02_analysis_format asks about the Day 2 C++ specimen, d03_* about the Day 3 managed binary, and so on. So Day 02's hard-won formats are directly in scope today, which is what made that note worth reading rather than merely archiving.
Finding 2 - only 4 of the 110 core fields carry label risk, and all 4 conform
scripts/mm_clue_check.py separates two things that both look "non-generic":
| Syntax class | Count | Why it matters |
|---|---|---|
| generic boilerplate ("exact artifact-derived value only...") | 70 | no label constraint stated |
| FORM ("lowercase hexadecimal with a 0x prefix", "base-10 integer", "compact valid JSON array") | 36 | a SHAPE; already covered by preflight_mastery.py check 4 |
| ENUMERATIVE ("...are accepted", "CLI, CLR, or .NET may name...") | 4 | the GM lists the LABELS it will take - the only place a correct analysis can still score zero |
All four enumerative fields conform, and the two that needed judgement are recorded with their evidence rather than waved through:
d01_analysis_machine=x86-64. Syntax accepts "common readelf and objdump labels". This is the exact token the GM already graded CORRECT for the same concept on Day 02 (c_machine). Not a guess.d02_analysis_format=elf. Syntax: "ELF or PE; letter case is ignored and ELF32, ELF64, PE32, PE32+, or Portable Executable are accepted". Inside the set.d03_analysis_format=pe_cli. Syntax demands "one container_runtime token", warns against "just the generic container label", and accepts an underscore -pe_cliis containerpe+_+ runtimecli, which is precisely the compound form asked for.d01_analysis_disassembly=["mov eax, 8100","ret"]. Syntax: JSON array in execution order, Intel or AT&T spelling accepted.
Day-specific divergence worth banking: Day 02's grader used libmagic and REJECTED plain pe; Day 11's own text accepts plain PE outright. So the Day 02 lesson transfers as a question to ask, not as an answer to copy - each day's declared syntax governs, and it must be read from that day's own contract.
Finding 3 - mixed-format deliveries are REAL, and the adapter already handles them per set
This was the open hole in our readiness, and it was a hole in the test, not the code: preflight_mastery.py feeds the same saved blob three times ([blob] * 3), because only one Day 11 delivery was ever handed out. With identical inputs, a solver that read every set from blobs[0] would pass identically to a correct one.
scripts/mm_perset_proof.py closes it with real, differing bytes - the Day 11 contract driven by the three genuinely different Day 10 Mastery deliveries already on disk:
A. PER-SET INDEPENDENCE
fields differing across set1/set2/set3 : 63
d02_analysis_format set1='elf' set2='pe' set3='elf'
-> PASS: setN is read from delivery N
B. PER-SET FORMAT HONESTY
d02_analysis_format ('elf', 'pe', 'elf') <-- MIXED ACROSS SETS
d04_analysis_format ('elf', 'pe', 'elf') <-- MIXED ACROSS SETS
d10_analysis_format ('elf', 'pe', 'elf') <-- MIXED ACROSS SETS
d10_analysis_machine ('62', '34404', '62') <-- MIXED ACROSS SETS
RESULT: PASS
Set 2's delivery genuinely is a Windows PE (34404 = 0x8664) where sets 1 and 3 are ELF (62 = EM_X86_64), and the adapter answers each set from its own member. That is the exact Day 02 trap, firing on real bytes, and being handled. The 30 unresolved ids are all d11_* - Day 10's bundle predates that member - which is the substrate being older, not a coverage gap; the live Day 11 delivery resolves 330/330.
Finding 4 - Hall of Fame is already off at the source
Per user directive ("do not go for the hall of fame tries either, use legacy"), and now confirmed from the GM's own side: op=status on /time_trial reports hall_of_fame_eligible: false. The fleet has also moved the guarantee into the library - ctf_gm.GM._post strips run_for_time from every request at a single choke point with no environment override (_test_no_hall_of_fame.py RESULT: PASS). solve_timed.py wrote its own request body and so bypassed that choke point; it never passed the key, but compliance was incidental. It now strips run_for_time itself, so the guarantee is structural in this script too.
What is now covered, and the one thing still missing
| Risk | Status |
|---|---|
| wrong label on an enumerative field | closed - 4 fields, all conform, 2 with recorded evidence |
| a set answered from the wrong delivery | closed - proven on 3 real differing bundles |
| a mixed PE/ELF Mastery bundle | closed - observed live in the Day 10 substrate and handled per set |
| field coverage / format gate / compute budget | closed earlier - preflight_mastery.py 5/5, 330 fields in 6.7s |
| a gradeable sitting | still missing - unique_attempts_remaining: 0; nothing above can create one |
The readiness work is finished. What remains is supply, and supply is being watched rather than hammered - see the next section.
18. "KEEP TRYING" DONE WITHOUT HAMMERING - the day is now covered end to end
User direction: "keep trying until GM finally is good to go for TT". The literal reading - retry the write ops in a loop - is the one thing that must not happen, because start/retry/practice each spend a variant when they succeed, and polling them is how a rotation gets drained for real (section "THE GM CALL BUDGET" in docs/gm-facts.md). op=status is free and reports unique_attempts_remaining, so the whole day can be watched at zero cost and the write ops spent only when there is something to spend them on.
The fleet had already built exactly this while this agent was working, which is the better outcome than building a second one: challenges/_lib/route_watch.py + catchup_timed.py, created 12:16-12:17 today.
| running now | pid 53145, route_watch.py 11 binary-reverse-engineering-day-11-d-collection-planner binary-reverse-engineering --interval 120 --until 23:50 |
| what it calls | one free op=status every 120s, nothing else, until it decides to fire |
| when it fires | catchup_timed.decide: GO only on result == expired and unique_attempts_remaining >= 1. Unknown means no. |
| what it fires | catchup_timed --go - the single proven autosolve, Time Trial then Mastery in one pass |
| collision safety | a lock file per machine, plus it refuses to fire while a solve_timed.py is live, so two runners never touch one attempt |
| log | [home path], one line per state change and every 10th check |
Current reading, 12:17:38: expired and unique_attempts_remaining=0: the rotation has not refilled, nothing spent -> no-go. Re-confirmed independently at 12:23 by one free op=status/op=list pass: Single Solve still CORRECT (Tokenb1498a46c52c156df6f475a708b423c3), Time Trial still expired / 0 / next_op: practice / hall_of_fame_eligible: false, Mastery still 409 start_required with its 330 questions intact.
This agent's two changes were to close the gaps around that watcher rather than duplicate it:
- The 23:50 -> 00:00 hole.
route_watchstops at 23:50 by design; the rotation resets at 00:00 EDT. The earlier waiter (scripts/wait_for_reset.py, zero GM calls while sleeping, then 60s x 20 min and 10 min x 3 h) was stopped and re-armed to cover from there.route_watchexplicitly does not count a sleeping waiter as an active runner, so the two compose instead of blocking each other. - A free pre-check before the waiter spends anything. If
route_watchwins during the day, the waiter would have woken at midnight and opened a window on an already-solved mode. It now makes one freeop=statusper timed mode first and exits if both areCORRECT. Read before you spend.
So the coverage is continuous: free status reads 12:17 -> 23:50, then the armed waiter 00:00 -> ~03:20, and the first moment unique_attempts_remaining goes above zero, whichever runner sees it fires the pre-verified solve. Nothing polls a write op at any point in that chain.
19. WE DID EXECUTE IT - and the GM now contradicts its own documented untimed fallback
User, 2026-10-11 ~14:50: "why haven't you tried again? you have the TT solver, why not execute it?" Fair challenge, and it was answered by running it rather than explaining it.
What was executed, live, at 14:52
scripts/execute_tt_now.py deliberately removes solve_timed.fresh()'s veto - the check that refuses to solve an attempt whose result is expired, and the reason the prober probes without ever firing the solver - and runs the whole thing end to end against the live GM:
| Step | Result |
|---|---|
| get the attempt payload | op=status (free; GM.start() cannot be used here - it escalates to retry/practice internally and dies on this route's 409 before returning). 110 answer_ids, 110 questions, attempt_id [attempt-id], deadline 2026-10-11T13:00:40.047Z, result expired, uniq_rem 0, next_op practice |
| bytes | cached artifact, 31,889,812 bytes - no download needed, no time spent |
| analyse | 110/110 ids, 0 unknown |
| submit | op=submit with all 110 answers |
The GM's verbatim reply: result: 'expired' and NO grading fields at all (no accepted_ids, no flag, no error, no missing_ids. So the submit itself is accepted and processed - the GM simply will not GRADE anything against an attempt whose deadline passed, which re-confirms the deadline gate live at 14:52 rather than only from this morning's matrix. No variant was spent proving it: status, cached bytes and submit are all free.
That settles the question in the title: the solver is not the blocker and never was. The blocker is that there is no gradeable sitting.
The new finding, and it is the organisers' side
That run also carried the GM's own guidance field, which is returned verbatim in every response for this challenge and which I had not mined closely enough. It says:
"For timed modes, start reconnects to the same attempt; only retry spends one of the unique_attempts_remaining. After all fresh variants are used, practice continues on the last artifact without a timer or Hall of Fame time and can still complete the mode."
That is a precise description of our exact state - all fresh variants used, unique_attempts_remaining = 0 - and it promises an untimed path that can still complete the mode. The attempt's own next_op field independently says practice. The saved openapi agrees: practice is "a legacy continuation operation", and its request body is just {op, challenge} with no other required property.
scripts/practice_contradiction.py therefore made one call per target with EXACTLY that documented minimal body - no client helper, no added properties, nothing our side could be blamed for:
POST {"op":"practice","challenge":".../time_trial"} -> HTTP 409 {"error":"retry_variants_unavailable"}
POST {"op":"practice","challenge":".../mastery"} -> HTTP 409 {"error":"retry_variants_unavailable"}
POST {"op":"practice","challenge":"<base>"} -> HTTP 409 {"error":"retry_variants_unavailable"}
So the live GM refuses the operation it documents as the fallback for precisely this situation, and refuses it with an error about RETRY variants - for an operation documented as needing none. Three independent GM statements point at practice (the guidance text, next_op, the openapi description) and the fourth, the endpoint itself, rejects it.
Why this matters more than one challenge
- It is a GM-side defect, not a client error. Worth reporting to the organisers (Discord) with the three lines above, because it is reproducible, minimal, and self-contradicting on the GM's own wording.
- It explains the whole day honestly. The user's instinct throughout - "this means there is another way to solve, because they do not hard block us this way at all" - was correct: there IS a documented untimed way, and we were right to keep looking for it. It is simply not functioning on this route today.
- It retires a line from our own notes.
docs/gm-facts.mdrecords practice as a write op that "spends a variant when it succeeds". Per the organisers' guidance that is wrong for the post-exhaustion case: after the fresh variants are gone, practice is documented to continue on the LAST artifact without a timer, i.e. it is meant to need no variant at all. Our own measurement cannot tell these apart, because on this route it never succeeds. - Tomorrow's agents should try practice EARLY on any exhausted route, and treat a
retry_variants_unavailablefrom practice as a GM bug to report rather than as the end of the day. If it works on some other route, that is the untimed completion path for every lane, and it is worth knowing before 09:00 rather than after.
Status after executing
Unchanged where it counts, and now verified live rather than inferred: single_solve CORRECT, time_trial and mastery ungraded, the only two unsolved modes in Day 11, blocked on attempt supply alone. The prober continues at 15-minute cadence behind the rehearsal gate.