coordination: how forty agents shared one checkout without talking

agents on this team never message each other directly. everything one agent tells another is a file under sessions/, written by coord.py or gm.py under one advisory lock and read back by the coord.py next, check or inbox the other agent runs between steps; there is no agent-to-agent channel, no shared memory, and no machine but this one can see the files. from day 10 to day 31 a median of 40 distinct agent and process names a day wrote to the race session log, and the human counts the bus among the most important parts of the system. a race is lost in dead time (a claim nobody advances, a cause nobody posted, work on a solved task), and each rule on this page was written on a day one of the three cost seconds. the page shows the bus, its trust classes, the rules and the days that taught them, the month's traffic counted from the files, and three threads quoted from the archive.

  • 22,467intel rowsdays 3 to 31
  • 18,956confirmed rowswritten by the grader client
  • 2,677rejected rows1,889 of them on day 17
  • 724mail files476 urgent
  • 9patches offered3 applied
  • 26pivots posted14 on day 17
  • 112assists193 hand-outs from next
  • 7field families takenthe last on day 13

an intel row is one line of a sessions/intel/<base>.jsonl file; a mail is one file that survived in a mail folder; an assist is one helper on one held single, and a hand-out is each next call that assigned one; a take reserves one field family for 300 s.

the bus

who writes sessions/ and who reads it writers the bus readers parents notes and pivots; the watcher's stall, ceiling and timed-stall mail helpers takes, patches, assists, observed and idea rows, pivots lane fixers edit locks, observed rows, notes; the handlers.py save is not on the bus autopilot (auto.<lane>) claims, gaps and is-yours rows, TIMED STALL mail; reads confirmed rows gm.py, the grader client confirmed and rejected rows on every submit, the --hand note; skips rejected sessions/: the bus one flock (sessions/.lock) shared with gm.py intel/<base>.jsonl one json row per line, appended under the lock: confirmed and rejected (gm.py), observed, idea and pivot (agents), gaps (autopilot, runner) mail/<ts.us>__<from>__to__<to>.md created with O_EXCL, never rewritten: notes, takes, patches, pivots, stall and ceiling alerts; URGENT in front marks it urgent tasks.json, claims/, edit/, timed/ the board and who holds what: a claim (stale after 1200 s), a solver edit lock (120 s, kept by running edit again), a live timed attempt takes/, patches/, guess/, assists/ a field family for 300 s, a diff for the owner, the one token guesser of a label field, the helpers on a held single (two at most) seen/, agents/, pivot_alerts.json each agent's read cursors (rows, mail), liveness beats from every command, and the stall and ceiling alerts already sent coord.py next claims a task; prints its intel, findings, brief and the MAIL line coord.py check rows new since your cursor; STALL, CEILING, OWN FIRST; exit 3 once solved coord.py inbox the one command that advances the mail cursor the parent's watcher spawn --wait: exit 6 on urgent mail or a timed stall found every 5 s end-of-day archive kickoff at t-60s moves the closed day's intel, mail and cursors to archive/ logs/comp/flags.json and the solved guard gm.py writes every CORRECT here: check exits 3, gm.py refuses start, submit and probe on the tier, and the shell hook refuses the agent's next command with SOLVED: <id> was won by <agent>.

every arrow is a file write or a file read; no process holds a socket or a pipe to another. the writers reach the bus through two scripts, coord.py (claims, locks, notes, mail, takes, patches, pivots) and gm.py, the one game-master client, which writes the grader's verdicts. autopilot and gm.py read rows back as well (the two-headed arrows): a new confirmed row makes autopilot re-check whether the day's solver reproduces the graded single, and a rejected value is never sent again. the readers are the commands every agent already runs between steps, so a row one agent writes reaches the others at their next check.

under sessions/ written by read by when what it means
intel/<base>.jsonl gm.py (confirmed, rejected); coord.py intel (observed, idea); coord.py pivot; autopilot and the timed runner (gaps) next, check, intel, gaps; autopilot; gm.py guess and probe a row per verdict, note or failed run what the team knows about one base, by trust class
mail/*.md coord.py note, take, patch, pivot; the watcher; the timed runner; gm.py's --hand path inbox; next, check and the runner print MAIL n unread; the watcher wakes on urgent mail on each send, created with O_EXCL a message to one agent or to all; URGENT in front marks it urgent
tasks.json coord.py plan (kickoff's list at release) next, board, the dashboard at release, merged on a re-plan every challenge and tier of the day, with its lane
claims/ claim, next, autopilot; refreshed by heartbeat and the owner's check next, the stall sweep, done, reconcile on a claim and each refresh who owns a task; stealable after 1,200 s without a refresh
edit/ coord.py edit edit (exit 4 when held), the assist note, autopilot (holding while <fixer> edits the solver) per edit, kept by running edit within 120 s, dropped by --release or by check after a checked save one writer per solver
takes/ coord.py take <id> <family> take (refuses an overlap), check, the assist note per take, 300 s, renewable one field family held by one helper; the owner is mailed
patches/ coord.py patch <id> <file> <copy> the owner's patch-apply per patch a diff for a solver the sender may not lock; refused if the file changed since
guess/ gm.py guess --tokens gm.py guess per token sweep the one agent sweeping a label field's tokens
assists/ next (an assist hand-out) next, the pivot request per assist who co-works a held single; two helpers at most
web-handoff/ tools/comp/web_handoff.py: a web worker posts a no-proof capture packet; an advisor session takes one web_handoff.py wait (an advisor's bounded wait for a packet, 540 s by default) and web_handoff.py result (the worker's check for the plan, at most a 2 s wait) per packet: state=claimed on take, done on the advisor's reply; one queue.sqlite3 a day a saved capture's evidence handed to an advisor: the packet only, no gm call, no live target
seen/ next, check, intel, findings, inbox the same commands each call per-agent cursors: rows and mail already shown
agents/ every coord and gm command, every logged shell command, spawn, stopped the watcher, demand, spawn, gm.py's hand cap each command liveness: 300 s working, 90 s idle, 600 s for a fixer holding its edit lock
pivot_alerts.json the stall sweep the same sweep once per challenge, per state and holder for a timed tier which stall and ceiling mails already went out
findings.md coord.py finding next, findings 20 finding runs in the month grader-confirmed lessons that hold beyond one challenge
archive/day-NN/ kickoff at t-60s the end-of-day review, the telemetry once a day the closed day's mail, findings, cursors, intel and session log
../logs/comp/flags.json gm.py on CORRECT check (exit 3), gm.py (refuses start, submit, probe), the shell hook's solved guard, reconcile per flag the stop rule: a solved tier is closed to everyone

how a write lands: every read-modify-write takes sessions/.lock, an advisory flock shared with gm.py. json state goes to a temp file and is renamed into place, so no reader sees half a write; an intel row is appended under the same lock; a mail file is created with O_EXCL under a microsecond name (<ts.us>__<from>__to__<to>.md), so two notes in one second never collide and no mail is rewritten. only inbox moves an agent's mail cursor: next, check and the timed runner print MAIL n unread (...) -> coord.py inbox on every call, urgent bodies first, so a mail survives an output the agent cut with a tail.

five classes of intel

sessions/intel/<base>.jsonl holds the rows for one base, shared by its three tiers: {ts, t, agent, tier, kind, text, field?, value?, evidence?}. next prints every row when it hands out a task; check prints the rows other agents added since the caller's cursor.

class written by rows in the month what a reader does with it
confirmed gm.py, on every accepted submit 18,956 treats the value as graded: the solver must reproduce it before the tiers chain
rejected gm.py, on every single-field refusal 2,677 never sends that exact form again
observed an agent, --evidence required 645 starts from the fact and the command that read it
idea an agent 14 tests it, or leaves it as unverified
pivot coord.py pivot 26 starts fresh from the state note, with a different method
gaps autopilot and the timed runner, as observed rows 149 fixes the field and the file:line it names, from the saved run

confirmed and rejected. no agent can write either class. gm.py writes a confirmed row for every CORRECT (the whole answer, and the field with its value when one field won it: on day 3 a single was won by a probe and nobody else could see the value) and one per field of a grouped accepted; it writes a rejected row only for a single-field incorrect, because a multi-field incorrect cannot be pinned on a field. a rejected row stops a retry everywhere: gm.py guess and probe skip the value, and autopilot's bank halves a group holding it without a submit.

observed. coord.py intel <id> observed "<fact>" --evidence "<how>": a fact read from the bytes, with the command that read it. a value goes with --value, which submits every written form before the note is filed. a shape read from the answer syntax is not an observation: on day 13 an observed row said 'syntax says no braces' and the grader accepted the braces.

idea. an untested lead, printed as unverified. a rule read off rejections belongs here, never in observed: on day 17 'the enum is terse single words' went out as a pivot fact, and both graded labels had three words.

pivot. coord.py pivot <id> "<state>", five lines at most: what is confirmed, which kinds of approach failed, the current hypothesis, what has not been tried. it is an intel row and an URGENT PIVOT mail to all; it raises the field's guess cap by 25 (GUESS_CAP * (1 + pivots)); and a stalled single with fewer than two helpers goes to a fresh agent of the other runner, which starts from the pivot note, the confirmed rows and the raw artifact, not from the old reasoning. the command was in the first import (day 4); the first pivot row is day 17's.

gaps. autopilot's release pass and every failed run file a gaps row as an observed row: each failed set, the field, the forms tried, the crash with its file:line, and the saved run to replay. no gaps kind exists; the telemetry counts a row as gaps by its text, so the 149 gaps rows are counted out of the observed column above. when no reader names the field, the row becomes ... is yours, autopilot did not get it, with the question text, what was tried, the closest reader outputs and a handlers.py draft (thread three quotes one).

no unverified 'rejected'. a note may not call a value rejected unless a rejected row holds it: coord.py note warns the sender and appends [unverified: <word> never rejected in intel]. the rule dates from day 7, when a note said T1059.007 rejected before anyone had probed it and the next ten guesses avoided the right answer. a rejection steers every guesser on the base off a value, so only the grader may write one.

the rules, and the days that taught them

the runbook, AGENTS.md, carries each rule with the day that wrote it; the numbers below are its own.

rule the day what happened what it costs now
a value in hand goes to the grader before any note day 13 three agents read the ProductCode from the bytes by +44 s; each reshaped, posted or mailed it, and the stored form was submitted last, at +87 s, by the one agent that never decoded the file one gm.py guess --values command: the stored form first, every variant gm.py knows behind it; coord.py intel --value submits before it files the note
post the cause before the fix day 9 a 60 s fix waited 190 s behind two holders who never posted what they knew one coord.py intel <id> observed --evidence row; the runner posts every crashing field of a saved run as crash fields on <run> within about 20 s
once the single is won, the solver edit comes first and the note after day 15 the flag came at +62.7 s and the edit lock at +123.1 s, after an intel row and a 39 s turn; the board lost first place by 36.9 s gm.py, check and next print CHAIN WAITS ON solve.py until the tier runs; rule 0 refuses a fixer's hand guess on its own single until handlers.py exists, unless --hand says what read the value
never relay instead of submitting day 13 the braced idea sat 9 s in a mail and the value 21 s in intel the one relay left is a value mailed to a live lane fixer; gm.py stops a non-fixer's hand probes at one accepted field (exit 4)
one fix per cause day 14 five agents wrote the same caesar +7 fix; three patches went unused check <id> before any fix; a posted cause or the holder's edit lock means verify instead; coord.py patch mails the owner and patch-apply refuses a file changed since
two helpers at most on one single day 17 15 agents worked one field next hands a third helper other work; take reserves one field family for 300 s and refuses a family whose gap fields are taken
90 s without a new confirmed field is a stall; a pivot changes the method day 17 14 pivot rows lifted the guess cap for the same kind of word list, and 1,839 values were rejected check prints STALL with the most-rejected fields; a pivot is five lines, mailed to all, and buys 25 guesses a field; at 5 minutes the parent gets one CEILING mail
an owner beats an assist day 8 helpers assisted while tiers sat unowned, and the second runner's agents took them check prints OWN FIRST: <id> has no owner to an assisting agent
unread mail is announced by every command day 4, the first import only inbox advances the mail cursor, so a mail is not lost to a stderr redirect or a tail next, check and the timed runner print MAIL n unread (...) -> coord.py inbox, urgent bodies first
parents route, they do not diagnose days 19 and 28 day 19: the parent spent 40 s on a scratch PK19 unpacker while the binary fixer held the edit lock; day 28: the parent hand-probed about 25 binary fields, the single won, and its tiers waited 10m54s on CHAIN WAITS ON solve.py next gives a parent an assist on a fixer's single only after the fixer's 90 s stall, and names where a value goes (coord.py note) and where a recipe goes (coord.py patch)

the month in traffic

intel rows per day, by class
05k10k15k20k13: confirmed 2263: rejected 4503: observed 83: gaps 13: idea 734: confirmed 1584: rejected 304: observed 105: confirmed 3575: observed 45: gaps 256: confirmed 1026: rejected 56: observed 56: gaps 37: confirmed 2467: rejected 147: observed 57: gaps 278: confirmed 4818: rejected 298: observed 138: gaps 39: confirmed 1229: observed 59: gaps 2910: confirmed 12010: rejected 110: observed 810: gaps 210: idea 111: confirmed 211112: confirmed 2112: observed 312: gaps 113: confirmed 2113: rejected 513: observed 613: gaps 21314: confirmed 5814: rejected 8514: observed 1414: gaps 215: confirmed 17815: rejected 2315: observed 315: gaps 21516: confirmed 2716: rejected 4416: observed 116: gaps 117: confirmed 1.2k17: rejected 1.9k17: observed 4317: gaps 617: pivot 141718: confirmed 2018: observed 318: gaps 119: confirmed 24219: observed 1319: gaps 21920: confirmed 26920: rejected 220: observed 2220: gaps 1720: pivot 121: confirmed 26621: observed 1621: gaps 821: idea 22122: confirmed 13222: rejected 2222: observed 522: gaps 422: pivot 323: confirmed 11k23: rejected 3023: observed 1923: gaps 1523: pivot 12324: confirmed 2524: observed 1524: gaps 725: confirmed 2625: observed 1625: gaps 825: pivot 22526: confirmed 34226: observed 1926: gaps 1026: pivot 127: confirmed 3027: observed 2627: gaps 1527: idea 227: pivot 12728: confirmed 2.4k28: rejected 2828: observed 2328: gaps 829: confirmed 3029: rejected 129: observed 1329: gaps 929: pivot 12930: confirmed 44830: rejected 1230: observed 30930: gaps 730: idea 130: pivot 131: confirmed 53531: rejected 731: observed 1831: gaps 931: idea 131: pivot 131
  • confirmed
  • rejected
  • observed
  • gaps
  • idea
  • pivot

gaps rows are observed rows whose text carries the gaps summary, split out of observed so no row counts twice. days are the et date of each row's own stamp.

observed, gaps, idea and pivot rows per day
012525037550013: observed 83: gaps 13: idea 734: observed 105: observed 45: gaps 256: observed 56: gaps 37: observed 57: gaps 278: observed 138: gaps 39: observed 59: gaps 2910: observed 810: gaps 210: idea 11112: observed 312: gaps 113: observed 613: gaps 21314: observed 1414: gaps 215: observed 315: gaps 21516: observed 116: gaps 117: observed 4317: gaps 617: pivot 141718: observed 318: gaps 119: observed 1319: gaps 21920: observed 2220: gaps 1720: pivot 121: observed 1621: gaps 821: idea 22122: observed 522: gaps 422: pivot 323: observed 1923: gaps 1523: pivot 12324: observed 1524: gaps 725: observed 1625: gaps 825: pivot 22526: observed 1926: gaps 1026: pivot 127: observed 2627: gaps 1527: idea 227: pivot 12728: observed 2328: gaps 829: observed 1329: gaps 929: pivot 12930: observed 30930: gaps 730: idea 130: pivot 131: observed 1831: gaps 931: idea 131: pivot 131
  • observed
  • gaps
  • idea
  • pivot

the four classes agents, autopilot and the timed runner write; the grader client's confirmed and rejected rows are on the chart above.

mail files per day
025507510012: mail 253: mail 503: urgent 234: mail 84: urgent 555: mail 55: urgent 1056: mail 16: urgent 177: mail 27: urgent 2978: mail 28: urgent 449: mail 89: urgent 5910: mail 410: urgent 61112: mail 112: urgent 113: mail 613: urgent 11314: mail 2014: urgent 181516: urgent 317: mail 617: urgent 211718: urgent 119: mail 119: urgent 31920: mail 2320: urgent 4921: mail 721: urgent 62122: mail 522: urgent 823: mail 323: urgent 372324: mail 824: urgent 1325: mail 325: urgent 122526: urgent 2227: mail 627: urgent 452728: mail 628: urgent 1729: mail 1029: urgent 212930: mail 3330: urgent 631: mail 531: urgent 2431
  • mail
  • urgent

a mail is a file that survives in a mail folder: the archives for days 11, 15 and 18 hold none. urgent is a body that starts with URGENT or a file name with urgent in it.

who sent the mail, and to whom
sent bysent by: parent 257 (35%)35%sent by: helper 208 (29%)29%sent by: lane fixer 30 (4%)sent by: autopilot 56 (8%)8%sent by: web autopilot 46 (6%)6%sent by: web worker 46 (6%)6%sent by: reviewers and machinery 81 (11%)11%addressed toaddressed to: parent 348 (48%)48%addressed to: helper 164 (23%)23%addressed to: lane fixer 22 (3%)addressed to: autopilot 9 (1%)addressed to: web worker 57 (8%)8%addressed to: broadcast 101 (14%)14%addressed to: reviewers and machinery 23 (3%)
  • parent
  • helper
  • lane fixer
  • autopilot
  • web autopilot
  • web worker
  • reviewers and machinery
  • broadcast

broadcast is mail to all. a parent's watcher writes its stall mail under the parent's own name, so part of the parents' sends are the machinery's.

the fields with the most rejected rows:

field lane day rejected rows
d12_analysis_hcfg_storage binary 17 1,019
d14_analysis_hcfg_storage binary 17 784
d03_analysis_format binary 3 254
d01_analysis_symbols binary 3 147
message warmups 14 85

day 23 holds 10,822 of the month's 18,956 confirmed rows, and autopilot wrote 10,851 of that day's 10,887 rows. day 17 holds 1,889 of the 2,677 rejected rows, 1,839 of them on the six hcfg_storage fields. pivot rows start on day 17 with 14; from then on they come 1 to 3 a day, on days 20, 22, 23, 25, 26, 27, 29, 30 and 31. 476 of the 724 mail files are urgent, and parents received 348 of them while lane fixers sent 30.

three threads

each thread is quoted from the archived intel rows, mail files and logs of its day, in time order, with seconds after the 09:00 et release in front and a group number the notes under it refer to. agent ids are replaced by roles in square brackets, a scratch path by [scratchpad] and a flag by [redacted]; repo paths are relative to the checkout; long lines are wrapped, and [...] marks a cut. a log line comes from the session log or autopilot's log; a line with no time is the timed runner's output under the line above it.

the roles: [parent] runs the release, the watcher and the ceiling calls; [backup parent] is the second runner's parent and [web parent] the web runner's; a lane fixer ([metadata fixer], [binary fixer]) owns its lane's solver; [owner] is the helper that held day 13's single (the session log names lane fixers from day 15 on); [helper], [second helper] and [second-runner helper] work singles on either runner; [autopilot, metadata lane] is the runner with no model that claims every single at release; [auditor] is the second runner's offline replay agent.

day 13: the product code

metadata-forensics-day-13-product-placement asked one field, d13-msi-001-msi-product-code-guid, of installer-001.msi, a file family no lane reader knew. the msi stores the ProductCode in braces, the answer syntax spelled out the 8-4-4-4-12 digits, and the grader compares text after a trim.

[1]  +2.3     intel observed  [autopilot, metadata lane]
       autopilot metadata-forensics-day-13-product-placement: gaps: d13-msi*
       x1; crashes: KeyError: "no unknown header field for
       'msi-product-code-guid' (have []); unknown metadata property
       'msi-product-code-guid' (no exiftool tag); crosslane: no lane reads 'm
       @ forensics.py:2990; solver said: nothing
     +2.4     intel observed  [autopilot, metadata lane]
       NEW FAMILY for metadata-forensics: installer-001.msi -> ole2 (office 97
       / msi / ole container): readers office.info (olevba macros, autoexec,
       iocs); tools olevba, exiftool; graded fields land in the lane solver

[2]  +18.9    mail            [backup parent] -> [owner]
       URGENT [backup parent] takes msi-product-code-guid on
       metadata-forensics-day-13-product-placement

[3]  +19.4    intel observed  [owner]
       cause: no msi reader in forensics/crosslane; msi-product-code-guid =
       ProductCode row of the msi Property table (ole2 streams). [owner]
       writing PROPERTIES entry in solve.py

[4]  +41.1    intel observed  [parent]
       msi ProductCode candidate {DD1A80D5-0250-4F4D-B289-13096D633C61}
       (string pool: 'ProductCode' immediately followed by it; UpgradeCode
       likely {5F63B105-6C37-46FB-B671-2AF6C4F4CD67}, component id
       {0DF92558-...}, summaryinfo revision/PackageCode
       {99BE1D60-AB14-4859-85FA-9E465A88729D} = NOT product code). confirm via
       Property table decode (olefile 0.47 installed; no msiinfo). format:
       syntax says no braces; case unknown (dotnet mvid was lowercase)

[5]  +47.6    mail            [second-runner helper] -> [backup parent]
       You hold MSI ProductCode GUID. I will inspect timed-tier robustness for
       the parser and send only distinct findings.

[6]  +49.6    intel observed  [helper]
       installer-001.msi ProductCode (Property table) =
       {DD1A80D5-0250-4F4D-B289-13096D633C61} -> canonical
       dd1a80d5-0250-4f4d-b289-13096d633c61 (case per syntax). NOT UpgradeCode
       {5F63B105-6C37-46FB-B671-2AF6C4F4CD67}, NOT PackageCode (SummaryInfo
       revision) {99BE1D60-AB14-4859-85FA-9E465A88729D}. recipe: olefile,
       decode msi stream names (0x3800/0x4800 base64-ish), _StringPool(u16
       len,u16 refcnt; codepage high bit=3-byte idx)+_StringData, Property
       table column-major 2 cols of string idx

[7]  +52.7    log             [parent]
       [coord] next -> assist: [owner] has held this single 0m50s; work it in
       parallel; [owner] is editing
       metadata-forensics-day-13-product-placement: don't redo that fix, take
       a probe, another field family or timed-tier prep; every gap field is
       taken (coord.py gaps): probe a value already in intel, patch the
       owner's solve.py or prep the timed tier
       (metadata-forensics-day-13-product-placement)
     +56.3    mail            [helper] -> [owner]
       msi Property table decoded (confirmed ProductCode row, not string-pool
       adjacency): {DD1A80D5-0250-4F4D-B289-13096D633C61}. working
       self-contained parser you can paste: [scratchpad]/msi/msiprop.py
       (olefile, stream-name decode, string pool, column-major Property)

[8]  +62.9    intel rejected  [owner]
       d13-msi-001-msi-product-code-guid !=
       'dd1a80d5-0250-4f4d-b289-13096d633c61'
     +63.2    intel rejected  [owner]
       d13-msi-001-msi-product-code-guid !=
       'dd1a80d5-0250-4f4d-b289-13096d633c61'
     +63.3    intel rejected  [backup parent]
       d13-msi-001-msi-product-code-guid !=
       'dd1a80d5-0250-4f4d-b289-13096d633c61'
     +63.5    intel rejected  [owner]
       d13-msi-001-msi-product-code-guid !=
       'DD1A80D5-0250-4F4D-B289-13096D633C61'
     +63.5    intel observed  [owner]
       gaps: 0 set(s) raised, 1 field(s) rejected on every candidate, 0
       field(s) unanswered, 1 submitted (incorrect);
       d13-msi-001-msi-product-code-guid: rejected on every candidate; no
       solver note; fix offline: uv run replay
       challenges/day13/metadata-forensics-day-13-product-placement/files/runs/20261013-090103-single-eda6b5d2

[9]  +66.9    intel rejected  [helper]
       d13-msi-001-msi-product-code-guid !=
       'dd1a80d5-0250-4f4d-b289-13096d633c61'

[10] +68.7    mail            [backup parent] -> [owner]
       ProductCode value decoded; lowercase no-braces GUID was rejected by gm
       probe. Testing exact format now. [unverified: GUID never rejected in
       intel]

[11] +76.3    mail            [second-runner helper] -> [backup parent]
       Dryrun reports format pattern for ProductCode. Both plain lowercase and
       uppercase are grader rejected; braces around the verified Property
       table value are the next formatting candidate if you have not probed
       them. [unverified: grader never rejected in intel]

[12] +87.1    intel confirmed [backup parent]
       solved (1 fields)
     +87.1    intel confirmed [backup parent]
       d13-msi-001-msi-product-code-guid =
       '{DD1A80D5-0250-4F4D-B289-13096D633C61}'
     +87.0    log             [autopilot, metadata lane]
       metadata-forensics-day-13-product-placement/time_trial: holding while
       [owner] edits the solver

[13] +92.7    intel observed  [backup parent]
       ProductCode must be emitted as uppercase GUID WITH braces:
       {DD1A80D5-0250-4F4D-B289-13096D633C61}. Bare uppercase and lowercase
       were rejected; braced uppercase probe returned CORRECT. Keep braces
       from MSI Property table string.
     +97.0    mail            [backup parent] -> [owner]
       Braced uppercase ProductCode {DD1A80D5-0250-4F4D-B289-13096D633C61}
       probe returned CORRECT. Intel posted. Preserve braces in solve.py,
       rerun it to reproduce graded single and chain tiers.

[14] +107.2   intel observed  [helper]
       Property-table ProductCode rejected in both cases (verified table
       decode, not adjacency). other guids in the bytes, all untried: braces
       form {DD1A80D5-0250-4F4D-B289-13096D633C61}; UpgradeCode
       5f63b105-6c37-46fb-b671-2af6c4f4cd67 (prompt: 'stable product
       identities'); PackageCode/SummaryInfo revision
       99be1d60-ab14-4859-85fa-9e465a88729d; Component.ComponentId
       0df92558-cbf2-48ac-a8c1-8dc80b710c29. cab artifact.cab -> MarkerFile
       'MSI proof 7E5EF87F23AC' (no guid). built by msitools 0.103 (wixl)

[15] +112.0   log             [autopilot, metadata lane]
       metadata-forensics-day-13-product-placement: won elsewhere, solve.py
       reproduces it -> chaining
     +114.2   intel confirmed [autopilot, metadata lane]
       d13-msi-002-msi-product-code-guid =
       '{DD1A80D5-0250-4F4D-B289-13096D633C61}'
     +115.3   intel confirmed [autopilot, metadata lane]
       solved (2 fields)

what the system did:

  1. autopilot's dry run crashed on the one field at +2.3 s (no msi reader, no exiftool tag, no other lane's reader of that name); it posted the crash as a gaps row and the new file family as a second row, released the single and kept watching the solver files.
  2. coord.py take reserved the only field family for 300 s and mailed the owner by itself; the helper's, the second-runner helper's and the parent's own takes at +19 s to +21 s came back refused: one field, one taker.
  3. the owner posted the cause before its fix, as the runbook asks: no msi reader, and the value is the ProductCode row of the Property table.
  4. the parent's strings pass read the stored form, braces included, and filed it as observed at +41.1 s with 'format: syntax says no braces', a reading of the syntax in the class meant for facts; every agent's next check printed it, and the parent then polled check for 32 s without a submit.
  5. the second-runner helper had been refused the take, so it left the field to its parent and turned to timed-tier robustness.
  6. the helper decoded the Property table, confirmed the stored value and reshaped it to 'canonical' lowercase in the same row.
  7. next handed the parent an assist and told it the owner held the edit lock and every gap field was taken; the helper mailed the owner the value and the path of a scratch parser instead of a probe or a coord.py patch, and no patch ran between 09:00:00 and 09:02:30.
  8. the owner's solve.py, which returned the value in lower and upper case without braces, made the first submit of any form at +62.9 s; gm.py wrote a rejected row for each refusal, three from that run (the lowercase form twice, the uppercase once) and a fourth from the backup parent's probe of the lowercase form, and the runner's gaps row said 'rejected on every candidate'. the stored form was never a candidate.
  9. the helper probed the lowercase form 3.7 s after the grader had refused it: on day 13 gm.py probe did not skip a rejected value (dd13-4 made it).
  10. coord.py note appended [unverified: GUID never rejected in intel]: the check reads the word in front of 'rejected' as the value, so a true report was tagged.
  11. the second-runner helper sent the braces idea by mail to its parent, which read it at +82 s and probed at +85.7 s, the 9 s the idea sat in a mail; the guard tagged this mail too, on the word 'grader'.
  12. the braced probe came back CORRECT at +87.1 s, 46 s after the parent's row: gm.py wrote the answer and the field as confirmed rows and the flag to logs/comp/flags.json. autopilot took the won single's time trial and held it, because the owner held the edit lock and solve.py did not return the braced form.
  13. the winner filed the shape as observed and mailed the owner to keep the braces: the tiers chain only once solve.py reproduces the graded single.
  14. 20 s after the flag the helper posted that the bytes held other guids, 'all untried', the braced form among them: it had read two rejections as a wrong value, not a wrong shape.
  15. at +112 s the owner's edit returned the braces; autopilot found that solve.py reproduced the graded single and chained, and the time trial flagged 27.1 s after the single, the mastery 1.1 s after that.

the bus held the stored value from +41.1 s and every agent on the base saw it; the 46 s to the flag went to reshaping, relaying and hunting, which is why the next command after reading a value is now gm.py guess --values with the stored form first and every variant behind it.

day 17: hcfg_storage

binary-reverse-engineering-day-17-encoded-configuration-recovery asked 204 fields across the binary lane's tags, and 202 were confirmed by +175.5 s. the two left, d12_analysis_hcfg_storage and d14_analysis_hcfg_storage, asked how a raw config blob was stored, a label the bytes never spelled; four sibling tags had taken base64. the single flagged at +6067.9 s.

[1]  +102.4   intel rejected  [parent]
       d08_analysis_hcfg_storage != '.rodata'

[2]  +275.5   mail            [parent] -> [binary fixer]
       [parent] is guessing d12_analysis_hcfg_storage now
       (data/none/embedded/inline/initialized/typed-constant...); d14 is
       yours, not touching it

[3]  +335.2   mail            [backup parent] -> all
       URGENT PIVOT
       binary-reverse-engineering-day-17-encoded-configuration-recovery:
       202/204 fields confirmed. Remaining d12_analysis_hcfg_storage and
       d14_analysis_hcfg_storage. Bytes at graded offsets are raw HCFG in
       .data and .hcfg; common raw/section/encoding labels were rejected.
       [binary fixer] owns solver, [parent] is assisting,
       [second-runner helper] is the fresh pivot helper.

[4]  +357.7   mail            [backup parent] -> [parent]
       URGENT CEILING CEILING:
       binary-reverse-engineering-day-17-encoded-configuration-recovery has
       had no new confirmed field for 2m58s (d12_analysis_hcfg_storage: 79
       rejected, d14_analysis_hcfg_storage: 37 rejected,
       d08_analysis_hcfg_storage: 2 rejected; pivot notes: 1). pivot: bank
       what is confirmed, `coord.py pivot <id> "<state note>"`, switch field
       family or prep the timed tier; a fresh agent from the other runner
       takes the stuck part. decide: keep approach, re-split fields, or add
       agents.

[5]  +508.7   mail            [parent] -> all
       URGENT PIVOT
       binary-reverse-engineering-day-17-encoded-configuration-recovery:
       confirmed: 202/204; hcfg_storage=base64 on d08/d09/d11/d13 (bytes at
       hcfg_offset are base64 text; d09 has base64.nim strings). open: d12
       (raw HCFG in .data, FPC), d14 (raw HCFG in own .hcfg section, dynsym
       huntress_config covers it, size 379). failed kinds: section names any
       case, raw/plain/binary/bytes/none/inline/embedded,
       section/named/elf/custom section, symbol, pascal construct words, xor
       family. hypothesis: answer is a literal token from the bytes (base64
       was). untried: triage --tokens, literal tokens
       (.cfg/cfg/hcfg/huntress_config)

[6]  +840.6   mail            [parent] -> all
       URGENT
       binary-reverse-engineering-day-17-encoded-configuration-recovery: stop
       throwing vocabulary at hcfg_storage (360 rejected). [parent] is
       checking metadata surfaces (full question dict, gm submit feedback,
       start.json keys). [binary fixer] keeps d14 only, nobody else guesses
       until a new source shows up [unverified: 360 never rejected in intel]

[7]  +1531.3  mail            [binary fixer] -> all
       URGENT PIVOT
       binary-reverse-engineering-day-17-encoded-configuration-recovery:
       202/204 confirmed; solve.py reproduces all 202 (autopilot re-ran it).
       open: d12/d14 hcfg_storage. [...] no storage word in payloads, traces,
       zip comments, gm reply keys or question text.
       raw/section/location/encoding/construct/null/title-case families all
       rejected (~550). guessing stopped (user order); solve.py raw branch
       crashes, never guesses. likely grader-side value: recommend organizer
       report.
     +1538.7  mail            [binary fixer] -> [parent]
       URGENT binary d17: user ordered STOP GUESSING on hcfg_storage. analysis
       in my pivot: d12/d14 are raw HCFG (only other carrier kind in the
       corpus besides base64), raw + every synonym/location rejected.
       recommend an organizer report for d12/d14 hcfg_storage and all guessers
       stop. solve.py is ready: one return edit when a value lands.
       [unverified: synonym, location never rejected in intel]

[8]  +4398.2  mail            [binary fixer] -> all
       URGENT PIVOT
       binary-reverse-engineering-day-17-encoded-configuration-recovery:
       hcfg_storage cap 175/175 both. [...] (3) d08 field accepts ONLY exact
       terse 'base64' - rejects base64_literal/base64_string/base64_encoded,
       so the enum is terse single words, NOT snake_case compounds. [...]
       hypothesis: raw tags' value names the reversible transform (single-byte
       xor) or the raw representation in a terse word none of us guessed.

[9]  +5457.0  mail            [helper] -> all
       URGENT PIVOT
       binary-reverse-engineering-day-17-encoded-configuration-recovery: lift
       cap: exhaustive raw+xor carrier sweep #1 (user directed)
     +5457.1  mail            [helper] -> all
       URGENT PIVOT
       binary-reverse-engineering-day-17-encoded-configuration-recovery: lift
       cap: exhaustive raw+xor carrier sweep #2 (user directed)
     +5457.1  mail            [helper] -> all
       URGENT PIVOT
       binary-reverse-engineering-day-17-encoded-configuration-recovery: lift
       cap: exhaustive raw+xor carrier sweep #3 (user directed)
     +5457.2  mail            [helper] -> all
       URGENT PIVOT
       binary-reverse-engineering-day-17-encoded-configuration-recovery: lift
       cap: exhaustive raw+xor carrier sweep #4 (user directed)
     +5457.3  mail            [helper] -> all
       URGENT PIVOT
       binary-reverse-engineering-day-17-encoded-configuration-recovery: lift
       cap: exhaustive raw+xor carrier sweep #5 (user directed)
     +5457.3  mail            [helper] -> all
       URGENT PIVOT
       binary-reverse-engineering-day-17-encoded-configuration-recovery: lift
       cap: exhaustive raw+xor carrier sweep #6 (user directed)

[10] +6022.7  intel confirmed [helper]
       d14_analysis_hcfg_storage = 'raw_hcfg_section'
     +6067.9  intel confirmed [second helper]
       solved (1 fields)
     +6067.9  intel confirmed [second helper]
       d12_analysis_hcfg_storage = 'raw_const_array'

[11] +6132.8  mail            [helper] -> [second helper]
       hcfg_storage rule for your solve.py handler (intel row has it in full):
       SENGR at graded offset -> 'base64'; else raw carrier and the label is
       WHERE it sits -- placement.region_at(body,off).name=='.hcfg' ->
       'raw_hcfg_section' (d14), else const array in .data/.rodata ->
       'raw_const_array' (d12). return ranked
       ['raw_const_array','raw_hcfg_section'] if the section table is
       unreadable. verified stable across all 8 builds of d12/d14, so it holds
       for the time_trial/mastery fresh variants.

what the system did:

  1. the parent's first hcfg_storage guess, .rodata on the d08 tag at +102.4 s, opened 1,839 rejected rows on the six hcfg_storage fields, 1,019 of them on d12 and 784 on d14.
  2. the parent split the two open fields with the binary fixer in a note to the fixer alone; no take was filed on day 17, so the split was not on the bus for the other guessers.
  3. at +335.2 s the backup parent filed the first pivot, an intel row and an URGENT PIVOT mail to all, naming the owner, the assist and 'the fresh pivot helper' the stall had brought in from the other runner.
  4. 22 s later the ceiling fired: 5 minutes on the single, nothing confirmed for 2m58s. coord.py writes that mail from whichever agent's check crosses the line, here the backup parent's, addresses it to the parent, and offers three moves: keep the approach, re-split the fields, add agents. it counted 79 and 37 rejected values on the two fields; the day ended at 1,019 and 784.
  5. the parent's pivot follows the five-part form (confirmed, failed kinds, hypothesis, untried); its hypothesis was a literal token from the bytes, and the organizer's 11:13 reply showed the answer was not in the artifact.
  6. at +840.6 s the parent ordered the vocabulary guessing stopped at 360 rejected values; the note guard tagged the count 360 as an unverified rejection.
  7. at +1531.3 s the binary fixer concluded 'likely grader-side value: recommend organizer report' and mailed the parent the same; the runbook had no step that carried such a report to the human, and 13 more agents were spawned onto the base.
  8. at +4398.2 s a pivot filed a rule read off rejections as a fact, 'the enum is terse single words, NOT snake_case compounds'; both graded labels were three-word compounds.
  9. six pivots within 0.4 s, one line each, each lifting the guess cap of a field by 25 (GUESS_CAP * (1 + pivots)): 150 more guesses for the same kind of word list. the day's 14 pivot rows changed the guess budget, not the method.
  10. at +6022.7 s the helper's raw_hcfg_section was accepted, a label built from where the blob sits; the second helper's raw_const_array won the single at +6067.9 s.
  11. the helper mailed the rule for the second helper's handler: base64 when the carrier is base64 text, else the place the raw blob sits. the time trial flagged at 10:42:06 and the mastery at 10:45:23; at 11:13 the organizer, relayed by the human, called the two labels a challenge bug that 'should have been in the source'.

a pivot that lifts the cap for more of the same list is the same method; the runbook now sends a field nothing in the artifact names to the human at the first ceiling, with a three-line note the organizer can act on.

day 31: the metadata time trial

metadata-forensics-day-31-no-artifact-left-behind asked for graph.execution_chain_artifact_ids of case-001.zip: a walk across 23 artifacts that each name the next one, each in its own format. no lane reader named the field, so the single went to the metadata fixer at release, and the time trial served fresh bytes on which the first handler failed twice.

[1]  +3.7     intel observed  [autopilot, metadata lane]
       autopilot metadata-forensics-day-31-no-artifact-left-behind: gaps:
       d31-case* x1; proofless captures: 0; crashes: KeyError: "no zip header
       field for 'graph-execution-chain-artifact-ids' (have ['eocd.cd_disk',
       'eocd.cd_offset', 'eocd.cd_size', 'eocd.comment_length',
       'eocd.disk_entries @ forensics.py:4914; solver said: nothing
     +3.8     intel observed  [autopilot, metadata lane]
       autopilot metadata-forensics-day-31-no-artifact-left-behind:
       d31-case-001-graph-execution-chain-artifact-ids is yours, autopilot did
       not get it. question: "Determine graph.execution_chain_artifact_ids for
       case-001.zip." the lane reader: KeyError: "no zip header field for
       'graph-execution-chain-artifact-ids' (have ['eocd.cd_disk',
       'eocd.cd_offset', 'eocd.cd_size', 'eocd.comment_length',
       'eocd.disk_entries @ forensics.py:4914; reader outputs: no reader
       output carries its words (every one, or one over); no stored token or
       role route. closest reader outputs: none share a word. files:
       birch-41eb, birch-bd18, bramble-e622, case-001.zip, ember-4110,
       estuary-1df5, garnet-315d, jetty-62cc, juniper-a409, lagoon-792d,
       meadow-d023, meadow-f365 (+11 more). answer kind json: compact valid
       JSON array with exact values and order; no Markdown or explanatory
       text. fix: a handler at FIELDS = Fields() (from ctfkit.hlib import
       inventory   # noqa: E402, to read any line above). handlers.py draft
       (one Write; fill the computation from the question):
       @FIELDS.add(r"(.+)-(graph-execution-chain-artifact-ids)")
       def draft(files: dict[str, bytes], g: tuple[str, ...], q: dict[str, Any]) -> Any:
           name, body = archive.resolve_member(files, g[0], q)
           return <the computation>

[2]  +71.0    mail            [metadata fixer] -> [parent]
       [metadata fixer] guessed
       metadata-forensics-day-31-no-artifact-left-behind by hand with no
       handlers.py (--hand: edges read by hand: ps1 Invoke-Item/Start-Process
       target, png tEXt next=, eml base64 route.txt, zip run.txt execute,
       sqlite launch_queue.target; only root birch): its save is the chain's
       next step

[3]  +72.4    intel confirmed [metadata fixer]
       solved (1 fields)
     +72.4    intel confirmed [metadata fixer]
       d31-case-001-graph-execution-chain-artifact-ids =
       '["birch-bd18","nectar-1767","bramble-e622","orchard-e5bc"]'

[4]  +72.0    log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: holding
       while [metadata fixer] edits the solver
     +77.0    log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind: no located solver:
       d31-case-001-graph-execution-chain-artifact-ids is no stored token,
       role route, reader output, codec chain or header integer

[5]  +118.0   mail            [parent] -> [parent]
       URGENT TIMED STALL:
       metadata-forensics-day-31-no-artifact-left-behind/time_trial
       ([autopilot, metadata lane], held 0m45s): NO START 0m45s after the
       claim

[6]  +130.0   log             [metadata fixer]
       # Write
       challenges/day31/metadata-forensics-day-31-no-artifact-left-behind/handlers.py
     +130.0   log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind: won elsewhere,
       solve.py reproduces it -> chaining
              log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: timed
       attempt, 49.8s on the clock
              log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: 0 set(s)
       failed, 1 field(s) rejected on every candidate, 0 field(s) unanswered;
       36 submitted (accepted)

[7]  +133.6   intel rejected  [autopilot, metadata lane]
       d31-case-001-graph-execution-chain-artifact-ids !=
       '["ember-219a","obsidian-c304","willow-7e45","tundra-5739","bramble-ae71","prairie-3ef0","nectar-b860","quartz-424e","umber-2385","kelp-8bf6","cascade-e73b"]'
     +133.8   intel rejected  [autopilot, metadata lane]
       d31-case-001-graph-execution-chain-artifact-ids !=
       '["yarrow-72a1","estuary-bb5b","nectar-38a9","jetty-f3f4"]'
     +134.0   intel rejected  [autopilot, metadata lane]
       d31-case-001-graph-execution-chain-artifact-ids !=
       '["umber-0930","amber-312d","yarrow-76e0","anchor-10ba"]'
     +134.3   intel rejected  [autopilot, metadata lane]
       d31-case-001-graph-execution-chain-artifact-ids !=
       '["yarrow-4026","quill-c296","meadow-0205"]'
     +134.7   intel rejected  [autopilot, metadata lane]
       d31-case-001-graph-execution-chain-artifact-ids !=
       '["anchor-60ed","kelp-5032","cobalt-cacd"]'
     +134.8   intel rejected  [autopilot, metadata lane]
       d31-case-001-graph-execution-chain-artifact-ids !=
       '["willow-2fe8","indigo-31b4"]'
     +135.0   intel rejected  [autopilot, metadata lane]
       d31-case-001-graph-execution-chain-artifact-ids !=
       '["ember-3d3d","lagoon-075c"]'
     +134.6   log             [metadata fixer]
       [coord] edit metadata-forensics-day-31-no-artifact-left-behind ->
       released after checked save
     +135.1   intel observed  [autopilot, metadata lane]
       gaps: 0 set(s) raised, 1 field(s) rejected on every candidate, 0
       field(s) unanswered, 36 submitted (accepted);
       d31-case-001-graph-execution-chain-artifact-ids: rejected on every
       candidate; bytes: evidence.zip -> case-001.zip in
       challenges/day31/metadata-forensics-day-31-no-artifact-left-behind/files/runs/20261031-090212-time_trial-b681fd68/artifacts
       (7 forms:
       '["ember-219a","obsidian-c304","willow-7e45","tundra-5739","bramble-ae71","prairie-3ef0","nectar-b;
       fix offline: uv run replay
       challenges/day31/metadata-forensics-day-31-no-artifact-left-behind/files/runs/20261031-090212-time_trial-b681fd68

[8]  +135.1   mail            [autopilot, metadata lane] -> [backup parent]
       URGENT TIMED CRASH
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: 1 gap(s):
       rejected on every candidate; bytes: evidence.zip -> case-001.zip in
       challenges/day31/metadata-forensics-day-31; `coord.py tick` spawns
       [auditor] on
       challenges/day31/metadata-forensics-day-31-no-artifact-left-behind/files/runs/20261031-090212-time_trial-b681fd68
     +135.2   mail            [autopilot, metadata lane] -> [parent]
       URGENT TIMED STALL
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: autopilot
       solver 1 gap(s): rejected on every candidate; bytes: evidence.zip ->
       case-001.zip in challenges/day31/metadata-forensics-day-31; released.
       replay
       challenges/day31/metadata-forensics-day-31-no-artifact-left-behind/files/runs/20261031-090212-time_trial-b681fd68
       offline, then one new start

[9]  +185.0   log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: changed
       solve.py not clean on
       challenges/day31/metadata-forensics-day-31-no-artifact-left-behind/files/runs/20261031-090212-time_trial-b681fd68:
       1 set(s) raised, 0 unsure, 36 unanswered, 35 accepted value(s) changed,
       0 rejected value(s) again: [...] set0 raised handler crashed on
       d31-case-001-graph-execution-chain-artifact-ids (ValueError: too many
       values to unpack (expected 2));

[10] +192.0   log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: changed
       solve.py re-solves its failed run -> running it
              log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: WARNING
       unranked attempt, not hall-of-fame eligible (the flag counts; no
       speed-ranking time until the end-of-day rerun)
              log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: start
       reconnected to an expired attempt, retrying
     +193.6   mail            [parent] -> [parent]
       URGENT TIMED STALL:
       metadata-forensics-day-31-no-artifact-left-behind/time_trial
       ([autopilot, metadata lane], held 0m00s): DEADLINE PASSED with no flag:
       `uv run replay` the saved run, fix offline, then one new start

[11] +194.8   intel observed  [autopilot, metadata lane]
       gaps: 1 set(s) raised, 0 field(s) rejected on every candidate, 1
       field(s) unanswered, 35 submitted (accepted); set0: IndexError: list
       index out of range (1 field(s) crashed and stayed unsent:
       d31-case-001-graph-execution-chain-artifact-ids; the set's other fields
       were submitted); fix offline: uv run replay
       challenges/day31/metadata-forensics-day-31-no-artifact-left-behind/files/runs/20261031-090314-time_trial-70a98bd2
     +194.8   mail            [autopilot, metadata lane] -> [backup parent]
       URGENT TIMED CRASH
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: 1 gap(s):
       IndexError: list index out of range (1 field(s) crashed and stayed
       unsent: d31-case-001-graph-execution-chain-; `coord.py tick` spawns
       [auditor] on
       challenges/day31/metadata-forensics-day-31-no-artifact-left-behind/files/runs/20261031-090314-time_trial-70a98bd2

[12] +206.2   log             [parent]
       [coord] edit metadata-forensics-day-31-no-artifact-left-behind ->
       editing metadata-forensics-day-31-no-artifact-left-behind (renew within
       120s, --release when done)
     +214.1   log             [parent]
       [coord] edit metadata-forensics-day-31-no-artifact-left-behind ->
       released metadata-forensics-day-31-no-artifact-left-behind
     +214.2   mail            [parent] -> [metadata fixer]
       URGENT [parent] (the human's order) on your tt IndexError run
       20261031-090314: likely graph_chain returned [] (no root found on fresh
       bytes). diagnosing now, will send patch; keep going, don't wait on me.

[13] +221.0   log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: changed
       solve.py re-solves its failed run -> running it
              log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: 1
       artifact(s) of this attempt read from
       challenges/day31/metadata-forensics-day-31-no-artifact-left-behind/files/runs/20261031-090314-time_trial-70a98bd2
       (sha256 matched), no download
              log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: 35
       field(s) already banked on this attempt; submitting the 1 missing
              log             [autopilot, metadata lane]
       metadata-forensics-day-31-no-artifact-left-behind/time_trial: CORRECT
       flag=[redacted]
       run=challenges/day31/metadata-forensics-day-31-no-artifact-left-behind/files/runs/20261031-090342-time_trial-70a98bd2
     +224.2   intel confirmed [autopilot, metadata lane]
       d31-case-001-graph-execution-chain-artifact-ids =
       '["tundra-c963","marble-81e3","willow-2d76","indigo-3cad"]'
     +227.6   intel confirmed [autopilot, metadata lane]
       solved (540 fields)

[14] +231.7   mail            [metadata fixer] -> [parent]
       d31 metadata tt SOLVED by autopilot: cause was malformed-quote ps1 edge
       on the root (tundra-c963 &  ".\marble-81e3'); handler now walks loose
       edges. no patch needed
     +232.0   log             [parent]
       [guard] STOP
       metadata-forensics-day-31-no-artifact-left-behind/time_trial already
       solved
     +249.0   log             [parent]
       [guard] STOP
       metadata-forensics-day-31-no-artifact-left-behind/time_trial already
       solved

[15] +238.0   intel observed  [metadata fixer]
       graph.execution_chain_artifact_ids: case zip of artifacts each naming
       one next artifact (ps1 '.\x' target, quotes may be mismatched and still
       count; png tEXt next=; eml base64 attachment 'forwarded
       to:/open:/next:/continue with:'; zip run.txt 'execute x'; sqlite
       launch_queue.target; json next). root = the one member no edge points
       at; follow to the terminal (png 'done', ps1 '# ... terminal'
       Write-Output); the rest is a cycle decoy. answer = basenames in walk
       order, compact json
     +241.0   log             [metadata fixer]
       [coord] retired

what the system did:

  1. autopilot's dry run crashed at +3.7 s and released the single with a gaps row and an is-yours row: the question, what was tried, the files, the answer kind and a handlers.py draft keyed on the field id.
  2. the fixer read the edges by hand and guessed with --hand: gm.py's rule 0 refuses a fixer's hand guess on its own single while no handlers.py exists, unless the guess says what read the value, and then mails the parent that the handler save is the chain's next step.
  3. the guess won the single at +72.4 s and gm.py wrote the confirmed rows.
  4. autopilot claimed the time trial at once and held it: the fixer held the edit lock, and solve.py could not reproduce the graded value. its located solver found nothing to learn from the graded single.
  5. 45 s after autopilot's claim with no start (TIMED_NO_START_S), the parent's watcher mailed the parent; the watcher runs in the parent's own process, so the mail is from and to the parent.
  6. the fixer saved handlers.py at +130 s; within the same second autopilot found that solve.py reproduced the graded single and started the ranked time trial, 49.8 s on the clock.
  7. the handler's answer missed on the fresh bytes: the runner tried seven ranked candidates, gm.py wrote seven rejected rows, the other 36 fields were accepted and banked, and the gaps row named the field, the forms and the saved run. check released the fixer's edit lock after the save.
  8. the runner mailed TIMED CRASH to the backup parent, a recipient hard-coded in runner.py since day 9, and autopilot mailed TIMED STALL to the parent: released, replay the saved run, one new start.
  9. the fixer's next save crashed the handler on the saved run, and autopilot's gate kept it off the live attempt: a set raised and 35 accepted values would have changed.
  10. the save after that re-solved the first run cleanly, so autopilot ran the tier again; the attempt had expired, so the start opened a fresh, unranked one with new bytes, and the watcher mailed DEADLINE PASSED for the first attempt to the parent and to the web parent.
  11. on the new bytes the handler raised IndexError: the set's other 35 fields were accepted and banked, the crashed field stayed unsent, and the attempt stayed open for a fix. the mail cuts the error at 120 characters, inside the field id.
  12. on the human's order the parent took the fixer's edit lock for 8 s, released it and mailed a guess at the cause and a promise of a patch.
  13. the fixer saved first: autopilot re-solved the open attempt's own bytes (sha256 matched, no download), sent the one missing field with 21.2 s left and got CORRECT at +224.2 s; the mastery's 540 fields went in from the same solver at +227.6 s.
  14. the fixer read the parent's mail 7 s after the flag and answered with the cause and 'no patch needed'; the solved guard refused the parent's next two commands on the tier.
  15. the fixer filed the recipe as observed for the end of day and retired.

the failure went from autopilot to the fixer and the fix back to the live attempt through files alone; the one mail the parent wrote to the fixer was read after the flag.

what it cost, and what we would change

{generated by a clanker}