night shift: how each day's misses became the next morning's solver
by 09:00 each morning, the solver that ran was the one that had failed the day before, fixed and replayed on yesterday's bytes. the gaps, crashes and slow seconds of a race became fixtures, library changes and checks that night, and the night closed on a readiness stamp the next release read. the loop ran thirty times. this page shows its stages, one night by the clock, the numbers night by night, what it predicted and how often that held, and the gate that closed each night. a night started when the board closed, often before noon, and ended at the stamp.
- 30nights the loop ranone procedure file from day 8, a report from day 9
- 463replay fixtures by the endone per graded tier, days 1 to 31
- 383shared-library commitssrc/ctfkit/hlib, days 4 to 31
- 89%of 359 open items marked fixed22 day reports, days 9 to 30
- 2,057tests by the end116 on the morning of day 5
- 96gate drills passed8 of 8 on each of nights 19 to 30
- 16/17schedule rows in place by the next morningrows 14 to 30; 0 before their own day
- 12race-day handler files, non-web4 folded into hlib and deleted the same night
the loop
AFTER_ACTION.md is the whole procedure: a fresh reviewing agent reads it once the board is complete and runs the stages in order without being asked for the next one. the yardstick for every finding is the seconds it moved the board finish. the human's standing order was to fix everything the day showed, lane-agnostic, without waiting for approval; the yellow tags mark the five places the procedure stops and asks.
purple: a stage. green: what it leaves in the repo. yellow, dashed: the human's call. the dashed line on the left is the next night: day N+1's misses feed stage 1 again.
| stage | what it does | what it writes | on day 28 |
|---|---|---|---|
| 1 close the day | reconciles the board, cuts the timelines, reruns every solved timed tier on the ranked pool, scores the night-before checks, promotes fixtures, archives the day's runtime files | top50.csv, timeline.md, agent-timeline.md; tests/fixtures/dayNN/; sessions/archive/day-NN/ |
18:21 to 18:35, 14 min |
| 2 review | the evidence pack first, then the raw records, the narratives last; read-only, no game-master call | evidence.md, after-action.md: findings by board seconds, decisions, open items |
18:23 to 18:55, 32 min |
| 3 variants -> solvers | backtests every saved run, harvests fresh regular variants inside the budget, fixes every parked one in hlib | research/variants/, backtest.md, hlib fixes with tests |
18:24 to 19:01, 37 min; a second metadata harvest to 19:48 |
| 4 tomorrow's hints | reads the prompts and the readiness check's look-ahead, builds what they name that no question graded yet | the DAY_CODECS row, HINT_FAMILIES words, lanes/<lane>-prep.md, docs/reference/future-checks.md |
the parent's prep 16:29 to 17:04; the next day's checks at 18:43 |
| 5 inefficiencies | the timeline's sinks, the solver profile, traced simulations of the day, a replay with live model fixers | solver-profile-<date>.md, research/simulations/ (deleted once its numbers are in the report) |
18:40 to 19:07, 27 min |
| 6 fix | every item in board-seconds order, race logic before solver speed, a test that fails without it | one commit per item, the open item marked fixed <sha>, CAPABILITIES.md rewritten where it changed |
the parent's session, about 11:50 to 17:54; the reviewer's two items, 18:45 to 19:59 |
| 7 gate | pytest, backtest, nightly.py, a clean simday, drillgate.py, the disk offload, docs current |
sessions/ready.json |
pytest, the drills and the final simulation by 19:47; the stamp at 21:24 |
| 8 the blog | a writeup per challenge, the day's posts, a day section on every tool page that changed | writeup.md, blog/, blog-full/ |
one commit at 19:17 |
the times are day 28's, the night below. the stages overlapped: the backtest and the harvest ran in the background while the review was written, and the fixes had started six hours before the reviewer did.
the web lane's night
the web lane ran the same stages beside the non-web review with its own artifacts: no download to promote, so its fixtures are recorded captures and mock targets, and no offline bytes to replay, so its replay spends fresh variants against live targets.
| stage | what it does | day 30's night |
|---|---|---|
| fixtures | the day's novel classes pinned on capture-faithful local targets: a mock target per class replaying the day's exchanges, a test each; the recorded captures in tests/fixtures/web/ are the two challenge-24/25 ones from 10-28 |
the two day-30 classes: mock targets mock_pti.py and mock_qtc.py under tools/after-action/testweb/, two tests in tests/test_web_live_families_dd30.py |
| report | the web lane's own findings and open items, beside the general one | findings F1 to F7, seven open items: dd30-6 and dd30-14 to dd30-19 |
| replay | every solved base from day 19 to the day, re-run on fresh variants, one proof field at a time | 58 tiers across 29 bases: 55 correct, 1 accepted, 2 refused, both refusals fixed the same night (the 57 rerun rows: 19 ranked, 4 unranked, 34 with the rank not recorded) |
| variants | the backtest over every saved web run | 0 wrong, 0 crash |
| prep | the lane's prep file: the day's families, the unobserved alternates, the keeper gate | the two day-30 families |
| fixes | web items in board-seconds order, a replay each | six commits, each with its targeted test |
| writeups | a writeup per challenge, the posts in both trees | the day-28 and day-29 writeups, the day-30 posts |
the web gate is the replay and the rehearsal: every solved base must come back correct on a fresh variant before the night ends, a new class lands as a named family with a local mock target and an offline test, and one command runs a real web worker against local targets as the rehearsal. the readiness gate replays the fixtures, so a class that regressed fails the night's gate, not the race.
one night, by the clock
day 28 was a loss: three lanes met fields no reader named and went to fixers, and the board closed 31 minutes after the release. its night has the clearest timestamps of the month, because two sessions worked it: the parent's, which landed the readers the race lacked by early afternoon, and the reviewer's, which ran stages 1 to 8 from 18:21. the gate failed twice on steps done by hand, a run not promoted and a table row not written, so that afternoon the gate became one command. the stamp still came late: the web lane's uncommitted work held it until 21:24, and a commit at 08:43 the next morning voided it again.
| time (et) | what happened |
|---|---|
| 09:31 | the board closes at +1881.7s, 49th of 93 teams that finished; three lanes went to fixers on fields autopilot had no reader for |
| 12:11 to 12:37 | the parent's session lands the missing readers: the apk packet codec and a partition-table disk record (12:11), the question-recipe interpreter (12:25), a crash-isolated partial submit and headless fixer launch (12:37) |
| 12:10 | NOT READY at 2e8835fd: the rehearsal, on runs not yet promoted |
| 12:50 | the day's autopilot wins promoted as fixtures (e56b1626) |
| 12:55 | NOT READY at e56b1626: missing row decode.DAY_CODECS[28] = 'reverse>hex' |
| 12:56 | the row lands (d9c1833c) |
| 15:06 to 15:15 | a second pass: the binary recipe step, seven codecs and a slug rule in the decoder, a dex framework layer, lazy metadata reads |
| 16:25 | nightly.py, the gate as one command (47b034c2) |
| 16:29 to 17:04 | metadata prep: the partition an offset in the question names, header records for the container kinds likely next |
| 17:54 | CAPABILITIES.md current for every non-web change of the day |
| 18:21 | the reviewer starts: reconcile, board 21/21, nothing in progress |
| 18:23 | the evidence pack, 319 lines |
| 18:24 to 18:43 | backtest before the harvest: 2,771 saved runs and variants, 0 wrong, 0 crash |
| 18:35 | stage 1 done: the ranked rerun 10/10 correct (binary mastery 5.94s against the race's 314.81s); five of yesterday's eight checks failed |
| 18:40 | a traced simulation of the day: board +8.956s, 15/15 by autopilot |
| 18:44 | autopilot --check --day 29 READY in 323s |
| 18:55 | stage 2 done; F10 from a broken-binary simulation: a fixer's save waited 106s behind the stored-token sweep, board +148.9s |
| 19:07 | stage 5: the fix measured, +148.9s to +30.8s scripted, +61.9s to +20.0s with a live model fixer |
| 19:17 | the day's posts, writeups and tool-page sections |
| 19:47 | nightly.py: promote, pending and tables pass, then commit first: 10 uncommitted checked paths, the web lane's work and the fix's hunk |
| 19:59 | the fix committed (88b33ac9) |
| 20:04 | kickoff learns to start the check detached on a stale stamp (the review's D1) |
| 21:24 | READY stamped on e07ea957 |
| 08:43 (day 29) | a commit voids the stamp; kickoff starts the check |
| 08:49 (day 29) | READY in 299s, eleven minutes before the release |
thirty nights in numbers
a commit belongs to the night of the day whose 08:15 it follows; the repository starts on day 4, so nights 1 to 3 show none.
one case directory per graded tier under tests/fixtures/dayNN; five lanes times three tiers is fifteen a day. days 1 and 2 hold the singles and one mastery; the cases above fifteen on days 4 to 14 are the web lane's, which later kept its recordings in tests/fixtures/web.
- marked fixed
- open, a decision, obsolete or skipped
rows of the report's open-items table with that day's own id; the report template starts on day 9. statuses are as of the end of the month, so an item fixed on a later night counts as fixed.
- autopilot
- a model agent
- unattributed
fifteen tiers a day (five lanes, three tiers). a tier autopilot submitted from a fixer's saved handler counts as autopilot's, so this is who pressed submit, not who found the rule. day 1 has no attribution.
test functions under tests/ at the last commit before 08:15; the repository's history starts on day 4.
reading them together:
- the big nights for the library were night 30 (56), night 10 (33), night 9 (29), night 14 (22). nights 8, 9 and 10 (18, 29 and 33 commits) built readers for formats each lane had not met yet, while a model agent still submitted ten or more of the fifteen tiers on days 2, 3, 4, 5 and 8. the readiness check dates from night 7, its stamp from night 13, the day table from night 14 and the table gate from night 16.
- the quiet nights were night 5 (2), night 6 (4), night 12 (5), night 27 (5). a quiet night in the library was not an idle one: the whole repository took 10, 14, 18 and 19 commits on those nights: race tooling, docs, reports, the day's posts and, on night 27, the web lane.
- night 28's 1 of 7 undercounts the night: its findings F1 to F6 were fixed by the parent's commits that afternoon, before the reviewer wrote the rows, so the rows that remained were mostly decisions.
- night 30 was the rebuild: 56 library commits, 54 open items with 51 fixed, a backward regression over every fixture and variant of every day and a forward matrix of the cases the last day could bring. the human held the whole-tree gate until the web lane was done, so the final stamp came at 19:59.
- 7 days had no tier submitted by a model agent at all: days 11, 16, 22, 23, 25, 27 and 30.
the nights one by one (subjects as committed, cut at the first clause; a subject that names an agent or a runner is skipped):
| night | library commits | fixtures | open items fixed | the night's largest library commits |
|---|---|---|---|---|
| 1 | 0 | 5 | - | - |
| 2 | 0 | 6 | - | - |
| 3 | 0 | 15 | - | - |
| 4 | 7 | 18 | - | night-before prep: semantic fallbacks for each lane's likely next change; release follow-ups: warm never aborts, module locks, auto alternatives |
| 5 | 2 | 17 | - | hlib: generic descriptor decoding, png chunks, rust, split codec, xor; hlib: language-agnostic script descriptor finder, verb roles, ranked xor |
| 6 | 4 | 15 | - | hlib: jar reader, pdf and exiftool fallback, token separators, bash graphs; race tooling: any new member type flagged, new answer formats, scope |
| 7 | 8 | 15 | - | hlib: header fields, compiled carriers, mach-o, wasm, codec grid; race tooling: claims, graded tables, assist patches, loud failures |
| 8 | 18 | 15 | - | expansion bounds: bombs end as errors, real big data still opens; readiness: tomorrow's likely variants solve offline today |
| 9 | 29 | 18 | 21 / 24 | forensics: structured header field names resolve generically (day 9 end of day); decode: literal-family codecs, caesar search pass, slug-line repair (day 9 end of day) |
| 10 | 33 | 17 | 11 / 12 | compound: trace outcomes from jar / .net code, one normalized template for every style; wmi: mof filters, consumers, bindings and the subscription that survives a reboot |
| 11 | 8 | 17 | 6 / 7 | readiness: d12 grid for warmups, mobile, script, metadata; readiness: d12 binary grid (hcfg section and load address), d12 lane prep |
| 12 | 5 | 17 | 10 / 11 | hlib: crosslane answers a field by another lane's reader of exactly that name; readiness: day 13 grid (whole-text transforms, dotnet identity fields) |
| 13 | 12 | 17 | 14 / 16 | autopilot: sweep stored tokens, chain through a located solver (dd13-7); decode: classical ciphers after atbash (d14 prep) |
| 14 | 22 | 16 | 10 / 11 | records: one-record readers for every family metadata has not seen yet; forensics: full lnk, eml and ooxml records answer tomorrow's properties |
| 15 | 14 | 15 | 22 / 24 | inventory, autopilot: a field a reader already outputs; triage: a member path resolves by name |
| 16 | 10 | 15 | 10 / 12 | web: the lane's readers, seed, drill and live-target plumbing; binary: wasm doors ready for day 17 (imports, memory, tables, indirect calls) |
| 17 | 17 | 15 | 14 / 15 | compound: hcfg_storage, c++ symbol names, runtime markers, access_flags; runner: on-clock work cut: vocabulary per file, nested zips read once |
| 18 | 20 | 15 | 8 / 9 | hlib.records: rar 4 / 5, truetype / opentype, ico / cur and rtf readers; hlib media: ffprobe composites by words |
| 19 | 10 | 15 | 17 / 19 | web: optimize live lane and generalize testing grounds; hlib.compound: the overlay's offset from the magic alone, a wider step search |
| 20 | 12 | 15 | 12 / 12 | hlib.forensics, apk, compound: the three day 20 race handlers promoted; runner: a mastery's sets are solved as their downloads land (dd20-12) |
| 21 | 6 | 15 | 8 / 8 | gm, web_live, autopilot: op reset, gated to a dead or wrecked web target; android: every manifest and signer scalar is a reading |
| 22 | 17 | 15 | 25 / 26 | web: close day 22 race gaps; records: the zip family, pyc, thumbcache and wim (dd22-22, dd22-24..26) |
| 23 | 13 | 15 | 27 / 29 | mobile: the analysis codec runs the dex, a native piece under unicorn; mobile: the Vm reads the apk's assets, resources and a loaded dex (dd23-24) |
| 24 | 9 | 15 | 9 / 9 | web: fix day 24 solver and timing failures (dd24-9); hlib.decode: day 24's line is netstring |
| 25 | 10 | 15 | 8 / 11 | day 25 web postmortem, blog writeups, and lane fixes; metadata: a record key's synonym and the registry record's day-2 keys (dd25-2, dd25-3) |
| 26 | 7 | 15 | 12 / 15 | hlib.dex, hlib.apk: split apks read whole; hlib.winart: win10 prefetch (MAM xpress-huffman) read locally, the whole record (dd26-3) |
| 27 | 5 | 15 | 6 / 10 | web: days 28-31 prep -- new transports/recipes + fixtures + deps; web: day-27 lane hardening for day 28 |
| 28 | 17 | 15 | 1 / 7 | mobile: dex framework layer; metadata: header records for the containers likely next (hlib.containers) |
| 29 | 10 | 15 | 17 / 18 | records: mft, pdf, png, 7z, journal and pst readers; web_live: generic bounded clue fallback for a renamed meta-class (dd30-1) |
| 30 | 56 | 15 | 51 / 54 | apk: a bounded layer peel for stacked puzzle codecs, the dex for unread data (dd30-31); compound: a call-graph field fits a timed set (dd30-21h) |
predicting the morning
stage 4 writes four kinds of prediction: a row for the warmups day table, hint words for the prompt, prep for fields no question has graded, and checks that only the next release can score. what follows counts each one against the morning it was for. for what the mornings still found missing, lane by lane, see coverage.
the day table
decode.DAY_CODECS holds one codec per day: a warmups mastery repeats every earlier line, so line k reads by row k and only the newest line needs a search. the table was born on day 14 at 09:51 with 14 rows. after that each row was written on the day it records or later, never before: 0 of 31 rows were in place before their own day's release. what the row buys is the next morning, and there 16 of 17 rows (14 to 30) were in place by the next release; row 15 was not, and day 16 lost 40.8s to the search it stood in for. from day 16 the table gate fails the night on a row a search supplied, which is what caught row 28 at 12:55.
the hint words
the prompt names the day's codec in a riddle. decode.HINT_FAMILIES maps riddle words to codec families, and the decoder tries a family the prompt names first. it grew from 27 families on the morning of day 15 to 91 on the morning of day 31. the table below replays the decoder's own rule (_hinted: a step of the codec that starts with a family whose words the prompt says) against the hint table as it stood at each release:
| morning | the prompt | the day's row | named by that morning's hint words | single submitted by |
|---|---|---|---|---|
| 15 | "even the punctuation went for a spin." | rot47 |
no | autopilot |
| 16 | "sixteen little symbols are calling. dot dot dot." | morse>hex |
yes (hex) |
autopilot |
| 17 | "sixteen guests. five little a's and b's apiece." | baconhex |
no | lane fixer |
| 18 | "three rails. one very zigzag commute." | railfence3 |
yes (railfence) |
autopilot |
| 19 | "two bytes walk into a bar. the little one goes first." | utf16lehex |
no | parent |
| 20 | "same bar. this time the big one goes first." | utf16behex |
yes (utf16) |
autopilot |
| 21 | "a familiar wrapper. something compressed inside." | b64inflate |
no | autopilot |
| 22 | "another familiar wrapper. this one needs a little inflation." | b64inflate |
yes (b64inflate) |
autopilot |
| 23 | "the alphabet got bigger. adobe might recognize the neighbors." | a85 |
no | autopilot |
| 24 | "count carefully. the comma knows where to stop." | netstring |
no | lane fixer |
| 25 | "every character has a point. a code point, anyway." | uniesc |
no | autopilot |
| 26 | "a very small language has quite a lot to say." | brainfuck |
no | autopilot |
| 27 | "ook. ook? ook! someone seems chatty." | ook |
no | autopilot |
| 28 | "our sixteen-fingered friend is walking backwards." | reverse>hex |
yes (reverse), yes (hex) |
autopilot |
| 29 | "sixty-four invited thirteen over. things got scrambled." | rot13>b64 |
no | autopilot |
| 30 | "that address bar problem? it happened twice." | url>url |
no | autopilot |
| 31 | "thirty-two, a little pressure, then sixty-four. unpack that thought." | b64inflate>b32 |
yes (b64inflate), yes (b64), yes (b32) |
autopilot |
the morning's words named the day's codec on 6 of 17 mornings. on 8 of the 11 misses autopilot read the new line anyway, by the search the hint only orders; on days 17, 19 and 24 the single went to a model agent. by the next morning the table named the codec for 5 of those 11 riddles. the seven classical-cipher families written as day-19 prep (playfair, bifid, four-square and the rest) were never asked.
offered, never graded
the readiness check's look-ahead lists every enum value a question offered and no answer ever used. two of its outputs survive in logs/comp/: 34 field and value lines on the morning of day 29, 36 on day 30, 14 distinct values, all in the binary lane; none dropped off the list between the two. one of them came true: neko_bytecode, offered in every binary *_format enum from the day-12 field on, was graded on day 30 under three new day-30 format fields, as the carrier of the record that held the binary single until +238s. the look-ahead read enum values only; the record's magic and the metadata relation family were named in that morning's question and prompt text, which it did not read until night 30 (dd30-8).
the prompt audit
night 30 read every non-web prompt and question set of days 1 to 30 (the 150 lane challenges) for things a prompt named and no question graded, and the solver path for each (prompt-coverage.md):
| lane | hints never graded | covered | partly | uncovered |
|---|---|---|---|---|
| metadata | 34 | 26 | 8 | 0 |
| script | 24 | 2 | 3 | 19 |
| binary | 13 | 5 | 4 | 4 |
warmups and mobile had none: each day's prompt named exactly what that day graded. its watch list for day 31 put the metadata relation fields first and a binary record under a new magic fourth. day 31 asked the fourth and not the first: binary asked ten configuration fields of a record under the new magic HGAU, which no producer answered (no generic producer), and metadata a graph-execution-chain field no reader named. both singles went to fixers; warmups, mobile and script went to autopilot alone. the list named one of the two misses, and naming it was not enough.
the night-before checks
- held
- failed
- not exercised
docs/reference/future-checks.md's results tables (days 20 to 30 are kept): one row per check, written on the night before and verified with its own command on the next night. the web lane's rows are left out.
over days 20 to 30: 47 held, 18 failed, 36 not exercised. a check not exercised is carried to the next night by id. a failure became an open item of that day's report. the instant morning check failed on days 27 and 28, its stamp withheld three nights running, and that is what moved the check into kickoff.
what the morning still handed to a fixer
the timeline's fixer table counts every non-web tier a model agent had to work, whatever the finish; the review treats each row as a tooling or prep defect. it exists for the last 8 reports:
| day | non-web tiers handed to a model fixer | which |
|---|---|---|
| 23 | 4 of 15 | binary time trial, metadata single, mobile time trial, script time trial |
| 24 | 2 of 15 | metadata time trial, warmups single |
| 25 | 1 of 15 | metadata single |
| 26 | 3 of 15 | binary single, metadata single, mobile single |
| 27 | 0 of 15 | - |
| 28 | 3 of 15 | binary single, metadata single, mobile single |
| 29 | 1 of 15 | mobile single |
| 30 | 2 of 15 | binary single, metadata single |
16 of 120 non-web tiers over those 8 days; every other tier ran on the night's solver alone. the organizer's one-off static challenge on day 30 is left out.
the gate
READY is one verdict over the committed tree. tools/after-action/nightly.py runs it as one command and stops at the first failure with one line of what to do: promote every winning run of the day that has no fixture, require uv run fixes pending empty (no rule left in a day's solver that hlib lacks), replay the day's fixtures with --tables (a search that stood in for a table row fails it), refuse an uncommitted checked path, then run autopilot.py --check. the check replays every lane's newest solver over all of its fixtures, runs the entry-script, web and preflight regression tests, and rehearses the next release offline, drills included. a pass writes sessions/ready.json, keyed on the tree of the checked paths: any later commit under them voids it.
the rule: nobody calls a night done before nightly.py is green, and it runs again after the evening's last commit by anyone. on race morning kickoff reads the stamp; a stale one starts the check detached, not in the parent's foreground.
the median of the check's own verdict lines in the session log (READY or NOT READY with its seconds), by the night it ran in. the check runs its steps in parallel, so it takes its slowest step: the offline rehearsal.
the check grew from 48s on night 13 to 335s on night 30, as the fixtures and the rehearsal's drills grew (night 13 is the first whose verdict printed its seconds). it printed 154 verdict lines over those nights and wrote 13 NOT READY headers with a time and a commit:
| when (et) | at | failing step | cause |
|---|---|---|---|
| 10-14 17:25 | 7963d5c7 | the rehearsal | not archived |
| 10-15 10:10 | 7ddee373 | the rehearsal | the located drill left a day-16 mobile mastery unflagged |
| 10-18 09:20 | f6871141 | warmups replay, the rehearsal | not archived |
| 10-18 09:39 | f6871141 | warmups replay | not archived |
| 10-19 15:49 | a59d9066 | every step | the check's shell could not open the uv cache |
| 10-21 11:13 | 3af5bd27 | every lane | a dependency download failed: no name resolution |
| 10-23 09:44 | 758ac3ab | mobile replay | the day-20 fixtures: no decoding path found in 20000 readings |
| 10-25 11:50 | 475f1093 | the rehearsal | not archived |
| 10-25 16:00 | 475f1093 | the rehearsal | the role drill left the day-26 binary tiers unflagged |
| 10-27 10:39 | ef13300c | the rehearsal | the step ran into its 300s cap; it got a cap of its own (dd27-9) |
| 10-28 12:10 | 2e8835fd | the rehearsal | the day's winning runs were not yet promoted |
| 10-28 12:55 | e56b1626 | warmups replay | missing row decode.DAY_CODECS[28] = 'reverse>hex' |
| 10-29 12:22 | 0f2f66b0 | the rehearsal, web regressions | the reader drill left the day-30 binary tiers unflagged; 4 web launch tests failed |
the rehearsal was the failing step in 8 of 13, a lane replay in 3, the environment in 2. every one was caught at the end of its day, not on a race morning. on top of the check, drillgate.py ran eight simulated releases each night from night 19 (a clean day, a broken single per lane, one broken mastery, a rate-limit window), every tier inside its budget: 8 of 8 on all 12 nights, the clean drill's board between +7.7s and +10.3s against a 15s budget. 125 simulation runs were deleted on nights 19 to 30 once their numbers were in the reports.
the stamp is what the morning reads. since it was keyed on the checked tree (night 24):
| morning | the stamp | what the release paid |
|---|---|---|
| 25 | covered | nothing: READY in under a second at 08:48 |
| 26 | covered | nothing: READY in under a second at 08:47 |
| 27 | two days old: an untracked file the rehearsal loads withheld it | 245s in the background, 08:51 to 08:55 |
| 28 | two days old: the night-27 check ran READY over the web lane's uncommitted edits and wrote none | no check before the release; the first ran at 09:05 |
| 29 | covered at 08:41, voided by a commit at 08:43 | 299s, detached; READY at 08:49 |
| 30 | stale: uncommitted edits under the checked paths | 331s, detached from 08:41:51 |
| 31 | covered | nothing: kickoff read it at 08:43:33 |
3 of 7 mornings found it covering the tree. the misses were never a failing check: a stamp withheld by uncommitted or untracked work, or voided by a commit made after it. day 28's release went out with no check at all, because no parent was alive to run one; that night moved the check into kickoff.
what we would change
- make the stamp automatic. 4 of 7 mornings did not find a covering stamp, each time for a commit or an edit made after the gate, never for a failing check. a hook that queues
nightly.pyafter the evening's last commit, by any lane, would have saved those mornings the 245 to 331 seconds and day 28 its unchecked release. - fix the class, not the instance. 83 of the 134 findings with a 'seen before' line (157 findings in all) named an earlier day or item. the renamed record magic is the plainest case: fixed for the overlay reader on day 20, missed by the config reader on day 30, missed again under a new magic on day 31. a recurrence should land as a test over the whole class on the night it is first seen.
- read the prompt and the questions from night 1. the look-ahead read enum values until night 30; both day-30 losses were named in that morning's text, and the audit that left 23 script and binary hints uncovered and 7 partly covered ran once, on the last night.
- start the gate when the fixes stop. on day 28 the fixes ran from about 11:50 to 17:54, the review from 18:21, and the stamp came at 21:24, twelve hours after the board closed. the gate's slow parts (the five-minute check, the twenty-minute drills) could run in the background while the review is written.
- budget the check before it grows. the check went from under a minute to over five, and its rehearsal step failed on its own cap on day 27. a check that grows with the days gets cheaper, not skipped: cache per tree, replay only the lanes a commit touched.
- build forward cases every night. night 30 carried 54 open items, the first forward matrix (a renamed magic in every carrier and member kind, every relation kind) and the prompt audit into one session. kept one day at a time they are small; built on the last night, they could only help day 31.
where the numbers come from
- library commits, fixture additions, the day table's and hint table's history, test counts at each morning and handler files:
git log,git show,git grepandgit rev-list, read-only. the repository starts on day 4. - fixtures: case directories under
tests/fixtures/dayNN/. - findings, open items, fixer tasks, drills and simulation runs: each day's
after-action.md,timeline.mdandchecklist.mdunderdocs/after-action/reports/; the prompt audit is day 30'sprompt-coverage.md. - the night-before checks:
docs/reference/future-checks.md's results tables. - who submitted each flag: the race-clock telemetry,
logs/after-action/telemetry/race_clock.json. - the readiness verdicts and the check's wall time: the archived session logs and
readiness-failed.logfiles undersessions/archive/,logs/comp/ready-check-day29.logandready-check-day30.log, and the kickoff logs; extracted once and kept inblog/site/night_shift.py.
{generated by a clanker}