Decisions

• Carry the bench apparatus into the platform and hide it behind an advanced toggle (rejected - the bench sections are instruments for building AFAL, not for using it, and a hidden instrument is still maintenance surface)
• Edit down to the four-section IA with an explicit kill list (chosen)

Rationale: The bench had grown six experimental sections, a 144 gallery and the Growth Generator - all apparatus for making AFAL work, none of it the platform someone uses afterwards. This is Q044's reduction applied to the interface: the panel gets simpler so the platform can grow. It is also the ruling that produced the day: the clean-panel HTML mockup built to explore this IA is what became the live preview, GLAS and the genome programme. Open within the taxonomy, recorded not resolved: Cone is built but absent from the tree and needs a home; the Growth FAMILY shares its name with the Growth GENE (T032 rules the gene's name; the family may need distinguishing).

• Keep the law in the float32 node graph and widen the fidelity tolerance (rejected - no float32 tolerance is both safe and useful for Phyllotaxis, and a tolerance wide enough to pass it would be wider than the drift the test exists to catch)
• Float64 Python for Phyllotaxis, float32 nodes for the helix species (rejected - two paths in one host is two implementations of one law)
• Float64 Python for the law in every species, nodes for instancing only (chosen)

Rationale: The Code Technician measured float32 divergence to size the Blender fidelity tolerance and found a structural fault instead. Phyllotaxis is not float32-viable at bench counts: with the mod-360 rule in place it still drifts 1.79 mm at 200 points and 14.4 mm at 800, and the bench's own EXTREMES demo carries an 800-point bloom, so this is not a corner case. The Specification Owner reproduced the figures independently before accepting them and matched the bench table to two decimal places. The cause is precision, not trigonometry. Phyllotaxis' golden angle of roughly 137.5 degrees makes the index-angle product large within a few hundred points - at index 800 it is 110,006 degrees, where one float32 ULP is 0.0078 degrees, arcing to 19 mm at that radius. The modulo was specified after the product, so it shrank the number without restoring what the product had already thrown away. That is a fault in the rule as written on 25 Jul, found by measurement, and corrected here. The helix species appeared to survive in the PROXY at around 12 micron - a figure the confirmation run below overturned; it is kept here only as the state of knowledge when this ruling was made. Module-scale error is negligible everywhere at roughly 5e-8. Worth recording plainly: the conformance test has not been built yet and has already forced a real architectural improvement in the Blender host. It also vindicates splitting conformance from fidelity in D205 - the fault lived entirely on the fidelity side, and a single blended test would have muddled a host's renderer with the laws themselves. CONFIRMATION RUN, real Blender 5.1.2 output against the canonical float64 law, engine version 8, same evening: the structural finding HOLDS and the proxy was optimistic throughout. Phyllotaxis measures 0.897 mm at 200 points, 7.18 mm at 800 and 321.6 mm at 5000 - about 1.2 times the proxy's figures. THE CONFIRMATION ALSO BROKE A SECOND FINDING. The helix species are NOT float32-friendly in real Blender; that was an artefact of the proxy, which modelled argument precision only and so under-predicted them by two orders of magnitude. Measured at 5000 instances and 30 m radius: Spiral 1.330 mm against a proxy 0.012, Shell 1.330 against 0.012, Hyperboloid 1.308 against 0.012, Cone 0.329 against 0.010 - a factor of about 110 on three of the four. Three of the four helix species therefore breach the millimetre that matters, and the rejected fallback of float32 nodes with a 0.1 mm helix tolerance would have missed by a factor of thirteen. That fallback was rejected on principle before these numbers existed, and the numbers now reject it on their own account. Small cases remain clean - Shell at 220 points and 11 m radius measures 4 micron - so the fault is driven by count and radius together, not by species alone. Scale error is float32 storage noise throughout at around 1.6e-7. SECOND CONFIRMATION RUN, same evening, closed the vertical gap: zResid, the vertical LAW drift, is micron-scale throughout and tracks prediction - Shell 220 at rise 0.03 measures 0.00029 mm, Spiral 5000 at rise 0.03 measures 0.0087 mm and at rise 0.30 measures 0.068 mm. Rise 1.0 measures exactly zero because every z is then an integer, exact in float32. The vertical axis multiplies index by rise ONCE where the angle multiplies index by step and then feeds transcendentals, which is why z stays benign while xy does not. maxXY tracked the first run unchanged, confirming the angle law is independent of Rise. One reporting distinction the bench drew correctly: the engine's constant z offset of minus half the height is gravity centring - PLACEMENT, not law - and was reported separately. The conformance comparison is on law-space output; a host's constant placement transform is declared and excluded. MECHANISM CORRECTED ON MEASUREMENT: the real graph is RADIAN-NATIVE with no reduction anywhere - float32(radians(step)) is inexact the moment it is stored, and that storage error rides up multiplied by the index. A radian-native emulation reproduces Blender to four decimal places, which is the proof. Two consequences sharpen the ruling: no node-graph patch can fix it, since two pi itself is inexact in float32; and the bench now holds a float32 emulator validated to four decimal places against real Blender, so future sizing questions need no Blender round-trip.

• Compare rounded strings exactly (rejected - rounding is discontinuous, so a value sitting a hair from a boundary flips on a 1 ULP library difference and reports a phantom failure; sin, cos and pow are not bit-identical across V8 and Python even in float64)
• Compare rounded values within one ULP of the stated precision (rejected - that grants a full millimetre of slack on lengths, which is exactly the size of drift the test exists to catch)
• Compare unrounded float64 within a tolerance far above library noise and far below the precision that matters (chosen)
• Write every gene always, inert ones included (rejected - an inert value in the file is a lie about what determines the form, and it is the T032 disease written down: a gene that appears to act and does not, or worse, one a later language version quietly activates)
• Write only the species' active genes (chosen)

Rationale: The tolerance was sized rather than guessed. One float64 ULP at 30 m is 3.553e-15 m, so a 1e-9 m tolerance sits about 281,000 times above the noise a runtime's maths library can produce and a million times below the millimetre that actually matters to a building. It cannot hide real drift and it cannot manufacture a phantom failure. Comparing before rounding also removes the discontinuity that caused the problem: rounding is a cliff, and any test standing on a cliff edge will eventually fall off it. The module ruling is the language-free principle earning its keep. The format was told never to enumerate genes, and the moment a specific gene needed a home the answer was already written: it goes where the language defines it. No amendment to the format was needed at all. Writing only active genes follows from sufficiency, which already demands that a genome contain what is needed to rebuild the form and no more. The obvious objection - that a later language version might activate a gene the old genome lacks - is answered by the language version already pinned in every file: a genome is rebuilt by the version that wrote it, which is why that field exists.

• Seed authoritative, host re-rolls parameters from it (rejected - it needs the per-species windows, which are not in the file and live in the language file where they are tuned over time, so the same genome would silently mean a different form in a later language version; fatal in a memory platform, where a genome recorded in July must rebuild identically in 2031)
• Both authoritative, host chooses (rejected - two encodings of one form is how they disagree)
• Parameters authoritative, seed kept as provenance and breeding input (chosen)

Rationale: The Code Technician's review found the fault: the draft carried both resolved parameters and a seed, encoding the form twice without saying which wins, and that ambiguity decided what the conformance test would actually execute. Sufficiency settles it. The format already requires that everything needed to rebuild the form exactly is in the file; a seed is only sufficient alongside the per-species roll windows, which are language-file property and change as species are tuned. Parameters are inert and dated - they mean the same thing in 2031 as tonight. The ruling dissolves a second bench flag as a side effect: with parameters authoritative, mulberry32 against Python's Mersenne Twister and the exact draw sequence stop mattering for rebuild, and become a breeding problem to be solved when breeding revives. The float32 flag was verified rather than accepted on description. At 5000 instances and 30 degrees a step, one float32 ULP on an accumulated angle of 2618 radians is 2.686 mm of arc at 11 m radius, so 'match exactly to the millimetre' could not have held. Reducing the angle modulo 360 first brings the same case to 0.005 mm, a factor of roughly five hundred, which is why the fix is a pinned evaluation order rather than a tolerance. A tolerance would have hidden real drift; an evaluation order removes the cause.

• Genome carries no parent, biology-faithful, lineage stored separately (rejected - it makes a genome a specimen, and a design memory platform whose genomes cannot say where they came from has sacrificed its premise for metaphorical tidiness)
• Genome carries its full ancestry inline (rejected - every child duplicates every ancestor, files grow without bound, and the same history is then stored in as many places as there are descendants to disagree)
• Genome carries parent, lineage id and generation; full ancestry derived by walking the chain (chosen)

Rationale: Miles ruled it by naming where GAAD parts company with the metaphor it borrowed (Q046). In biology a genome carries the result of inheritance, not a pointer to the ancestor, and ancestry is reconstructed from similarity afterwards. GAAD breaks that on purpose, and the break is the platform: Q043 states the thesis as a journey, and a genome with no parent has no journey, only a shape. The borrowing rule this sets for everything downstream: GAAD takes the MECHANISM from biology - genes, mutation, selection, generations - and refuses its amnesia. It also unblocks the roadmap. Parent and child brought to life, a 2x2 growing to 12x12, and film scenes built in HTML are all lineage work, and all of them were waiting on this answer. F053's export champion gains its best version too, since a champion that reaches Revit carrying its ancestry is design memory entering the industry's model rather than staying inside GAAD.

• AFAL Live Preview, the bench's working name (rejected - accurate today and wrong by autumn, since lineage, the world grid and film scenes are all coming to the same surface and none of them are AFAL; and 'preview' says not the real one yet when the page runs the real laws)
• The Growing Room (the Specification Owner's lean - sibling to F031's reading room, plain, needs no explanation)
• GAAD Live (rejected - says it runs, says nothing about what it is for)
• GAAD Glasshouse (chosen by Miles)
• Short form GG (rejected - already means Growth Generator in seven places across the records; two meanings for one abbreviation is exactly the rot a thirty-year record cannot afford)
• Short form GLAS (chosen by Miles)

Rationale: A glasshouse is a real building type, which suits a platform made by an architect, and it is the building made for growing things - which is what the surface is for, whatever language is running. It is also made of glass so you can see in, which is what a browser is and what GAAD claims about itself: the journey should be legible, not sealed inside a .blend. The name had to survive what is coming. Lineage, a 2x2 growing to 12x12, and film scenes built in HTML are all headed for this page, and a name naming today's first tenant would have had to be thrown away. Q045 settled that AFAL is a testing ground rather than the point, so the name stays language-free by the same rule that keeps GALF engine-free. Miles widened the definition the same evening: GLAS can be on the web or in Blender, and one day GLAS-in-the-product. That makes GLAS the constant across every host GAAD will ever have, with Blender as scaffolding, the web as reach and the product as the endpoint - which is P054's renderer-as-adapter argument one level up. It also carries P054's licence consequence: GAAD as a commercial product is only possible outside Blender's GPL, so a surface that already runs host-free is what makes that road passable. Everything GLAS depends on must therefore be host-free too, which is exactly what D202 requires of the genome and GALF requires of the language files. Miles then named a fourth host of a different class: GLAS-in-Revit. The first three are GAAD's own; Revit is Autodesk's, closed, with its own API, units and geometry kernel, so embedding there demands portability rather than mere host-freedom. It is also the host with the most commercial weight, putting generative form-finding where architects already work, with nothing unfamiliar to install - and it is the ground Miles has led BIM on for twenty years. The scale ruling made the same evening is what makes it practical: building-size objects stated in metres to millimetre precision is BIM's native tongue, not Blender's, so a GAAD genome lands in Revit already speaking the language. The cost to weigh is that every host multiplies the number of places the growth laws are implemented, which makes D202's single genome and its same-file-same-form test more load-bearing with each one, not less.

• Let the web write its own JSON now and reconcile later (rejected - that is the drift being cured, moved up one level and made harder to see)
• Adopt the bench's existing specimen shape as it stands (rejected as the whole answer - cheapest, but the shape grew inside Blender and would carry engine-shaped assumptions the web must then honour forever; it is still the input the neutral format is derived from, so nothing is lost)
• Define one neutral genome format, derived from the existing specimen (chosen)

Rationale: F052 put a second copy of the AFAL growth laws into the world, in JavaScript beside the add-on's Python, and two copies drift. A website showing a form Blender will not reproduce breaks the one promise GAAD makes. The genome file is what ends that, because it makes agreement checkable instead of hoped for. It is also the floor under everything Miles wants next on the web surface: a child is a mutated genome, a stage in a 2x2 or 12x12 world is a genome, and a film scene is a sequence of genomes. None of the lineage, world or film work can start cleanly until the file exists. The concept is not new here and must not be reinvented - D139 already ruled that the remembered circle on the Navigator lineage IS a genome, and AFAL specimens already carry their genes at the bench with count stored beside scale since D197. Curing drift in the laws while inventing a second format for the file would be the same disease one level up.

• Re-chrome the bespoke timeline pages to match the Hub and cut their ~30 category filters (rejected: keeps two record formats to maintain forever, the duplication GAAD exists to remove)
• Delete the timeline generators outright (rejected: gaad_build.py imports them to write the bundle's own Records/ copies; deleting breaks the build - retire the web output, not the code)
• Retire the timelines from the website, Hub becomes the single view, redirects preserve old links (chosen)

Rationale: Two faults drove it, both Miles's: the timeline pages carried foreign chrome (different fonts, no site header) so navigating to them jumped/shook the layout (T031), and their filter row had grown to 30-plus per-category buttons. The Hub already fixes both - site chrome, a clean type-filter row, plus a search box the timelines never had - and one source of truth is GAAD's founding instinct, the same reason the diary got one page and one format. Detail is not lost: the Hub's rows expand, and the graph dots now land on the exact record, searched and highlighted.

• Drop Sphere (rejected: it makes the beaded forms Miles called GG twigs)
• Keep Sphere with Cube as default (chosen)

Rationale: Cube reads best for the accumulating twisted-blade forms; Sphere strings a growth into beads and is kept for when that is wanted. Sphere arrived in v3_024 and was fixed in v3_025; the fix also exposed and closed a long-masked no-op in the GG value writer. Drafted at the bench as DR-2.

• Spaces between the words (rejected: breaks the add-on module name and shell tooling)
• Underscore-joined words after the version (chosen)

Rationale: The version history reads at a glance without opening each file. Underscores keep the filename a valid Python module name. Drafted at the bench as DR-1 in the first daily handover zip; filed by the Specification Owner per the pipeline.

• Bench Engineer (the working name it carried for its first day; a real title in hardware/electronics; retired on the ruling)
• Clerk of Works (Miles's joke, briefly misfiled as a ruling and reverted the same hour)
• Resident Engineer / Site Engineer / Field Engineer (construction titles for the engineer stationed where the work is; Resident Engineer was Claude's lean)
• Build Engineer / Toolsmith (IT alternatives; Toolsmith from Brooks's surgical team, 1975)
• Code Engineer (rejected for the collision: the Specification Owner also writes code - what separates the seats is ground, not code)
• Code Technician (chosen - proposed by Miles himself)

Rationale: The name does the governance by itself: in Miles's industry a technician executes, details and verifies under a professional's direction and never signs the design, which is the seat's remit to the letter. It is also the founder's own first title - GAAD began with the instinct of an architectural technician, and the newest seat extends the same word. The precedent is the film seats: when work needed different hats, seats were ruled for it without touching platform governance. Drafted at the bench as DR-1, the first record to travel the handover pipeline (bench drafts with placeholder ids, Miles carries, the Specification Owner files) - the draft correctly refused to guess record numbers.

• Leave s7 as scale_i = growth^i and show the tip scale live in the panel (rejected as the whole answer - honest and cheap, but it makes the coupling visible rather than removing it; kept as a rider, inverted to show the per-instance figure)
• Leave s7 and bound Growth by the current count (rejected - makes the dial safe but the same number still means a different form at a different Population)
• Reparameterise Growth as the total end-to-tip ratio (chosen)

Rationale: Growth and Population were not independent. The tip was growth^(count-1), so Population sat in the exponent and one dial meant a different form at every count. Two faults followed. Above 1.0 it ran away, which is why Growth was capped to taper only on 23 Jul. Below 1.0 most of the travel was dead, because a visible tip needed above 0.954 at count 50 and above 0.995 at count 500, which is why three modes had to carry three different windows for one dial. Under a total ratio the runaway cannot return, since a ratio is bounded by definition, and the whole dial is usable at any population. The consequence Miles weighed and accepted is genetic rather than cosmetic: mutating Population no longer changes the taper. Count changes length, Growth changes taper, and the genes stop fighting, which is what makes the crossover landed on 23 Jul mean anything.

• Keep the 12x12 world as AFAL's primary form and grow capability inside it (rejected - every capability is paid for 144 times, so the honest budget per stage stays tiny, which is why the forms are cubes on a line rather than architecture)
• Build AFAL's own selection, crossover and lineage so a population can be bred inside the studio (rejected - duplicates machinery GAAD already has and PRAL and TWAL already rely on)
• Single stage as the working default, 144 retained as an optional harness (chosen)

Rationale: Miles's word: 144 stages was always an odd ball, GAAD can already choose any grid and one day nxn, and when AFAL connects to GAAD only one stage has to work. PRAL and TWAL carry no population machinery of their own; they say what one stage is and GAAD does the rest, so AFAL should be no different. Two things follow. The per-stage budget stops being divided by 144, which is what makes the swappable module, the growth-behaviour library (F044) and the fidelity the nature research needs affordable at all. And it is the shortest route off the T4 ceiling, because T5 is the connector and a connector only ever needs one stage, which is what the engine already is once the world wrapper is removed.

Rationale: A renderer must not iterate a string as a list. The convention is a list (157 of 178 non-empty), but strings are schema-valid and prose options read as paragraphs, so the renderers handle both rather than forcing the twelve into lists.

Options considered: Hand-write AFAL's page (rejected: another orphan, breaks JSON-as-truth); build the renderer on the tech-spec pattern (chosen).

Rationale: JSON is the source of truth; the page is a view of it. Sourcing chrome from a sibling keeps AFAL consistent with the others. Remaining A0014 work: regenerate the other six pages through it (eyeball-compare first) and wire it into gaad_build.py with the conformance table.

Options considered: Hand-add AFAL's box and re-space the packed SVG (rejected: unverifiable, stays hand-maintained); generate the boxes band (chosen). The rest of Figure 1 stays static illustration.

Rationale: Completes D192: no hand-drawn language figure remains on the site. LIVE reads from platform_status active; boxes fit dynamically, so a new language needs no hand-editing.

Options considered: Hand-add AFAL as a seventh column to the packed SVG (rejected: unverifiable reflow, and it stays hand-maintained and drifts); keep amber by inventing a status field (rejected: not a field in the files, would be hand-decided per language); generate from the language files and drop amber (chosen).

Rationale: Generate-from-source kills the staleness permanently and makes the figure's own 'read straight from each language file' note finally true - the picture becomes a view of the data, not a second copy that drifts. Amber dropped for honesty: one rung per language (D165); a nuance with no home in the files has no place in a generated figure.

Options considered: Stop at T3 (understates it - the prototype demonstrably runs); promote to T4 (chosen); go higher (rejected - no connector and no GAAD integration, so T5-T7 would be false).

Rationale: The rung is earned on evidence, not granted for time: rungs 1-4 are each genuinely met. T4 is the honest ceiling until AFAL has its own connector and runs through GAAD rather than standalone.

Options considered: File the technical-truth doc as-is on the developer's word (rejected: technical truth must be checked against the code before it becomes rule); verify then file (chosen).

Rationale: Every material claim in the doc checked out against AFAL Studio v0.2.3, so the implemented behaviour is safe to file as rule; proposed items are intentions, not rule, and stay separate. Rung stays T2 - the rules are now precisely formed and code-matched, but T3 (formal three-seat agreement) is the Chief Architect's call and the prototype already runs, so a T3 ruling would carry AFAL to T4.

Options considered: Bank only s11/s18 and leave the array/mirror grammar (rejected: Evidence about spirals would contradict Rules about arrays); reconcile the grammar to the engine (chosen, since code and research agree on it).

Rationale: T1 is source material checked, and six sources were read at relevant-sections depth (P063 bar). The reading grounds AFAL's core and, with the code, fixes the grammar mis-filed at birth. Rung stays T2: rules now correctly formed on verified T1, but T3 needs formal three-seat agreement and the prototype sits ahead of the rung. Specification Owner and Architecture Reviewer both recommend T2.

Options considered: Expand ARAL's panel with 3D-form menus and promote parts to T7 later (rejected: the TRL ladder is one rung per language, so a part cannot hold its own rung while inside ARAL); make the form generator platform engine with no rung (rejected: a rung-bearing language was wanted); a new language AFAL (chosen).

Rationale: The readiness ladder (D165) is one honest number per language, so promoting part of ARAL is not available while the part sits inside ARAL. A separate language gives form its own rung and keeps ARAL about emergence, avoiding hollowing ARAL to a catalogue. Miles's call, 22 Jul 2026, keep it simple in the spirit of GAAD.

Options considered: Add only 12x12 (leaves a 9->12 gap in the ladder); add 10/11/12 (chosen, no gap); make grid size a free integer (rejected - the enum documents and constrains the tested set).

Rationale: Same class of bug as the generator's own historic cap-at-5, which silently degraded 6-9 until widened to 9. Centralising the allowed set on the enum stops the next preset addition from hitting a fourth hidden guard. Proven in Blender: a full 144-stage 12x12 world bred in 1.8s across PRAL and TWAL.

• Migrate all six languages now
• GALF v0.008 first, then the generator, then one language at a time
• Leave the contract as it stands

Rationale: Miles read MHAL's s4 and s6 against the contract and found no common framework across the languages. The measurement backed him: sections were addressable only by guessing each file's key names, content sat in x_ extensions because no section claimed it, and the conformance table was typed by hand and rated MHAL v0.004 while MHAL was at v0.006. T030 opened the same day on the missing vocabulary. Contract first, because six files claiming conformance to a contract that does not ask for the spine would be reworked when it does.

• Leave discovery to chance and links from LinkedIn
• Add the in-file layer and measure via Search Console

Rationale: EP5's publish showed shares landing without preview cards and Google finding the site by luck: only index.html had og tags, no sitemap or robots existed, and titles carried no phrases people actually search. The layer costs nothing visible - the voice of every heading is untouched - and Search Console turns traffic into ground truth the same way the records do for development.

• Publish the personal diary as a new Diary section replacing Daily; hold the technical diary
• Publish both diary pages
• Keep diaries private and leave Daily as is

Rationale: Freshness came up while reviewing how to attract more Google traffic: the site updates only when an episode lands, while the diaries are written every session and are the purest form of the site's premise - the process shared as it happens. Daily stopped at 10 Jul and a visibly stalled log reads worse than none. Raised by Miles on 17 Jul; recorded open for his word on the shape.

• Fix the wrong numbers by hand
• Derive both numbers from the language files

Rationale: Miles found architecture.html saying Five languages in its heading while its own card grid said Six, and asked for the number to be a parameter so the two can never disagree and a seventh language changes them everywhere. The same disease as D177: a count that existed only as typed prose had no source, so nothing could regenerate it and nothing could check it. Checking also found the bundle's Website folder behind the 1_017 publish - the source and the publish had swapped places - and the pages were synced back before the fix was applied.

• Two separate panels in the same tab
• A second script registering its own panel
• One parent panel with two collapsible sections

Rationale: Miles asked for the prototype to be preserved as is in a cascade menu with the study added beside it. Separate namespaces were not a preference: with the names as first written, one press of Clear MHAL would have deleted the whole study. The offset going to zero is the point of the pairing - the invented block and the measured one land on each other, and the question of whether the prototype's 244 m x 80 m block should adopt the verified 60.96 m depth stops being an assertion and becomes something you can see. That question is open.

• Tighten the frame - a rotated box aligned to the 29 degree grid
• Accept the overshoot and say so in the read-out
• Filter by the city's tax block and let the frame only find it

Rationale: The Upper West Side block returned 216 parcels. Filtered to the city's own block it holds 90, so more than half of what the frame caught belonged to the neighbours. The cause was geometry, not data: a north-aligned box around a grid tilted 29 degrees east of north scoops in the corners of the blocks around it, and on a 213 m west-side block that is 47,500 sq m of box around 13,006 sq m of block - 3.7 times the thing it was meant to hold. Midtown East's short Lexington block hid the fault at thirteen lots. A tighter frame would have been a better calculation; the BBL is not a calculation at all. It is the city's definition of exactly this block, so the evidence grade moves from Calculated to Verified and the tolerance stops applying to membership.

• JSON only - no links, the addresses are enough
• Address-derived search links only
• Search links plus ZoLa, Street View and a historic atlas layer

Rationale: Miles asked for the links and named the historic layer as the one he wanted most: this is emergent by history. The block descriptions were already carrying the claim that the grid persists while parcels mutate; the links let anyone check it in one click rather than take the file's word. ZoLa needed block geometry rather than an address, which is what drove the frame work recorded in the language file as zola_bbox_evidence. The historic layer stalled on research - NYPL archived Map Warper in April 2021, and the plate lookups need the atlas index map read by eye. Miles halted it: no more research on this.

• Real parcels as MHAL input - the genome fills surveyed lots
• GIS as context geometry only - a backdrop the AL respects
• GIS as a study set - measured reality beside the invented world

Rationale: Miles's words: not real, but we can lean from what there is existing. The distinction is the whole value. If real parcels became input, MHAL would stop inventing and start tracing, and the language would be judged on how well it copied. As a study set the real block does the opposite job: it gives the invented block something honest to answer to. It also keeps the data out of the platform - the study is research-side under D170, so no addon, no records, no D161 gate. Manhattan only for now: MHAL already carries the verified 1811 grid, so the Commissioners' plan and what got built on it can be read against each other.

• Leave it - five records, cosmetic
• Make the generator defensive against unknown values
• Enforce the vocabulary at the validator

Rationale: Found because Claude wrote paragraphs into origin on all eight of 15 Jul's decisions - the longest 402 characters - and the generator rendered each as a pill that ran off the side of the card. The validator could not have caught it: it checked that a field was non-empty and never checked what was in it. Claude had diagnosed exactly this failure four hours earlier, in this same session, and then walked into it. The eight also fell out of the page's header count, which reads by origin - it said 87 new when the truth was 95. This is the lean beachhead for the wider vocabulary problem, because origin needed no agreement: its list already existed in the colour map. The feature statuses are the hard case - 11 values across 39 records, including 'in-progress' AND 'in progress' - and they still wait on Miles, because 'built' versus 'adopted' is a judgement, not a typo. Note the two categories that had drifted apart in plain sight: '2026 Rebirth' and 'rebirth' meant the same thing and were counted separately for months, and '1994' had never been coloured because the map was behind the data. Neither was visible until something forced a look at the field.

• A standing rule in SKILL.md to update the numbers by hand on every web update
• A generator that reads the record JSON

Rationale: Miles asked for the homepage graph to be updated and added a standing rule: remember to do this on all web updates, as dates need to be current. Checking the page found the stat cards claiming 157 decisions against a live 172, and 84 terms against 94 - a drift of fifteen decisions that no tool could have caught. The homepage was the one part of the estate with no source: the numbers existed only in the HTML, so nothing could regenerate them and nothing could check them. That is why they drifted silently for fifteen decisions. A rule that depends on remembering fails on the first busy morning; this brings the homepage under the same JSON-as-truth discipline the records have always had. Open: the script sits in Scripts/ and is not called by gaad_build.py, so it has no Validate step and has not been through D161.

• FWAL to T4 on the strength of a generator that runs, with an infancy note like MHAL's amber
• FWAL stays T3 until a panel exists

Rationale: A FWAL generator script written on 15 Jul rolls compositions from the verified 12 ft bay module and passes its own conformance checks, which by D165's words is T4, Prototype runs. Adding readiness pills to the website forced the question. Miles's call. Promoting FWAL would have made T4 mean two different things depending on which language you looked at, and the ladder would have stopped measuring anything. It also removes a second problem: the FWAL generator lives in 4_Research, which by D170 never enters Live, so FWAL's T4 would have rested on a script the platform will never ship.

• Pill reading LANGUAGE, rung, version
• Pill reading rung and version only - the language name is already the card's gold tag

Rationale: Miles asked for the language HTML files to be added to the website and the card pills to show status and version. Miles's call on both. Naming the language in the pill said it twice and made the pill too long to sit on one line. Sourcing rung and version from the language file means the website cannot drift from the language files, which is the same JSON-as-truth discipline the records already hold. The colour is the readiness ladder made visible at a glance: two gold, two cyan, two light grey.

• Keep the reserve, matching the main generator's stage convention
• Drop it - ARAL draws no labels, so the strip is dead space

Rationale: Miles saw an empty strip at the front of the ARAL stage and asked why objects avoided it. It was the LABEL_RESERVE, 24 m, carried as-built from generator v0_56 into the ARAL prototype: Y placement ran +32.5 back but only -18.5 front. Miles's word: that is a bug, I never requested this, there is no text label. ARAL never draws front labels, so the reserve reserved nothing. It was inherited rather than chosen - the clearest example yet of a convention travelling into a language that had no use for it. Existing tapes recorded under older versions keep their old positions; the rule shapes new generations only.

• Keep Pause alongside Stop
• Retire Pause, put Forward in its slot

Rationale: Miles: the pause button serves no purpose as we have a stop button. Miles's call, and correct: Stop already covered everything Pause did. The tape had Rewind but no Forward, so the playhead could only be stepped in one direction - an asymmetry nobody had noticed while Pause occupied the slot Forward wanted.

• Tape OFF only - the record traded for raw speed
• Buffered commit only - a free win, but the rebuild cost remains
• Both

Rationale: Miles asked whether removing per-generation storage would let Mutate xN run visibly faster. Reading the code found two costs: the scene rebuild per generation, and _hist_push copying the entire history list each generation - a cost that grows with tape length. Both, because they solve different halves. The buffer removes a cost that grows with tape length and takes nothing away - full tape, full Scrub. The radio gives the sprint mode Miles asked for and is honest about what it costs: an unrecorded run has no Scrub, no Rewind, no replay. Greying the Scrub during an untaped run prevents the worst failure, where the slider drags a stale tape under a live stage.

• Local-only, never travels, one line in CURRENT_ACTIONS pointing at the folder
• A fifth zip carrying its own index and audit trail

Rationale: D170 kept research out of Live, which meant research would not travel: the zips are the session context transfer, and a ring fence note written on 15 Jul would have reached nobody. Research Pass 001 proved the need in a single document: its B5 rows were Verified from a named source, its A rows Extractable, its C rows Unknown. One document-level status would have had to lie about two thirds of it. Section-level status has precedent in D131, where each Tech Spec section carries its own date. Open: whether the zip carries its own JSON-to-HTML builder or the index is JSON only.

• An eleventh record file and tenth Hub tab, with per-section verification status
• Research kept entirely outside Live

Rationale: Miles proposed a Research record category to capture 4_Research with document- and section-level verification status. Reviewing it exposed that the evidence vocabulary FWAL uses (Verified / Derived / Supported interpretation / Approximate / Unverified / Unknown / Extractable) lives inside one language file as x_evidence_vocabulary, and a platform record type cannot borrow a language's private terms. Miles's call. Nothing in 4_Research makes a platform claim, so nothing there needs the platform's gates. Keeping research out of Live also kills the promotion problem the record type would have forced: FWAL's evidence vocabulary can stay experimental and language-local instead of being promoted to GALF just to serve a records feature. The same instinct that keeps the ARAL bench out of the Connector keeps research out of the records.

Options considered: 1 - reinstate the v1_018 wording verbatim: honest and already proven, but longest, and truncates in a narrow panel. 2 - reinstate tightened, e.g. '16/64 placed, 48 no room, PASS': same information, fits better, but new wording to agree. 3 - leave it out: rejected - the readout is the answer to a real question Miles asked twice, and its absence is what let the same discovery be made by eye.

Rationale: Found while reconciling the ARAL version collision (T027) - Miles had rediscovered by eye a behaviour the previous session had already built a readout for. Worth recording rather than just fixing, because the readout has already proved its value twice over. It was built to answer 'why did I ask for 60 and get 16?', and the same session it went missing from the working chain, Miles reached the same conclusion unaided by watching Harmony refuse to place objects that had no room. The panel should not make him re-derive what it already knows. The wording tension against the shorten-the-status request is a genuine design question, not a typo, so it is his call rather than a silent fix.

Options considered: A - flat Code/ with all scripts together (chosen): simplest for a single tool launch point; language is already carried in the filename prefix, so nothing is lost. B - Code/ with per-language subfolders: preserves the existing grouping but adds a level for no gain once filenames are prefixed. C - split inside each workset (aral_development/Code + /Blender): keeps the wall but defeats the single stable launch point, since each workset would need pointing at separately. Miles chose A after testing it against his own one-version-per-chain habit: retired versions are swept to Superseded, so Code never accumulates hundreds of files.

Rationale: Miles, working session - the ARAL edit loop had become a dozen download-and-drop rounds in one day. The wall is the point. Git and Claude Code are excellent for text and poor for large binaries, so the line between 'in version control / editable by tools' and 'never touched' is exactly the line between text and .blend. Trusting a tool not to touch a .blend sitting next to the .py is thinner protection than making it structurally impossible; the folder layout enforces what a promise cannot. The restructure also surfaced that the mixing had already begun - a stray aral_prototype_v1_006.blend was found inside aral_development/Superseded and moved to Blender/. This resolves the SEPARATION half of D166.

Rationale: Building a per-generation history inside the ARAL prototype (to support Rewind) duplicates the platform's lineage system in miniature. That is acceptable as prototype scaffolding - it unblocks real-time exploration of emergent mutation behaviour today (Q038, the first real-time run) - but it must not harden into a parallel history that competes with GAAD's Navigator once ARAL graduates. Recording the boundary now prevents accidental double-build later. Miles's call, 14 Jul 2026. REVISION: the transport turned out to reveal a genuine platform interaction (a playback head for the lineage), not just a prototype convenience. Recording it as graduating (via F036) rather than disposable, so the proven interaction is carried forward not rebuilt from scratch. Miles's call, 14 Jul 2026.

Rationale: The manual zip-shuffle workflow has produced real friction this session: duplicate bundle folders piling up in 1_Live (0_131, 0_132 x3), a stale website publish two nights ago, diaries buried inside the working zip, and overwrite anxiety on the working folder. These are symptoms of moving a versioned codebase by hand. The separation question, the arrival-automation question, and the version-control question are one cluster and should be decided together rather than piecemeal. To be discussed with Miles: Git/GitHub for true version history and safe merges; Claude coworker / Claude Code and other AI tooling for reducing the manual handoff. No change adopted yet - this records the open thread so it is not lost and is decided deliberately.

Rationale: The language/prototype/contract picture had grown into three overlapping tables that were getting messy to hold. Computer science solved this with readiness ladders (NASA TRL, adopted across defence, energy, healthcare, aerospace) - one scale, common language, gates on rungs. Folding GAAD's stages, its two contracts and its QA step into one TRL scale makes each language a single honest number and sets up a future where the level is a real field each language file stores and the website derives its status from, rather than a hand-typed label (the D151 aim). Adopted NASA's TRL name and scale at Miles's steer, 13 Jul 2026. TRL kept as the standard name rather than a bespoke acronym so a technical reader recognises it on sight; scale starts at 1 to match readiness-scale convention; rung names expanded to 2-3 words so each reads as a clear achievement; an amber state marks present-but-unverified (MHAL prototype), so the ladder is honest about what has been seen to run.

Rationale: 'Dormant' collapses two different situations: a language with nothing built, and a language with a prototype already generating form in Blender (ARAL was breeding live tonight). The site was truthful but incomplete - it hid the prototype layer. A small factual note closes that gap cheaply and honestly without touching the status vocabulary or the schema. Agreed by Miles 13 Jul 2026, 20:12.

Rationale: The published page pre-dated TWAL's graduation and showed stale/ mixed statuses (TWAL Dormant, PRAL 'ACTIVE', descriptor pills that were not statuses). The page promises status shown honestly straight from each language file; two clean states delivered on that and stop a descriptor being mistaken for a status. Recording the change keeps the site and the records in agreement and prevents a future publish reintroducing the tails. Changes approved as rendered images by Miles, 13 Jul 2026.

Rationale: Following the build publicly is only measurable with basic audience data. Injecting the tag at source keeps it consistent with the platform rule that outputs are generated, not hand-edited, so no page is missed and new pages are covered by default.

Rationale: The AI seat cannot run Blender, so the proving run only executes on Miles's machine. Four versions shipped tonight that Validate would have failed instantly. D135 built one assert library for exactly this; the discipline of reading it pre-release was missing. 24 seconds of Validate beats an evening of cascade debugging.

Rationale: Surfaced when TWAL ran through GAAD at 6x6 (D158): the 40-tower city per stage read as clutter across a large grid, exactly the 'development zone may become cluttered' concern from the 1994 thesis (Fig 3.10). Density was accepted for now (Miles, 12 Jul), but the tower-to-grid relationship is unresolved and should be decided before TWAL evolution work continues.

Rationale: Rule 7 was written when a session was one workset (one fenced language). That is no longer true - today's session touched ARAL, housekeeping, panels, folder structure and TWAL. Filing the diary inside one language folder miscategorised a whole-project record.

Rationale: TWAL reached full platform parity on 09 Jul (24/24 validate). Graduation was held until a through-GAAD generate was proven, not assumed - the honest bar for lifting a fence. Confirmed working, so banked.

Rationale: D154's prohibition alone could read as isolation. Composition is a positive rule of its own: it keeps each language the single honest authority on its concern while letting the family build at every scale - and it matters at Connector level, where cross-language invocation will need declared relationships to ride on.

Rationale: Generalises to every future seed, including ones where no code ever existed (a canvas, an animation). The behaviour is the language; the implementation is the era.

Rationale: Captured after each was needed in-session 11 Jul 2026. Written into HANDOVER and SKILL.md.

Rationale: Keeps 's5' unambiguous - always GALF section 5, never a research block. Matches how the GALF spec refers to its own sections.

Rationale: Miles: 'this does not mix languages'. ARAL will have a life of its own, a Latham-lineage generator the ambition. Version lines restart per language (D149).

Rationale: Consistent units make cross-language comparison and generation reliable and stop both false precision and lost precision. Adopted into GALF s18 (D152). Contributed by Miles.

Rationale: Generalises Honest Geometry (fake no geometry) to Honest Knowledge (fake no confidence). Proven in FWAL and MHAL before adoption. GAAD's first contract amendment through the full three-seat process (D140). Ratified by all three seats 11 Jul 2026.

Rationale: The Architecture page promises status shown honestly, straight from each language file - 'genome' broke that promise. DORMANT is the display face of the stored vocabulary, permitted explicitly by the GALF v0.005 friendly-label provision, and reads better to a first-time visitor than 'unintegrated'. Settled by Chief Architect + Specification Owner, 11 Jul 2026.

Options considered: Write .cel files per champion; export-on-demand verb; keep CEL embedded only (status quo).

Rationale: Miles, on discovering the CEL field live in stage files the same day TWAL connected. The CEL data exists and replays correctly from inside stage files, so standalone files are sentiment plus interoperability rather than necessity - but the 1994 echo has real narrative and archival value. Held rather than decided.

Options considered: Platform-wide rename (rejected: breaks links and provenance); keep the zoo documented (rejected: defects remain); dotted versions in filenames (rejected: Miles - no dots or hyphens in names); capitalised names (rejected: case-sensitivity risk, no benefit).

Rationale: Miles + Specification Owner working session, 10 Jul 2026 (queued from the TWAL wiring day). Seven version schemes were in live use, with two real defects: lexical sort breaks on unpadded versions (v0_9 vs v0_18), and the same artefact spelt two ways (connector 0.6 in-header vs v0_6 on disk) taxes every cross-reference. Lowercase kills the Linux case-sensitivity 404 class on the website. Underscore-only keeps names shell-, URL- and pipeline-safe. The contract/versioned split states what the platform already practises (fixed palette, versioned generator). Orbit scoping avoids breaking published links and recorded provenance. Second edition checked against industry and research-data-management standards (10 Jul 2026): snake_case all-lowercase is the established best practice in data engineering and the Python ecosystem; version-as-last-element, leading zeros for sort order, ISO 8601 dates, concise names, and documenting the convention beside the files are all standard guidance (UBC RDM, Harvard HMS, Stanford Libraries, PEP 8 norms). D149 adopts the standard rather than inventing one; the only local strictures are no-hyphens (consistency over kebab-case) and the 30-character tightness.

Rationale: One wrapper written once beats five written differently: replay depends on the envelope fields being uniform across languages, and per-language envelopes would be five chances to break design memory. The payload stays language-owned so the envelope adds no coupling.

Rationale: GAAD's records are only worth what their honesty guarantees; a status nobody enforces is decoration. The grandfather clause keeps the rule strict without falsifying PRAL's real, working status - one honest exception beats a loose rule, and the port ticket makes the exception self-erasing.

Rationale: Keeps both contracts honest about what they are: GALF cannot own a runtime interface without breaking its own neutrality rule (the T021 finding), and merging them would couple the language definition to the platform runtime. Matches D145's discipline of keeping distinct senses apart.

• Page named 'Architecture' (bare) - rejected: ambiguous across the two senses
• Page named 'Framework' - rejected: collides with GALF, which is the framework
• Rename GALF -> ALF and add Core/Foundation/Fabric (Reviewer suggestion) - rejected: costly rename + unneeded nouns
• Page named 'The Architecture' (capitalised, system-structure sense) + keep GALF - chosen

Rationale: Raised by Miles from architectural-school usage ('what is the architectural language of Fallingwater') versus the computing sense ('the architecture of how hardware and software connect'), prompted while building the website language/framework page. ChatGPT (Architecture Reviewer) proposed ALF + Core/Foundation/Fabric. GAAD's own name (Genetic Aided Architectural Design) already claims 'architectural' for the design sense, and the audience spans both architecture-school and software/BIM readers, so an unqualified 'Architecture' page would read ambiguously. 'The Architecture' as a proper-noun page title reads as system structure by context (beside Story/Platform/Records) without colliding with the design sense. Renaming GALF to ALF was rejected because GALF is baked into every language file's conforms_to, spec filenames, D140 and the website, so a rename ripples widely for no functional gain; and 'Framework' as a page name sits too close to GALF (which IS the framework). New nouns (Core/Foundation/Fabric) were declined as vocabulary not yet needed.

• Fold the prototype into the GAAD bundle now (rejected - couples exploratory work to the live platform and violates 'GAAD must remain as current')
• Keep it standalone but GALF-agnostic (rejected - would need a rework to port later; cheap to honour GALF now)
• Standalone, Claude-owned, ringfenced, GALF-conformant (adopted)

Rationale: Keeps exploratory MHAL geometry work moving fast without risking the live GAAD bundle, while proving something valuable to GAAD itself: that GALF works as a real contract an independent standalone can honour from the outside. Ownership with a clear boundary means the prototype can be freely iterated (colour-by-term, standing legend, fast geometry, safe clear) without touching platform state, yet lands cleanly if and when it is brought inside.

• Spec/Languages/ subfolder (rejected - the languages are peers of the spec concept, not children of it)
• Keep everything in Spec/ (rejected - the folder no longer says what a file is)

Rationale: Spec/ was starting to conflate two kinds of document: platform specifications and conforming language implementations. Separating them mirrors the GALF architecture itself - contract in Spec/, implementations in Languages/ - and gives every future language an obvious home.

• Keep external GALF naming inside Spec/ (rejected - two naming schemes in one folder invites drift)

Rationale: Miles handed GALF ownership to the Specification Owner on 08 Jul 2026. Bringing it under GAAD naming and the Spec/ folder makes the contract a first-class platform specification alongside Lineage, SmokeTest and DL, versioned and validated with everything else.

• PRAL first, as the platform-active language (rejected as the template case - PRAL is knowledge-thin; GRAL exercises the full contract)

Rationale: Miles, on agreeing GALF v0.003: the project changes direction here - the simple decision gives GAAD a foundation for every language that follows (Q027). GRAL earns first position: it is the knowledge-richest language, grounded in the real garden room, and its v0.020 file stress-tested the contract before agreement.

• Per-language ad hoc definitions with no shared contract (rejected - languages would drift; the platform could not validate them uniformly)
• Tie the contract to the current Blender implementation (rejected - implementation independence is absolute; the contract says what a language IS, never how it executes)

Rationale: Concept by Miles with ChatGPT (v0.002); Specification Owner review produced seven amendments (v0.003 draft), tested against real language files GRAL v0.020 and MHAL v0.002 which earned two further contract rules (mandatory status vocabulary; internal coherence - MHAL's Hierarchy contradicted its own Relationships three ways); Architecture Reviewer approved with four minor amendments, all applied. The contract absorbs parked features F016/F017/F018 and extends the standing stage-file language precondition with galf_version. Three-seat process working as designed.

• Disc (rejected - describes the shape, not the meaning; not genetic)
• Cell (rejected - already means a building-block shape in GAAD's vocabulary; overloading it blurs shape-unit vs whole-design)
• Individual / Specimen (viable GA terms; Genome preferred as it names the design's genetic content, which is what Backtrack replays)

Rationale: 'Genome' layers cleanly with GAAD's existing vocabulary: a Genome is expressed into cells/shapes (box/cube, column/cylinder - the 1994 'cell' vocabulary), so the Navigator holds each design's genome and each genome builds from cells. This avoids overloading 'cell', which already means a building-block shape unit, and it is more precise than 'disc' (which only named the shape) - a whole remembered individual deserves a whole-organism term. Reinforces the D134 split: square = Stage (design happens), circle = Genome (design remembered).

• Leave the static 'Backtrack' label with a separate status message (rejected - the button should carry its own state, as Isolate did)
• Show only 'Backtrack to Gen {g}' (superseded - the string is part of the identity; the label now names String and Gen, matching the Navigator disc)

Rationale: Backtrack is a two-context verb (D133): press once to open the Navigator, select a disc, press again to commit. Nothing on the button said which step you were on. Reusing the self-labelling grammar of the retired Isolate toggle - live text plus a red (row.alert) armed state - makes the sequence legible without a separate status line, and the red signals 'you are mid-Backtrack, one more click commits'. Panel-only change; the operator already did the two-context work.

• Keep the visibility toggle in the Generator scene (rejected - the restore dance is the bug source)
• Duplicate the stage into the Isolator (rejected - drift and double the objects/materials; linking shares one source)
• Replay the stage from its lineage file into the Isolator (deferred - needed for isolating a remembered Navigator stage, not for the live Generator case)

Rationale: The old Isolate Stage (F004) toggled object visibility inside the Generator scene and stashed/restored the view and label state on exit - the exact machinery behind the v0.95-v0.97 label-restore bugs. Making the Isolator a separate scene fed by object links means the Generator scene is never mutated, so there is nothing to restore and that whole class of bug disappears. It also makes scene-switching the single, consistent navigation model. Linking (not duplicating) keeps one source of truth for geometry and materials, so a colour-mode change in the Generator is reflected in the Isolator with no sync code.

• Plain white dots at every vertex (rejected - noisy, and no link value)
• Dots link only to the record-type page top (rejected - does not reach the individual record)
• Regenerate the whole graph from JSON to guarantee dot-on-line alignment (deferred - would shift the approved hand-authored lines; kept the lines, read each dot's count off its existing y instead)
• Dot opens a date-filtered view of all records from that day (deferred - larger build; current model is one dot, one specific record)

Rationale: Turns a decorative trend line into a navigable index: the graph is not just a picture of accumulation, it is a way into the records themselves. Record pages already carry per-record id anchors, so no records change was needed. Ids run in strict date order per series, so a dot's cumulative level maps cleanly to a real id; an invisible 5px hit-circle sits behind each 1.8px dot so the small targets stay clickable. One dot marks a day the count rose, so it opens the top record of that step rather than every record from that day.

• Continue drop-and-eyeball iteration - rejected: two multi-cycle troubleshoots in one afternoon, both preventable (one by an invariant check, one by a runtime assertion)
• Full CI pipeline - deferred: the headless smoke test gives most of the value at a fraction of the setup; revisit with the Claude Code evaluation

Rationale: The sandbox can prove syntax and pure maths but never runtime scene behaviour; Miles can prove runtime but should not be the first line of defence for arithmetic. These practices put each check where it is cheapest.

• Keep squares in both scenes (rejected: World and Navigator shared one visual grammar, so screenshots and glances could not tell work from memory apart)
• Circles in both scenes (rejected: the World IS a site - square stages are the right architectural unit for the place where design happens)

Rationale: Semantic separation encoded in geometry; alignment with the 1994 plates, the website hero's dots-on-a-path, and Q024's atoms (atoms are round). The scene boundary now quietly teaches the Evolve/Backtrack distinction on every crossing.

• Single-step Backtrack (one generation per press, 1994 Track loop exactly) - superseded by Miles's Navigator flow: seeing the whole lineage and jumping to the pivot beats blind stepping; the Genetic Tree was 1994's answer to the same need
• Reuse the existing Back to Generation operator with the selected stage as target - rejected: overloads an operator that means something different and splits Backtrack across two buttons
• Click-commits in the Navigator (Rapid-style) - rejected: with clicks-as-commitments live, a stray click would open phantom strings; the button is the commitment

Rationale: The Navigator-as-Track-decision-point is faithful to 1994 in spirit - the Genetic Tree was where you could see where to go. One button, two contexts, honest labels. Engine lands in addon v0_93.

• Depth+visit in the filename, 1994-faithful (gen_007_v2.json) - rejected: string membership stays implicit, reconstructed by chaining parent refs
• Subfolder per string (s002/s002_g007.json) - rejected after discussion: one glob reads the whole array, lexical sort shows the strings anyway, no orphan folders, simplest generator code; 1994 kept all .CEL files in one folder and it worked
• Bare tree of stages with parent pointers, strings derived at display time - rejected: the string is the unit the designer thinks in, and it gives status/pivot/creation metadata a home; the model stays convertible since stage rows + pivots contain the full tree
• Branch/fork naming from version control - rejected: branch implies merging (design strings never merge), loses the genetic register, and string is the 1994 word - provenance, not sentiment

Rationale: Backtrack (F006) is part of classic GAAD's engine grammar, not an add-on vocabulary (Q025), and its storage is the load-bearing wall for F024, D038 scoring and the Design Memory vision (Q026). Storage schemas are the hardest thing to change once real sessions have written data, hence spec before code. Stages are the atoms of the memory - every one preserved and replayable as a 3D view (Q024); dead ends become preserved strings, the Rebirth's deliberate upgrade on 1994's discarded dead ends. Caps chosen for development sanity, one edit to lift.

• Leave tech spec sections undated (rejected - the Hub Date column read as empty, and a spec section has a real 'last updated' moment worth recording)
• Reuse the single top-level spec date for every section (rejected - sections change independently, so a per-section date is more truthful and more useful)
• Show a dash for empty cells (rejected - a real date carries information a placeholder does not)

Rationale: A spec section's currency matters. A per-section date shows at a glance when each part was last touched and fills the Hub Date column meaningfully. Seeding all sections at 2026-07-01 gives a clean baseline to diverge from as sections are revised.

• Link references to positions within the Hub SPA (rejected - the Hub renders rows dynamically, so in-page anchors are unreliable; the static record pages carry stable per-record anchors)
• Only linkify the explicit related fields (rejected - references also appear inline in prose, so linkifying at the value renderer covers both)
• Validate each reference before linking (deferred - the parity checker already guards related fields, and a missing anchor simply does not scroll)

Rationale: Cross-references were dead text that forced manual lookup. Auto-linking at the single render_value choke point turns the whole record set into a navigable web with one change, reusing the anchors and scroll-margin the record pages already provide.

• Rewire every record-type normalizer to carry the date separately (rejected - the renderer can lift the existing date badge into the new column at a single point, leaving the normalizers untouched)
• Leave the date as a Status badge (rejected - it read as a status and was easy to miss; a dedicated column scans far better)
• Sort every record type newest-first (deferred - only decisions, pivotal moments and features were requested; other types keep their order for now)

Rationale: A record's date is a first-class attribute and reads better in its own column than buried among status badges. Newest-first matches how the individual record pages already sort, and puts the most recent activity where the eye lands first.

• Reuse the development-bundle number for the publish zip (rejected - the site republishes on a different cadence than bundle cuts; a shared number would either force needless site cuts or leave gaps)
• No version on the publish zip, overwrite in place (rejected - loses the ability to reference or roll back a specific published state)
• Date-stamped filename (rejected - a monotonic 1_### line is easier to cite in records and sorts predictably)

Rationale: The site went public on 06 Jul 2026 (P049) as a single deployable package. Giving it its own 1_### line, distinct from the 0_### development bundles, lets the public site be refreshed and cited on its own terms while keeping a clean, roll-back-able history. Supports CURRENT_ACTIONS item 3 (automate records publish to the website), where each cut assembles a publish package: that package now has a defined name and number.

• Web-font text wordmark in report headers (rejected - font-fallback failure observed on the website; reports must render correctly offline)
• Reference the logo PNG by relative path (rejected - reports are single-file by design)
• Embed the /Brand PNG as a data URI at build time from one source (chosen)

Rationale: One source of truth for the mark, mirroring the gaad_palette.py dedup pattern: change the PNG in /Brand, re-run gaad_build.py, every generated report updates. The ../index.html link is correct at the published site (records/ sits beside index.html) and a harmless dead click in the local bundle.

• Keep per-category tables on the audit (rejected - Miles asked for one flat table)
• Convert the long-form log pages (decisions, PMs, tickets) to tables too (rejected - card layout reads better for long rationale text; they already carry filter buttons)
• Flat table + filter buttons on audit, Hub and Hub-terminology only (chosen)

Rationale: Miles's verdict on the audit rework: 'wow this feature audit with category buttons is very good - please remember this.' The pattern gives one sortable scan of everything while the buttons restore the grouping that flattening removes. Applied only where content is genuinely tabular; forcing decisions or tickets into rows would be a regression. Note: gaad_audit.html is standalone (not rebuilt by gaad_build.py), so its restructure lives in the HTML itself.

• Re-arm only on file load as in v0_79 (rejected - does not cover undo/redo, Reset or a mid-session loss)
• A modal operator capturing clicks instead of msgbus (rejected - heavier, and D119 chose the additive msgbus watcher deliberately)
• One shared _gaad_rapid_rearm() wired to undo_post / redo_post / Reset / toggle-ON, plus a timestamped busy timeout (chosen)

Rationale: T015 was the highest-priority open defect (Phigh): clicks silently stopped breeding, which is worse than a crash because nothing signals the loss. Routing every subscription-dropping event through one helper keeps the recovery logic in a single place, and the toggle-ON path gives Miles a manual reset if any unforeseen route still drops it. The busy timeout is the belt-and-braces guarantee that the flag can never wedge. Backtrack (F006) remains the eventual safety net for a misclick while ON; this decision only hardens the watcher, it does not add undo of a breed.

• Native Blender sub-panels (bl_parent_id) as mocked in v2_4 (rejected - no Python API to collapse them, breaking Collapse All)
• Prop-driven chevron sections with the v2_7 structure (chosen)
• Keep maintaining the mock-up pair in lockstep with the live panel (rejected - the live panel moved faster; retired instead)

Rationale: The panel stabilised through hands-on iteration (addon v0_86 to v0_90) faster than the mock-up could track, so the artefact that people actually use is the honest spec. The EVOLVE hub groups everything touched per-cycle; set-once sections collapse away at Gen 1.

• Keep calling the picker Design Language (matches D099/D102 wording but overloads DL, the master spec)
• Architectural Language with PRAL / GRAL / MHAL (chosen - clean split from the master DL, pronounceable set)
• Keep the original PAL / MAL acronyms

Rationale: AL keeps a clean three-layer hierarchy (GAAD platform, DL master spec, ALs as selectable vocabularies, Objects within an AL). PRAL is unmistakably Primitives where PAL read as a word; MHAL removes the MAL/HAL near-collision and keeps HAL free for House. Each acronym is a short distinctive prefix plus AL.

• Keep name-regex resolution and only patch the no-op
• Resolve from the shared gaad_stage_number property, as champion selection already does (chosen)
• Block the Stage button while Rapid is on, rather than disarm Rapid

Rationale: The real cause of Stage appearing dead was Rapid Stage Select breeding on the selecting click; disarming Rapid makes the stage tools behave as pure view commands. Property-first resolution mirrors the proven champion-selection path and removes a whole substring-leak class of bug (Stage_2 matching Stage_20).

• One 'STUDIO' group holding all seven buttons
• Two groups: EVOLVE + NAVIGATE
• Two groups: EVOLVE + GENERATE (chosen, Miles's call - GENERATE mirrors what those buttons return to)

Rationale: The seven buttons had accumulated three different jobs in one place: breed/progress the world (Initial, Next, Rapid, Reset), jump to a different scene (Generator, Navigator), open a report (Navigator Report). Grouping them under one name always felt forced. Two honest sub-groups match the actions: EVOLVE is what the working session is DOING, GENERATE is where the design lives (return to the Generator scene, jump to the Navigator scene, read the report). Both always-open so they don't hide when other sections collapse - the panel's busiest controls should never be one click away from reachable. The sub-question of renaming the scene/HUD (currently 'Generator' from D058) is left open because that name is threaded through the code and records; a later session can address the naming with proper supersedes to D058 rather than half-doing it now.

• Keep the single 85 m stage from the Rebirth default
• Add square-only selector with five preset sizes (chosen)
• Add rectangular option immediately (deferred to F023 - own session)

Rationale: Reference block sizes: Portland 60 m walkable grid, Chicago Loop 100 m, Barcelona Eixample 113 m, London mews 50-80 m, Manhattan 80x275 m (rectangular), suburban US 400 m+. Five square presets cover the walkable-to-campus range with clean round numbers; 100 m is the honest current default. Gutter as a fixed 18% keeps visual proportion consistent - a 300 m block on a 60 m gutter would look packed, 60 m on a 60 m gutter would look sparse. Rectangular Manhattan blocks are genuinely different urban DNA and give the designer a real new tool, but adding them alongside the selector risks a half-built change - separated as F023.

• Replace Next Generation with click-to-breed
• A modal operator capturing clicks
• Additive toggle + msgbus watcher firing the existing operator (chosen, Miles's call)

Rationale: First live test (P048): 'works v well and is super fast' and 'not distracting - keeps the human engaged' - the EVOLVE stance of D110 made real, running at 0.3s per generation (D118). Additive-toggle preserves the safe two-step for inspection (EXPLORE) and costs nothing when off. Known v1 limits, accepted: a misclick breeds while ON (Backtrack F006 is the eventual safety net, deferred - big topic, Miles), and the watcher can be lost after a Navigator visit or platform reset (T015, open - msgbus is cleared on undo/redo; hardening pass queued as addon v0_80).

• Keep one uniquely named material per primitive
• Deduplicate materials by colour value
• One shared material per shape type, world-wide (chosen, Miles's call)

Rationale: At a full 9x9 (~3,488 objects) Next Generation was creating ~3,488 near-identical materials and purging the previous ~3,488 one at a time - roughly 7,000 datablock operations per click for what is really a five-colour palette, since an object's colour is always its shape's palette colour (an inherited colour only survives while the shape stays the same). Shape-type materials are simpler and more honest than colour-keyed deduplication: the material IS the shape's identity. Measured baseline was 12.8s per Next Generation at 9x9/3,488; this pass targets the datablock churn and Python loops that remained after D116 removed bpy.ops from the per-stage path. VERIFIED in Blender 03 Jul 2026: 0.3s per Next Generation at 9x9 with 6,041 objects (was 12.8s at ~3,488) - roughly 40x faster at nearly double the population. Closes T012.

• Leave only the granular D113-D116 + T012-T014
• Add a capstone decision indexing them (chosen)
• Fold everything into one decision instead of granular records

Rationale: The guiding principle held throughout: generation writes JSON only, and everything visual - labels, reports, the Integrity Check - renders on demand, so the working loop stays fast (Miles's 'no HTML updates per generation; replay on demand' call). One capstone ties the day's granular records into a coherent move rather than a scatter of edits, and records the working method D112 set up: build-test-fix in one session, records captured at the end.

• Leave the surface on bpy.ops
• Batch the surfaces then apply the scale once
• Build the surface as raw mesh via from_pydata (chosen)

Rationale: Each bpy.ops forces a full dependency-graph re-evaluation of a scene that grows as the build proceeds - a quadratic cost that bit hardest at 9x9 (162 surface ops). Direct mesh-data creation removes them, so 9x9 does the same handful of scene re-evaluations as 3x3.

• Keep labels built by the generator
• A generator flag to build labels only when set
• On-demand panel toggle; the generator builds none (chosen)

Rationale: Labels are a viewing aid, not design data, so they should not tax every generation. Moving them off the generation path was the single biggest 9x9 speed win (roughly 9s to 4s). Building on demand honours the same JSON-now / render-on-demand principle as reports (D114).

• Keep the per-generation integrity check
• Run only the fast runtime checks after generation
• Remove it from the generation path; STATUS line plus on-demand button instead (chosen)

Rationale: The integrity check validates bundle structure, addon source and HTML records - none of which a generation changes - so running it per generation was pure cost (file reads plus an HTML report write) for no signal, and it worsened the already-slow 9x9 generation. Miles's principle: no HTML updates per generation; data lives in JSON and reports replay on demand, like Navigator Report. The STATUS line gives the same feedback without the cost.

• Leave the quick-select and Garden Room in place
• Remove Garden Room only (leaves a pointless one-option selector)
• Remove the quick-select, show the picker directly, keep the enum as a hook (chosen)

Rationale: Applies D111 (built things earn panel space). Garden Room was an orphan leaf - selecting it only showed 'No object set', with no GRAL generator behind it and the generator never reading the enum. With a single built language a selector is dead weight. Keeping the enum registered preserves the hook without showing an unbuilt control (D072: no placeholders).

• Continue as-is with memory summaries
• Skill + automation + fresh sessions (chosen)
• Move all development to Claude Code immediately (evaluate first instead)

Rationale: The conversation itself had become the store of procedure - slow to carry, fragile to transfer, and the breeding ground for errors like T008. Encoding procedure as files (skill + scripts) makes it durable, versioned and testable, in the same spirit as the records system itself.

• Keep DESIGN LANGUAGE as a slim reference section
• Delete with Objects rescued into CREATE (chosen)
• Per-change spec amendments instead of one batch (rejected by D107 protocol)

Rationale: Every item came from Miles working the panel live: Stage Size was buried and truncated; mutation had been unfindable; the Objects box was lock theatre; the DESIGN LANGUAGE section had emptied itself into a shell ('delete Design Languages from panel. We dont need this any more'). The panel now reads as one vertical working loop: language -> objects -> generate -> rules -> navigate -> records -> platform.

• Play / Pause transport metaphor
• Live / Safe
• Evolve / Explore / Backtrack (agreed direction)

Rationale: Emerged from Miles's Rapid Evolution request (F022) and his usage narrative: click, click, click, click - pause - orbit, inspect - resume - click, click - Navigator - explore. The pause state and the Navigator visit are the same mental state ('I am looking, not breeding'), so the panel should organise around states, not tool categories. Also names something the 1994 thesis system never had: a stance toward the design space.

• Patch individual complaints without a reflow
• Full restructure including the Evolve/Explore/Backtrack triad now
• Subtraction-first reflow now, triad reserved (chosen)

Rationale: Miles's hands-on feedback across the 0_107/0_108 test rounds: 'the panel is causing me problems and is not flowing well'. Subtraction first: four sections gone or replaced by single buttons removes most of the friction before any restructuring. Reference material becomes compact and read-only while working; controls appear where and when they act.

• Hub alongside the nine buttons
• Hub replaces the nine buttons (chosen)
• No Hub wiring (status quo)

Rationale: The Hub aggregates all record entries with search; nine single-purpose buttons were panel bloat from the moment the Hub existed. 'Home' is the right mental model: the front door to the project's memory.

• Keep the freeze and log feedback for a future revision
• Unfreeze with per-change document updates
• Unfreeze with sanction-then-batch amendments (chosen)

Rationale: Miles is the first person working the panel hard across generations, scene switches and resets, and reported it 'not flowing well' - drift between specced-well and works-well-in-the-hand is exactly the evidence the anti-churn discipline (D103) says should drive the next revision. The sanction-then-batch protocol keeps the spec document stable and authoritative while the working layer iterates.

• Keep one bpy.ops object per primitive (status quo)
• Direct mesh construction only, still one object per primitive
• Linked mesh data (instancing) - shares mesh datablocks but object count unchanged
• Direct mesh construction + join per variant (chosen)
• Geometry nodes per stage (F015 - remains the candidate for future languages/city scale)
• Lazy build - only construct stages in view, regenerate on demand (D030-adjacent, deferred)

Rationale: Blender's dependency graph degrades with OBJECT COUNT, not polygon count. A 5x5 world at typical object counts already places hundreds of primitive objects per generation; beyond 5x5 the viewport, selection and bulk deletion all suffer (T006 is a bulk-deletion symptom). Joining collapses object count from N_stages x object_count to N_stages, flat as worlds scale, and removing bpy.ops from the variant path removes a full scene-update per primitive plus a transform_apply per primitive. The scene becomes a render of the JSON record rather than the record itself, which strengthens the decisions-become-data principle (D008): the semantic identity of every primitive lives in the JSON. Miles confirmed the forward path before adoption: complex buildings and cities per stage remain possible (join granularity is a dial - per variant now, per building later; polygon count, which Blender handles well in a single mesh, replaces object count as the limit), and a future slow path can rebuild any variant from the JSON as separate editable objects for the chosen final design. Accepted tradeoffs: no per-element viewport selection or per-element modifiers on generated variants; per-primitive custom properties replaced by variant-level properties plus the JSON. Verified by out-of-Blender tests: vertex-layout parity with v0_32 per shape, closed-solid winding (signed-volume positive and translation-invariant), exact volumes for cube/pyramid/wedge and faceted-band volumes for cylinder/dome, placement and rotation parity, and an end-to-end joined-build test (material slots, material_index ranges, properties, JSON object_name writeback).

• Leave as-is (status quo)
• Index all seven from the tech spec with one-line descriptions
• Review each file individually - index, consolidate, or retire
• Fold them into the Records Hub as a tenth category

Rationale: Matches the pattern already surfaced in D031 and Section 9 (File Naming Conventions): drift and gaps should be tracked as decisions so they get resolved deliberately, not accidentally. The automated-check follow-up converts tonight's manual discovery into a permanent guard against the same class of drift recurring unnoticed.

• Leave the DL spec in chat/workspace only
• File the .docx into the bundle now; author the JSON later alongside GRAL
• Author the JSON immediately before filing anything

Rationale: A frozen baseline that GRAL depends on should travel with the bundle. Filing the document now closes the immediate gap; authoring the JSON is deferred deliberately so the schema is proven against a real language (GRAL) rather than designed in isolation, per the spec's own development sequence.

• Issue v0.04 now folding in all five recommendations before GRAL
• Freeze v0.03 for GRAL's duration and park the recommendations for v0.04

Rationale: Applying the recommendations before GRAL risks architecture churn - stopping to redesign the architecture every time implementation reveals a detail, so the spec never stabilises and GRAL never ships. Freezing the approved baseline breaks that loop. Recommendations 1 and 3 in particular will be better shaped by what GRAL actually needs, so parking them is not just safer but produces better decisions.

• Keep the panel and DL structurally identical (seven-part panel = DL)
• Make the DL the master data model and treat the panel as a partial view onto it

Rationale: The panel and the DL were drifting into two competing structures. Declaring the DL the master and the panel a view resolves the collision cleanly and matches GAAD's existing JSON-source discipline. The two owner corrections keep the DL-to-panel mapping internally consistent in both directions.

• Hide Objects/Evolution Rules after Gen 1 (previous behaviour)
• Keep them visible but greyed so the run stays inspectable

Rationale: At this stage of development it is important to see what objects and rules drove a generation even after it has run; hiding them lost useful context. Renaming the tree scene, HUD and report to Navigator aligns the whole platform with the panel's Navigator terminology.

• Keep iterating the mock-up without committing to a real build
• Freeze the spec at v1_0 and build the real addon to match it

Rationale: The panel design had stabilised across many small iterations and a critical architectural review scored 9/10. Freezing it as a versioned blueprint and building the real addon against it locks in the agreed structure, while the angle-bracket convention keeps not-yet-built leaves honest and visible rather than hidden.

• Grey out Garden Room and Manhattan entirely until built
• Auto-revert to Primitives if an unbuilt language is selected
• Allow selection now, show an honest not-yet-built message, keep CREATE usable

Rationale: Selecting an unbuilt language should not feel broken or block the user from using GAAD as normal. An honest in-panel message keeps the mechanism visible and testable now, ahead of HAL/GRAL primitive work which depends on the outcome of D038.

• GRG/HAL/MAL as separate standalone projects with duplicated engines
• GRG/HAL/MAL as a feature bolted onto existing Object Collection without a language concept
• GAAD as platform with Object Collection offering selectable Architectural Languages

Rationale: Garden rooms, houses and Manhattan-style towers are structurally different vocabularies of form but share the same genetic breeding need, Records system, panel and HUD. Treating them as languages within one platform avoids duplicating the engine while keeping each language's primitive set uncrowded and distinct.

• No automated testing; continue manual checklist per release
• Build a Layer 1 static check script run from the panel

Rationale: Manual checklists do not scale and are error-prone across many small panel changes per session. A one-click static check run from the panel catches regressions in seconds, before the bundle is used.

• Hardcode stage size/gutter values in the addon
• Have the generator write them to scene properties for the addon to read

Rationale: Keeps the addon decoupled from generator internals; if stage geometry constants ever change, the addon automatically reflects the new values with no addon code change required.

Rationale: Closes out F012 from the feature backlog, giving a human eye-level viewing angle distinct from the existing top-down-leaning 3D view.

• Keep EXPLORE name and verbose button labels
• Rename to VIEW with terse labels

Rationale: VIEW more accurately describes camera/viewport controls now that Generator and Navigator moved to CREATE. Terse labels read faster in a narrow panel.

• Leave Design Generator and Design Tree under EXPLORE
• Move them into CREATE alongside generation controls

Rationale: Generator and Navigator are core creation-flow destinations, not exploratory extras; grouping them with Initial/Next Generation and Report makes CREATE the single home for the full design workflow.

• Keep CONFIGURATION
• Rename to SETTINGS

Rationale: SETTINGS is more familiar terminology to most software users than CONFIGURATION.

• Keep multi-line STATUS labels
• Single compact pipe-separated line

Rationale: A single line reads faster at a glance and matches how a HUD or dashboard typically communicates live state, without consuming panel vertical space.

• Keep the flat GENERATE/EXPLORE prototype layout
• Restructure into named collapsible sections (GAAD Lab)

Rationale: The panel had grown bottom-up so everything carried equal weight. Grouping by intent with collapsible sections makes the architecture read like GAAD rather than a prototype, while staying low-risk (no algorithm change) so testing continues immediately. It sets a stable information architecture that pays dividends for every release that follows. Builds on F009.

• Keep Deep Teal / brand dark (rejected: Miles preferred black for cleaner contrast)
• Pure black #000000 (chosen — cleaner, lets the stages and forms stand out)

Rationale: Black provides the strongest contrast against the neutral stage surfaces and coloured primitives. The Deep Teal and brand dark were adopted at different points (D041, D087) but Miles preferred a simpler, cleaner black backdrop for the working environment.

• Keep release.txt only (rejected: inconsistent with HTML records)
• Styled HTML from JSON like other records (chosen — consistent, modern, filterable)

Rationale: All other record types already have the JSON → MD → HTML pipeline. Release Notes was the odd one out with a plain text file. Bringing it into the HTML system gives it the same visual treatment — gold timeline, expandable cards, version chips — and makes it accessible from the Development Reports section alongside all other project records.

• Blender theme default (rejected: grey background doesn't match GAAD brand)
• World shader background (rejected: only visible in rendered mode)
• Viewport custom background colour (chosen — works in solid/material preview, self-contained)

Rationale: The GAAD brand uses a very dark (#0D0E11) background throughout its HTML records, HUD overlay, and visual identity. Setting the viewport to match creates a cohesive visual experience. The setting is per-viewport and does not modify the Blender theme globally.

• Switch to Generator scene before deleting (rejected: fragile, changes user context)
• Use bpy.data.objects.remove() throughout (chosen — scene-independent, robust)

Rationale: bpy.data.objects.remove() is the correct low-level API for scene-independent object removal. Step 6 (Evolution scene cleanup) was already using it — applying the same approach to Steps 1-3 makes the entire Reset operator consistent and reliable regardless of which scene the user is in.

• Keep 3 options with descriptive labels (rejected: labels 'Default' and 'Testing' no longer accurate)
• Add 5×5 and tidy labels (chosen)

Rationale: 25 stages gives the user a much larger population to select from, which is valuable for exploring design space. The dynamic grid already supports any N, so adding 5×5 is a trivial change. Tidying the labels makes the selector cleaner.

• Full-width blue toggle button (rejected: too visually loud, dominates the Mutation section)
• Standard checkbox (chosen — quiet, consistent with other boolean controls)
• Custom colour toggle (rejected: same API limitation as D082)

Rationale: Miles flagged the blue toggle as visually loud in the Mutation section. A checkbox is the natural Blender widget for a boolean setting. The slider fill colours remain blue (Blender theme standard) — changing them would require slider=False which loses the drag gesture.

• Keep Records and Reports as separate sections (rejected: two collapsible sections for similar content)
• Merge everything into one section (rejected: Design Evolution Report needs quick access, not buried)
• Development Reports + Design Evolution Report above Reset (chosen — clean hierarchy)

Rationale: The panel had too many small collapsible sections. Design Evolution Report is a frequently-used action that should not be buried inside a collapsed group. 'Development Reports' better describes the collection of project records (decisions, features, release notes etc.) than the generic 'Records'. Adding 'Configuration' as a titled box and showing the last release version gives the panel a professional, complete feel.

• GAAD Gold button colour (preferred but not possible — Blender API limitation)
• Change Blender theme alert colour to gold (rejected: affects all of Blender, not just GAAD)
• Blender alert red as primary-action highlight (chosen — platform-native, understood by users)
• No button highlight (rejected: primary action should be visually clear)

Rationale: The Generate buttons are the single most important action in the panel — highlighting them when they are ready to fire makes the workflow self-guiding. Blender's alert system is the correct, supported way to do this even though the colour is red rather than brand gold. Fighting the theme system for a custom colour would add fragility for a cosmetic gain.

• No timer (status quo)
• Timer in the generator only, not surfaced in reports
• Timer in generator + BUILD TIME column in Design History Report (chosen)

Rationale: Build time is a core performance metric that echoes the 1994 thesis timer. Recording it in JSON makes it available for future analysis (performance trends across grid sizes, hardware comparisons). Surfacing it in the Design History Report gives the user immediate feedback on how long each generation took — a satisfying data point that also highlights the 200× speed improvement over 1994.

• Hardcode three separate stage lists (rejected: duplication, hard to extend)
• Dynamic grid builder with NxN parameter (chosen: clean, extensible)

Rationale: Testing different grid sizes is essential for evaluating population diversity and selection pressure. 2×2 is the minimal viable grid (small/quick); 3×3 is the established default from the 1994 thesis; 4×4 gives a larger population for richer testing. Using a function means future grid sizes (5×5, 6×6) are trivial to add.

• A separate Blender scene for isolation (rejected: heavyweight, loses context)
• Toggle hide_viewport on non-matching objects + save/restore view state (chosen)

Rationale: The 1994 GAAD had an Isolator to examine one macro phenotype in detail. Using hide_viewport is lightweight and reversible — no objects are moved or deleted, and saving the view state means the user returns exactly where they were. Matching by the G###_S### prefix is robust because every object and surface in the generator carries this naming convention.

• A single toggle (plan/perspective) — rejected: two named buttons are clearer
• Two separate buttons with explicit labels (chosen)

Rationale: The 1994 GAAD had a dedicated 2D Development Zone (plan view of all progeny) as a core viewing feature. Adding a Plan View button restores this capability. A companion 3D View button gives the user a quick way to return to a useful perspective angle without manually orbiting. Both are lightweight viewport manipulations with no scene data changes.

• Keep v0_24 values
• Adopt the v0_25 values above

Rationale: Larger position and looser rotation give bolder spatial variation per generation; the higher min/max object counts allow denser, more varied stages; the gentler height mutation keeps proportions more stable while shapes still explore.

• Allow Mutation to Other Objects
• Keep 'Allow Mutation to Other Types'
• Other wording

Rationale: Removes the collision between 'Type' (collection) and 'Types' (object kinds) so the toggle's meaning is unambiguous.

• Flat primitive list (no Type layer)
• Type layer with multi-Type selection
• Type layer with single-Type selection

Rationale: A Type taxonomy future-proofs the panel for Buildings / Rockets / Garden Rooms. Constraining a run to a single Type keeps the genome coherent (no cross-Type breeding) and simplifies the generator. Dovetails with D071 (modular architecture).

• Keep 'Design Evolution'
• Rename to 'Design Tree'

Rationale: 'Design Tree' is more literal and concrete than 'Design Evolution' for the recorded lineage view. Dropping the 'Back to...' framing and fixing the order reads as two peer views rather than an action plus a return.

Rationale: Reset has no valid purpose in the Design Evolution scene. Hiding it prevents the bug and removes the temptation to use it in the wrong context.

Rationale: Coming soon labels create noise and imply a half-finished product. The panel should only show what works.

• Keep monolithic structure (rejected: will become unmanageable at 5k+ lines)
• Split into focused modules with thin orchestrator (chosen — action when generator approaches 2000 lines or Buildings/Garden Rooms object types are added)

Rationale: The generator is already 1,226 lines and growing. Shape creation, mutation, genome scaling, JSON logging and scene setup all live together. Adding new object types (Buildings, Garden Rooms) will compound this. Modular architecture now, before the codebase is too large to refactor safely, will keep GAAD maintainable and testable long-term.

• Guard with 'if handle is None' only (rejected: fails on module reload)
• Always remove before adding (chosen)

Rationale: Module-level variables in Blender addons reset on reload without triggering unregister(), so the 'if None' guard is not sufficient. Always removing first is the correct defensive pattern.

• Leave scene names as Blender defaults ('Scene', 'GAAD Tree') (rejected: confusing in the outliner)
• Named scenes + all four scripts in panel (chosen)

Rationale: Clear scene names in the outliner make it immediately obvious which scene is active. Showing the add-on filename in the panel completes the scripts inventory and makes version-checking straightforward.

• Keep single-line HUD text at uniform size (rejected: headline lost in the small text)
• Large headline + split lines + date/time + guard (chosen)

Rationale: The HUD is the primary identity element in both views. Making the view name large and prominent gives instant orientation. Splitting the generation count to its own line keeps it readable. Date/time adds useful session context. The non-GAAD guard prevents the HUD appearing on unrelated Blender files when the addon is installed.

• Keep both the plaque AND the HUD (rejected: redundant, and the plaque is the dated element)
• Remove the plaques, keep only the HUD (chosen)

Rationale: Completes the '1994 plaque out, modern HUD in' swap. The plaque was the most dated element in the 3D views; with the HUD confirmed working (logo + brand text), the plaque is pure redundancy and visual clutter on the floor. Functions kept in code as a safety net.

• Keep 'Generation' / 'Evolution Tree' (rejected: off-brand, inconsistent - HUD said 'Generation Tree' while buttons said 'Evolution Tree')
• World -> 'Design Generator' (rejected: clashes with the generator SCRIPT name; mechanical)
• Tree -> 'Lineage' (good, but technical; 'Design History' is the brand word from the logo)
• World -> 'Design Studio', Tree -> 'Design History' (chosen)

Rationale: The logo's strapline is the brand's spine; pulling 'Design' into the view names makes the whole tool feel of-a-piece and fixes a real inconsistency (the tree was called both 'Evolution Tree' and 'Generation Tree' across the UI). 'Design History' is literally what the lineage is, is meaningful to non-technical audiences, and sets up 'Design Intelligence' for the scoring future. 'Design Studio' frames the world as the human, active place of designing without colliding with the generator script name.

• Keep the extruded 3D title plaque (rejected: dated, tilts, foreshortens)
• Blender annotations/text objects (still geometry; not as clean)
• A blf/gpu HUD draw handler - flat 2D viewport text (chosen)

Rationale: The 3D plaque was the most '1994' element left in the World. A HUD overlay is the modern idiom (it's the same layer Blender uses for 'User Perspective' etc.) - always legible, screen-anchored, no geometry in the scene. Building the HUD first and removing the plaque later avoids ever leaving the World untitled.

• Re-frame the World on every Next Generation (rejected: yanks the camera away from the user's chosen view)
• Auto-detect the Tree->World switch (fiddly, surprising)
• An explicit 'Back to Generation' button that switches + centres + frames (chosen)

Rationale: The orbit/centring fix the Tree received (D051/v0_5b) was also needed for the World, but only when returning from the Tree - during normal breeding the user wants their view kept. An explicit button matches GAAD's one-click idiom, keeps the user in control of when the snap happens, and pairs naturally with the Evolution Tree button.

• Keep the responsive table -> stacked-card format (rejected: looked dated on mobile)
• Compact expandable list
• App-like timeline card feed (chosen)

Rationale: The table-to-stacked-card mobile format was functional but felt utilitarian. A timeline card feed is both more modern and truer to GAAD as 'The Design Memory Platform' - the records literally read as a journey down a timeline. Mobile-first cards remove the awkward table collapse entirely. One shared helper keeps all five pages consistent.

• Adopt brand neutral objects - supersede D041 Rebirth Colours (brand wins)
• Keep D041 Rebirth Colours - brand identity adopted but objects stay coloured
• A hybrid (neutral by default, colour as an optional 'mode')

Rationale: Both positions are coherent: the brand argues colour competes with the design process; D041 argued colour aids shape legibility and gives GAAD a vivid identity. Because D041 is ADOPTED and in the shipping generator, the brand's neutral-object direction must not silently override it - it is logged OPEN for the human to rule on when the brand re-skin is built.

• Keep the green edge-frame (D028) - off-brand, already superseded
• Gold champion stage (chosen; already built in D042) - align hex to brand #D9A441

Rationale: Confirms the independent convergence on gold and simply ties the hex to the canonical brand value. Low-risk: the gold champion already exists in the generator (v0_22a); this is a colour-value tweak when the brand re-skin is built.

• Keep the green genetic-path identity (superseded by the brand)
• Adopt the gold-delta 'Design Memory Platform' identity (chosen)

Rationale: A deliberate, complete brand system that states the thesis in one line and sidesteps CAD/BIM/generative/AI framing. Adopted from the original chat where it was canonical; renumbered to D055 to avoid colliding with this chat's existing D037-D039. Pleasing convergence: this chat independently moved the champion to GOLD (D042), so the brand and the build already agree on gold = selection. The conflict (brand wants neutral objects; this chat adopted coloured 'Rebirth Colours') is deliberately NOT resolved here - see open D057.

• One combined README with a version block (previous approach)
• Hand-written changelog (drifts out of sync)
• readme.txt + auto-generated release.txt from a releases record (chosen)
• In-panel version history: a simple Release Notes button now vs a full in-panel changelog browser (chose the button; richer browser deferred)

Rationale: readme.txt and release.txt answer different questions (how do I run it? vs what's new?) and change at different rates, so separating them is cleaner and matches real software. Generating release.txt from gaad_releases.json keeps one source of truth and lets the records write the notes. Newest-first rendering makes the same file double as the version history. The Release Notes button surfaces it inside GAADBlender with no new machinery - another renderer reading the records.

• Everything loose in root (status quo - cluttered)
• Lowercase subfolders now (cleaner, but needs path changes in 4 scripts - deferred to 1.0)
• Capitalised subfolders now, zero script changes (chosen)
• Per-tool versions + bundle headline version (Option A, chosen) vs stamp every tool with the bundle version (Option B)
• Keep 'V' prefix vs drop it (dropped)

Rationale: A single .blend in root with tidy capitalised subfolders is clean, professional and self-contained - copy one folder into a fresh dev folder and run. Independent tool versions stay honest (a file's number only moves when it changes) while the bundle version gives an at-a-glance release identity, with VERSION.txt bridging the two. Dropping 'V' and keeping '0.' follows common practice and signals pre-1.0 status truthfully. Capitalised-now avoids touching working path logic; lowercase waits for the 1.0 reset when everything is bumped anyway. The add-on Scripts/ auto-detect is the small enabler that makes the structure work with no manual configuration.

• Duplicate the report's diff maths into the tree now (rejected - third copy to maintain)
• Concise change line now, full metric panel after a shared diff module (chosen)

Rationale: Putting the real per-generation metrics beside each stage in the tree makes the lineage genuinely analytical, not just visual. But it depends on a shared diff module so the numbers are computed once and trusted everywhere - the recurring shared-module foundation. A deferred FEATURE, so it lives as an open Decision, not a ticket (tickets are for deferred bugs).

• Keep the green 'AutoCAD-retro' panel (rejected - see T002)
• Short version stub 'v0_21' vs full filename gaad_generator_v0_21.py (chose full filename, traceable)
• Per-element text colours vs one unified grey (chose unified grey #8A9299)
• Concise change line now vs full metric diff panel (concise now; full metrics deferred to D052)

Rationale: The title panel read as a 1990s CAD label (T002) and several labels were invisible at working angles (T003); this pass gives the World and Tree a consistent, legible, modern identity. Unifying text to grey calms the panel so the coloured forms carry the colour. The full filename makes every render self-documenting. The side-by-side tree with its own signed 'GAAD - Generation Tree' title makes the lineage readable and gives the Tree its own identity alongside the World. Bugs fixed in passing (text extrude below surface, stray green accent bar, loud Generation text, invisible labels) are resolved this cycle and need no tickets; T002/T003 are closed.

• Keep raw Markdown only (renders as plain text in editors)
• HTML instead of Markdown (lose easy diffs/GitHub)
• HTML + keep Markdown, shared style helper, origin colour-coded (chosen)

Rationale: Raw .md opened as plain text in an editor, which read poorly. Styled HTML gives a proper page - scannable, colour-coded so the 1994-vs-new and open-vs-closed stories show at a glance - while keeping .md for diffs and GitHub. A shared helper means all five pages look identical and styling lives in one place (the recurring shared-module discipline).

• Graphviz - script JSON->dot->auto-laid-out SVG/PNG (chosen: lowest effort, regenerates live)
• Cytoscape.js / Dash Cytoscape (interactive, browser - deferred)
• D3.js (bespoke, steep - deferred)
• Render it in Blender (rejected: it is a node/text graph, not 3D form)

Rationale: Closes the loop the project has circled since P022/P027/P029: GAAD turned on itself. Every mark is true - gold clusters are the 1994 DNA, faded nodes are backtracked ideas, blooms are turning points. It is the thesis's own Genetic Array (Fig 3.29) pointed at the development of GAAD itself, and being generated from the records it is alive: log a decision, rerun one script, the tree grows. Origin colouring (D046) finally has a spatial job.

• Keep 'Issues' with binary open/resolved
• Severity vs priority (chose priority - answers 'what next?' for a solo dev)
• Two-state vs three-state status (chose open/in progress/closed)
• Rename to Tickets with priority + 3-state status (chosen)

Rationale: 'Issues' is passive; 'Tickets' is active - a unit of work that moves through a cycle and gets closed, which fits the solo-developer reality of triaging 'noticed it, will deal with it when I have resources (me)'. Priority (not severity) answers what to do next; a three-state status gives just enough granularity to see work in flight. Turns the log into a backlog.

• Fold memorable lines into PM records (rejected - quotes are about language, a different kind of record)
• Capture quotes with a public/private flag (rejected - open-source project, all cleared)
• Dedicated Q### record type with source attribution (chosen)

Rationale: Good phrasings are a distinct asset - reusable for posts, talks and marketing - and easy to lose in the flow of work. A curated, attributed quotes file captures them while keeping the attribution honesty Miles applies on LinkedIn (what is his to claim vs AI-assisted). Themes make it easy to pull the right line for the right post; an ai_collaboration source credits the collaboration openly.

• No origin field (status quo - distinction lives only in prose)
• Two values (rebirth / new)
• Three values 1994 / evolved / new (chosen - captures the hybrid middle)

Rationale: Makes queryable the most important story in the project: how much of Rebirth is restoration of the 1994 thesis versus new invention. A pure binary forced too many hybrid decisions into the wrong bucket, so a three-value scheme was chosen. A nice side effect: the future Records-Tree can colour nodes by origin, showing the 1994 DNA threaded through the project with new growth branching off it.

• Leave Rebirth as forward-search only (status quo)
• Re-mutate when revisiting an ancestor (rejected - thesis specifies replay/restore, not re-mutation)
• Replay-based backward/forward tracking restoring stored phenotypes from a pivot progeny (chosen direction, OPEN on detail)
• Render the tracking tree in Blender vs a dedicated 2D graph tool (open)

Rationale: Forward search alone has the thesis's stated 'significant limitation' - the dead end - where hill-climbing gets stuck. Backward/forward tracking is the escape that turns GAAD from a hill-climber into a genuine exploration of the design space, and is one of the three algorithms that define GAAD (with Forward Search and Genetic Engineering). It is the concrete realisation of the rear-cover promise of 'exploration in the 4th dimension'. Left OPEN because it is a large capability that depends on seed-based storage (D030) being built first and interacts with scoring (D038); the build order is storage -> tracking. Logged now so the direction is captured while the thesis reading is fresh.

• Keep records outside the tool (status quo)
• One 'Open Records folder' button
• A dropdown of records
• Four named buttons opening each .md directly (chosen)
• Loose beside the .blend vs a Records/ subfolder (chose subfolder)

Rationale: Makes GAAD self-documenting from inside the app: the decision history is one click away while working, reinforcing 'decisions become data'. Four named buttons match the one-click spirit of Open Report. A Records/ subfolder keeps the root tidy and consistent with D031; fallbacks avoid forcing a reorganisation.

• Call it 'clash' and treat as a fault to minimise
• Bounding-box intersection vs true mesh intersection (chose bounding-box first)
• Count only vs count + overlap volume (chose both, count headline)
• 'Object intersection' as neutral recorded data, Boolean-join reserved (chosen)
• Score intersections now vs record first, score later (chose record first)

Rationale: Primitives previously knew only their own shape; intersection gives them context. Naming it neutrally ('intersection', not 'clash') keeps it consistent with 'decisions become data' - measure the fact, don't bake in a verdict - and preserves the option that an overlap is a deliberate Boolean join. Bounding-box is cheap, deterministic (important for replay/seed storage) and good enough for a first signal. Recording before scoring avoids quietly turning GAAD back into a constraint-solver against the unrestricted-growth spirit of D015.

• Keep the green square edge-frame (D028)
• A gold/yellow edge-frame only
• Highlight the whole stage gold (chosen, as in early GAAD)
• Keep wedge yellow vs reassign wedge to grey (chose grey, to reserve yellow/gold for the champion)

Rationale: The green edge-frame was visually weak. A full gold stage fill is a strong pre-attentive 'this one is selected' cue (used in early versions) and far more legible than a thin frame. Freeing green from champion duty also removes the dome/champion green ambiguity flagged at D041. Grey adds a calm neutral shape option and lets yellow/gold mean only 'champion'.

• Keep the 1994 'Retro Bold' primaries
• Desaturated tonal palette (earlier swatch)
• 'Rebirth Colours' = Vibrant Startup + green + purple (chosen)

Rationale: The 1994 primaries read as dated (P026). A curated vibrant-but-modern web/UI palette gives GAAD a contemporary identity while staying colourful and legible. Naming the original 'Retro Bold' preserves it as a heritage option and frames the 1994->Rebirth shift. Adding green and purple keeps all five shapes clearly distinct and carries the brand green into the world. To be applied in the generator alongside the studio look (Eevee AO/soft shadow/bloom + grounding plinth).

• Rely on the 'Changes in 0.x' script-header changelogs only
• Track issues as Pivotal Moments
• A dedicated structured Issues log (I###) with version traceability (chosen)

Rationale: Decisions and Pivotal Moments have no natural slot for 'this broke / why / how it was fixed', and the changelog prose is buried in script files and not queryable. A structured issues log captures the debugging journey as first-class data with version-level traceability (introduced_in -> resolved_in) that the changelogs cannot give, consistent with decisions-as-data (D020). Backfilled with I001, the v0.15 title-panel selection regression.

• No title panel (status quo)
• Flat ground plaque at stage level in the foreground (chosen)
• Billboarded HUD panel hovering above the world
• Content: GAAD wordmark + filename version + 'Generation N' label

Rationale: Gives the 3D view a clear, readable header identifying the tool, its version and the live generation - useful in screenshots, recordings and LinkedIn posts, and a step toward the thesis's 'comprehensive graphical user interface'. Placed flat at stage level so it reads as a title plaque consistent with surface labels (D010). Kept open because Miles has UX tweaks pending.

• Objective (pure geometry: area, volume, compactness, variety) vs goal-directed (distance from a set target, e.g. tall-spiky / enveloping domes)
• Absolute (variant in isolation) vs relative (improvement over its parent)
• Told (Miles defines the rule) vs learned (GAAD infers taste from picks)
• Single headline number vs a small vector breakdown (size / variety / goal-fit)
• UX/surfacing: report column vs on-stage cue vs tree (pending Miles's UX feedback)

Rationale: The Evolution Summary already self-summarises the raw material, so the foundation exists (P021). This is the leap from recording the journey to evaluating it - the first foothold on the Design-Intelligence arc. Recorded as OPEN so the design conversation and UX feedback are captured before any scoring code is written.

• Leave terminology scattered across decisions and the handover doc
• A single flat glossary table
• Comprehensive categorised JSON source of truth with generated Markdown (chosen)

Rationale: Terminology was defined piecemeal across D003/D004/D005/D006/D007/D021/D022/D024 and the project background, and the handover repeatedly referenced a gaad_terminology.md that did not yet exist on disk. Making it a first-class record matches the decisions-as-data principle (D020), gives the vocabulary one canonical home, ties each Rebirth term back to its 1994 thesis root, and supplies clean reference material for posts, the thesis write-up and the future AI-learning chapter.

• No timestamps
• Friendly date format
• ISO format for sortability (chosen)

Rationale: The generation JSON already records created_at to the second; surfacing it gives the report a real chronology, and ISO format sorts correctly as plain text.

• Keep current labels/behaviour
• Rename only
• Auto-report on tree run
• Open HTML directly vs open folder

Rationale: Lowers friction: one click gives both the 3D lineage and the report, and the result opens straight in the browser. Keeping standalone Write Report preserves report-only runs. Pure workflow polish on the tool (P024).

• Leave manual (press Home, set clip end by hand each time) - current, error-prone
• Auto-frame only
• Purge only
• Purge + tree isolation + auto-frame (chosen)

Rationale: After ~24 generations plus repeated tree builds, data accumulated (many cameras/lights/curves) and the leftover tree camera/view made the generator world appear tiny and clipped when switching scenes. The root cause is scene/data management, not the view; fixing it in the scripts removes a whole class of usability problems and keeps files lean - important as worlds scale (D007) and as seed-based storage (D030) arrives.

• Manual load/paste each run (current - slow)
• Register + auto-run on file open
• External editor workflow
• Installable add-on with a GAAD panel and buttons (chosen)

Rationale: Removes the repetitive load-script step that was slowing every session, while keeping the versioned scripts as the source of truth (the add-on just launches the newest). Auto-detection avoids editing the add-on per version, fitting the D031 naming/folder convention.

• Always uppercase GAAD everywhere including filenames
• Uppercase in prose/labels, keep lowercase gaad_ prefix in code/filenames (chosen)

Rationale: GAAD is an acronym (Genetic Aided Architectural Design) and reads correctly only in uppercase. Code identifiers and filenames keep the conventional lowercase prefix to avoid breakage and match normal practice.

• Per-project hand-edited absolute REPLAY_ROOT (current - error-prone, caused a path mismatch)
• Fixed standard folder layout with relative //Replay resolution
• Single config file/variable shared by all scripts
• Versioned project folders (GAAD Development 0_11, 0_12 ...) vs one stable project folder
• ADOPTED: default to //Replay relative to the .blend; absolute path optional override

Rationale: Folder/filename drift has already caused a real problem: the tree script's REPLAY_ROOT pointed at an old folder while the data lived in a newer one, so no geometry appeared. A convention removes that whole class of error and makes the project portable and self-consistent. Opened to decide deliberately rather than ad hoc. Resolved: scripts beside the .blend; data folder renamed 'Generations' (clearer than 'Replay'); reports in 'Reports/'. Relative resolution removes the path-mismatch class of error.

• Full population (current 0.11) - total backtrack, explodes at large n
• Selected-only - lean, but unchosen siblings lost permanently
• Seed + reconstruct - store recipe, regenerate siblings on demand (chosen)
• Lazy snapshot - save siblings only if a backtrack actually happens

Rationale: Modern echo of the thesis's compact unique-numbering encoding (Figs 3.23/3.25): store the generative recipe rather than every output. Keeps full backtracking while files stay tiny at nxn. The generator already seeds each variant with random.Random(variant_seed), so the foundation exists. The catch - and the companion rule - is that generation becomes a contract: a genome_version must be recorded so old seeds reconstruct faithfully even as the genome evolves. Chosen by Miles.

• Flat ground text (current)
• Hovering billboarded HUD pill (chosen)
• Glowing/emissive caption
• Node label on genetic-path connector
• Green-accent parent caption vs reserve green for champion only (chose reserve)
• Headline only vs headline + metrics line (chose headline + metrics)

Rationale: HUD pill inherits D020's modern, hover-and-billboard language without the legibility risk of glowing text, and stays independent of the not-yet-built Tree 0.2 connector (which can tie in later). Reserving green for the live champion keeps the signal meaningful. Two-tier content (bold headline + faint metrics) is scannable in-scene while full detail stays in the report. Sharing the summary's diff logic keeps one source of truth. Claude decided at Miles's request.

• Keep '(PARENT)' text suffix
• Colour alone (gold)
• Border/frame
• Glowing orb marker
• Hovering ring/halo marker (chosen)
• Vertical beam/pin marker
• Slight plinth
• Neutral stage vs keep gold (chose neutral)
• REVISED to square edge frame (ring clashed with tall objects)
• Flat frame vs raised rim (chose just-above-surface frame)
• Square frame vs circular (chose square to match stage)

Rationale: GUI principle: show state visually, not in words. A green ring reads pre-attentively as 'active/selected' from any orbit angle in 3D, feels modern/cutting-edge, and frames the stage rather than obscuring it. Neutral surface lets green be the single parent signal without a competing colour. Label stays bare id, honouring D016. Chosen by Miles. REVISED: the hovering centre ring intersected tall forms on the stage; a perimeter frame keeps the modern emissive 'active' cue while staying clear of the objects, and a square frame matches the square stage footprint ('this whole stage is selected').

• No formal roadmap
• Tight near-term only
• Balanced near-term + vision
• Vision-forward roadmap

Rationale: Today was complex and generative; a roadmap captures momentum without overcommitting. Weighted vision-forward because the session's real discovery (GAAD as recorded design lineage, beyond geometry) is the compass. Kept a living document, like the decision log.

• Geometry: full sphere (as currently rendered) vs hemisphere trim (true dome cap)
• Volume if full sphere: (4/3)*pi*r^3 vs visible half (2/3)*pi*r^3
• Volume if hemisphere: (2/3)*pi*r^3
• Floor area: plan circle/ellipse pi*(w/2)*(d/2) (same either way)
• Whether the hemisphere trim (long-parked) is done as part of this
• Circular vs elliptical plan (chose circular)
• Hemisphere volume (2/3 pi r^3) vs visible-half of full sphere

Rationale: Circular hemisphere is the honest, simplest reading: half a form sitting on the surface, footprint a true circle, volume the matching hemisphere. Locking circular reduces a dome to one parameter (diameter), tidies the genome, and makes area/volume unambiguous. Chosen by Miles.

• Display placement: on-stage caption (A) vs side billboard (B) vs companion 2D readout (C)
• Floor area as sum of per-object footprints vs combined union coverage
• Totals shown as absolute vs delta vs both
• Include domes in sums now vs exclude until their geometry is settled

Rationale: Readout C is fully legible, shareable (LinkedIn/thesis), and avoids 3D-text problems; it pairs with the bare variant-id labels already on the Blender stages (D016). Sum-of-footprints is simple and transparent (noted as a gross sum). Floor area and volume reconnect the abstract evolution to architectural terms. Domes are excluded for now because their geometry is unresolved (full sphere vs hemisphere), which would distort the sums; tracked as the open decision D018.

• Letter stage names A,B,C... to avoid verbal confusion with generations (rejected earlier)
• Friendly 'Gen N - Stage S' labels
• Bare JSON variant id 'G001_S006' for all labels

Rationale: Keeps it simple and faithful: the label IS the data. What you see in the scene matches the JSON and the replay filenames exactly, with no translation layer to maintain or get out of sync - consistent with the decisions-as-data philosophy. The id already encodes the stage (S006), so nothing is lost.

• Rebuild full 3D parents (option a) vs flat plan/thumbnail strip (option b)
• Read from replay JSON vs from the live scene
• Run in a new Blender file vs build into the current scene
• Stop at last recorded selection vs append the current unselected generation
• Read all generations vs a start/end range
• Stacked stages only vs an explicit genetic-path connector line between parents

Rationale: Faithful to the thesis 'genetic array' (Fig 3.29) and genetic path (Fig 3.25). Reading the replay folder keeps it consistent with the replay philosophy and decouples it from the live generator. Agreed scope: option a (full 3D), reads JSON, new Blender file, stop at last recorded selection, all generations (no range), labels show generation and chosen stage (as in the thesis), stacked stages only for now (connector line deferred).

• Genetic Aided Architectural Design (as the thesis pages read)
• Generic Aided Architectural Design (as some Rebirth summaries read)
• A deliberate meaning shift between 1994 and Rebirth

Rationale: The 1994 thesis (Fig 3.3 heading and back-cover abstract) reads 'Genetic'. The 'Generic' wording in later Rebirth summary documents was a transcription slip rather than an intentional change. Settling on 'Genetic' keeps 1994 and Rebirth consistent.

• Restore the original six historical cells (slab, dome, box, pyramid, wedge, column) with their Fig 3.27 rules
• Keep the five current names and apply per-type scaling rules to them
• Cylinder free to squash vs cylinder locked XY-equal

Rationale: Keeps GAAD simple and avoids renaming churn (no going backwards on naming, consistent with existing JSON and scenes). Locking dome to uniform XYZ fixes the spindle artefact; locking cylinder XY-equal keeps it a proper circular column. Cube, pyramid and wedge stay free so the tall-spike (3.6A) and long/wide-wedge (3.6B) experiment behaviours remain reachable.

• Markdown only
• JSON only
• JSON source of truth with generated Markdown

Rationale: Mirrors how GAAD already treats design history (structured data first, human view second) and makes the decision log itself replayable and parseable for the future AI chapter.

• Version number only
• Version number plus descriptive tag

Rationale: Makes each artefact self-documenting and easier to track across the development history.

• (a) Faithfully reproduce the original typed genome with per-type scaling rules
• (b) Keep a looser abstract sandbox with a simple anti-spindle cap

Rationale: Makes Rebirth a genuine re-implementation of the thesis rather than a lookalike, and fixes the spindle while preserving enveloping domes. Chosen by Miles.

• Cap dome height relative to footprint (simple sandbox fix)
• Restore the original per-type scaling rules so dome XYZ stays uniform

Rationale: The spindle artefact was a port error: the Blender port let height mutate independently of width/depth, which the original genome's 'domes keep equal XYZ scales' rule prevented. The height-cap would also have broken Experiment 3.6A, which intentionally evolves large enveloping domes.

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).

Rationale: Recorded in Week 1 (GAAD Rebirth Master Context Archive v2.0).