Tactical LogHuntress CTF 2026 // team archive

Days / Day 11 / Binary RE / D-Day

DAY 11//LANE: BINARY RE//STATUS: CORRECT x3

D-Day

Binary RE SSTTMM Modes reported CORRECT in this write-up

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 (password infected), 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

ModeResultDetail
Single SolveCORRECTflag Tokenb1498a46c52c156df6f475a708b423c3, 4.8s, all 110 fields accepted first submit
Time TrialCORRECTflag Token05a78034b5daf7dc070f6486932177b2, practice continuation 2026-10-12, 110/110 sure, 10.7s
MasteryCORRECTflag 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 machine 0x8664), and the grader wants the raw machine code as the base-10 int 34404, not the text token x86-64 (which it rejects). The adapter held rather than guess (Mastery never probes). Fix in autosolve_binary.py: a native x64 PE answers its analysis_machine with str(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
  • _Dmain x2, druntime x2, ldc x5, dmd x1, TypeInfo_ x490, core. x122 -> LDC-built, linked against druntime/Phobos. The TypeInfo_/std.algorithm density 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 HCFG string (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):

  1. 13:00:01Z Single Solve starts; 13:00:08Z CORRECT (4.8s).
  2. 13:00:10Z the ranked (Hall-of-Fame) Time Trial attempt opens, per the lane's ranked-first policy. Its deadline is 13:00:40Z - a 30 second window.
  3. Every lane's autosolve is hitting the GM at the 09:00 release simultaneously, so the GM answers 429. autosolve_binary._gm retries a 429 up to 40 times with 0.6 + 0.15*i sleeps. That backoff slept straight through the 30s window.
  4. 13:01:01Z (51s in) the attempt is expired. solve_mode/run handle "expired" by calling op=retry, which answered 409 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)

CallResult
op=practice (the GM's own next_op)409 retry_variants_unavailable
op=retry409 retry_variants_unavailable
op=retry + run_for_time:true409 timed_intent_not_available
op=start + run_for_time:true409 timed_intent_not_available
op=practice + run_for_time:false400 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

FilePurpose
scripts/stat.pyop=status on all three routes
scripts/oapi.pyGM openapi, grepped for the attempt-pool vocabulary
scripts/raw_probe.py / raw_probe2.pyraw GM probes with full (untruncated) bodies and arbitrary payload keys, 429-aware
scripts/calib.pyread-only unique_attempts_remaining calibration across routes
scripts/lab_time.pyoffline replay + timing of analyse on the expired attempt's saved bytes
scripts/layer.pyper-block slot census; proves zero new slots today
scripts/dcheck.pyD-toolchain evidence from the d11 member
scripts/submit_expired.pyone-shot late submit of the 110 verified answers
scripts/practice_solve.pysingle automated op=practice run
scripts/solve_timed.pythe 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-proxy from inside Homebase) authenticates by SSH session rather than by our bearer token, so it could hold a separate attempt pool. [ip]:22 timed out at 09:20 local - VM off or VPN down. Recorded in _board/agent-2.needvm with exactly what to re-probe if it is powered on.
  • Live recovery is automated and chained: scripts/solve_timed.py polls practice/start/retry every 30s for 5 hours (a 409 consumes nothing), fires one automated start -> download -> analyse -> submit the 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

  1. An expired attempt is a free offline lab. op=start on an expired timed route returns 200 with the full public questions contract, and _save has 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.
  2. No late grading. op=submit of all 110 verified answers to the expired attempt returns {"result":"expired"} with 0 accepted.
  3. 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.
  4. op=practice rejects run_for_time (400 invalid_run_for_time); it is a plain continuation op.
  5. The timed pool can be effectively size 1. This route went from workable to 0 after 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:

PoolEntered withSupply
Ranked (Hall of Fame)start + run_for_time:trueexactly one attempt per player per route
Untimed ("training"/practice)start / retry / practice, property omittedunique_attempts_remaining variants

And three behaviours combine into a trap:

  1. op=start resumes, it does not create. Once an attempt exists on the route, a plain start hands back that attempt - including a dead one, with result:"expired". It can never escape a corpse. This is why the "fallback to untimed" path could not rescue the mode.
  2. The ranked attempt is one-shot. A second run_for_time:true is refused with timed_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".
  3. retry and practice draw from the same untimed pool, and that pool is at 0 for this route, so both answer retry_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:

MachineHomebase 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):

FieldBearer pathVM / SSH path
attempt_id[id]identical
unique_attempts_remaining0identical
next_oppracticeidentical
op=practice409 retry_variants_unavailableidentical
op=retry409 retry_variants_unavailableidentical

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

AvenueResult
practice, retry, retry+run_for_time, start, start+run_for_time, practice+run_for_timeall refused; full matrix above
submit of 110 verified answers to the expired attemptresult:"expired", 0 accepted - no late grading
VM / SSH token-free GM path as a separate poolsame attempt_id, same unique_attempts_remaining:0, same 409s - closed
Mastery reachable ahead of Time Trial409 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:true to obtain a fresh credential. The openapi is explicit that normal pairing returns already_paired and never rotates, and that replacing a credential needs an explicit proxy-authenticated reset: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.md records 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 run challenges/_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 different attempt_id or a non-zero unique_attempts_remaining there 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:false probe distinguishes dual-pool (accepted) from legacy single-pool (409). On a legacy route, treat the first timed attempt as the only attempt.
  • unique_attempts_remaining on a legacy route is the total remaining attempts, ranked and untimed together. A 0 there 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=practice and op=retry are 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=start will 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:

  1. The variant rotation is per-CHALLENGE, not per-mode. op=practice on the bare base id returns the same retry_variants_unavailable, so the pool is exhausted challenge-wide rather than only on the /time_trial route. Nothing reachable through another mode.
  2. 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=practice are 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.py process remains. Last polls recorded: 10:01:42 op=practice and 10:06:43 op=retry, both 409 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-2 returns, correctly:
    NOT DONE: still open: ...-d-collection-planner/time_trial, ...-d-collection-planner/mastery

    The two modes stay OPEN in the ledger. This honours the standing rule that a blocked mode is never recorded as done - done.json is the override of record and a false entry would hide the challenge from board.todo, the watcher and the end-of-day sweep.

Final tally

ModeResult
Single SolveCORRECT - Tokenb1498a46c52c156df6f475a708b423c3
Time TrialNOT COMPLETED - GM variant rotation empty; cannot refill before 00:00 EDT
MasteryNOT 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.py 16/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(); fix autosolve_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.md confirming op=retry is the intended renewal.
  • Artifacts: writeup challenges/Day 11/D-Day/D-Day_Writeup.md, state.json, this report, and scripts/ 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.py entries (1 none, 1 mistake, 4 gap - the gaps feed end_of_day TODOs) and 2 kb.py note entries on dual_format_re.

Two items left for the Commander

  1. 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 the challenges/Day 11/D-Day/ tree.
  2. 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=1 should 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:

contractartifact byteslive attempt
/time_trialyes (110 q, via op=status)yes (op=artifact)no - expired, unrenewable
/masteryyes (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, /untimed all 404 challenge_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:

FactValueProven by
Mastery fields330 = 110 core x 3 sets (set1/set2/set3)the real contract captured off its own 409 start_required
Mastery deliveries3contract artifact fields + set prefixes
Mastery compute6.7s, 330 sure / 0 probe / 0 unknownpreflight_mastery.py
Download throughput20.4 MB/s measured livemeasure_download.py (free: the TT artifact is served with no attempt)
Mastery download~96 MB -> 4.7s serial, less in parallelmeasured
Mastery window total~11.4s of ~30s, serial worst case4.7 + 6.7
Format safetyctf_gm.format_gate raises nothing; all 330 values conform to their declared kind/syntaxpreflight_mastery.py checks 3 and 4
Submits neededONE (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:

RouteStateCorrect op
/time_trialattempt EXISTS, expiredretry/practice - the documented renewal ops; start only RESUMES
/masterynever 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_remaining is per-player/per-team state (proven: the token-free VM path reports the identical attempt_id and the identical 0, 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 shapeBearer / public proxyVM / 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:

  1. 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).
  2. A ranked Time Trial attempt was opened with a 30 second deadline. That start consumed the challenge's last variant.
  3. The 429 backoff then slept through the entire 30s window -> the attempt expired unused.
  4. retry/practice could 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:

DefectWhat it costsThe rule
Hammering the GM at release (429 storm)the WINDOW - a 30s deadline slept awaynever let retry/backoff sleep inside a timed window; stagger lanes; prove the GM is answering BEFORE starting the clock
Starting an attempt speculativelythe VARIANT - one per start, non-refundableonly 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 callConsumes a variant?Notes
op=start (fresh)YES - onethe only way a new variant is handed out; non-refundable even if the window is wasted
op=retry, op=practiceYES - onethey retire an attempt and provision a replacement from the same rotation
op=start on an existing attemptnoit RESUMES; it cannot create or spend anything
op=statusno - FREEand it reports unique_attempts_remaining, the pool depth
op=listno - FREEsolved flags for the whole day in one call
op=openapino - FREEthe contract; cache it, it does not change
op=artifact / op=downloadno - FREEstill serves an EXPIRED attempt's bytes, and the Single Solve artifact
op=submitnobut 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

  1. Never poll a write op in a loop. start/retry/practice each spend a variant when they succeed. Polling them is how a rotation gets drained for real. Poll op=status instead - it is free and it tells you whether a write op would even work.
  2. 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.
  3. 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.
  4. 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.
  5. Cache what does not change - the openapi, the questions contract, artifact bytes - and re-read rather than re-fetch.
  6. 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:

  1. The rotation is per-identity. unique_attempts_remaining: 0 is 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.
  2. 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.
  3. 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_trial A different attempt_id or a non-zero unique_attempts_remaining means both modes are winnable today from there, with handoff/FIRE_PLAN.md runnable 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.

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.md forbids 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:true to 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:

  1. Label risk. A byte-correct answer can still be graded wrong for being the wrong spelling.
  2. 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 classCountWhy it matters
generic boilerplate ("exact artifact-derived value only...")70no label constraint stated
FORM ("lowercase hexadecimal with a 0x prefix", "base-10 integer", "compact valid JSON array")36a SHAPE; already covered by preflight_mastery.py check 4
ENUMERATIVE ("...are accepted", "CLI, CLR, or .NET may name...")4the 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_cli is container pe + _ + runtime cli, 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

RiskStatus
wrong label on an enumerative fieldclosed - 4 fields, all conform, 2 with recorded evidence
a set answered from the wrong deliveryclosed - proven on 3 real differing bundles
a mixed PE/ELF Mastery bundleclosed - observed live in the Day 10 substrate and handled per set
field coverage / format gate / compute budgetclosed earlier - preflight_mastery.py 5/5, 330 fields in 6.7s
a gradeable sittingstill 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 nowpid 53145, route_watch.py 11 binary-reverse-engineering-day-11-d-collection-planner binary-reverse-engineering --interval 120 --until 23:50
what it callsone free op=status every 120s, nothing else, until it decides to fire
when it firescatchup_timed.decide: GO only on result == expired and unique_attempts_remaining >= 1. Unknown means no.
what it firescatchup_timed --go - the single proven autosolve, Time Trial then Mastery in one pass
collision safetya 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:

  1. The 23:50 -> 00:00 hole. route_watch stops 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_watch explicitly does not count a sleeping waiter as an active runner, so the two compose instead of blocking each other.
  2. A free pre-check before the waiter spends anything. If route_watch wins during the day, the waiter would have woken at midnight and opened a window on an already-solved mode. It now makes one free op=status per timed mode first and exits if both are CORRECT. 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:

StepResult
get the attempt payloadop=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
bytescached artifact, 31,889,812 bytes - no download needed, no time spent
analyse110/110 ids, 0 unknown
submitop=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

  1. 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.
  2. 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.
  3. It retires a line from our own notes. docs/gm-facts.md records 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.
  4. Tomorrow's agents should try practice EARLY on any exhausted route, and treat a retry_variants_unavailable from 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.