Decisions

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.

• W
• r
• i
• t
• e
• .
• c
• e
• l
• f
• i
• l
• e
• s
• p
• e
• r
• c
• h
• a
• m
• p
• i
• o
• n
• ;
• e
• x
• p
• o
• r
• t
• -
• o
• n
• -
• d
• e
• m
• a
• n
• d
• v
• e
• r
• b
• ;
• k
• e
• e
• p
• C
• E
• L
• e
• m
• b
• e
• d
• d
• e
• d
• o
• n
• l
• y
• (
• s
• t
• a
• t
• u
• s
• q
• u
• o
• )
• .

Rationale: 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.

• P
• l
• a
• t
• f
• o
• r
• m
• -
• w
• i
• d
• e
• r
• e
• n
• a
• m
• e
• (
• r
• e
• j
• e
• c
• t
• e
• d
• :
• b
• r
• e
• a
• k
• s
• l
• i
• n
• k
• s
• a
• n
• d
• p
• r
• o
• v
• e
• n
• a
• n
• c
• e
• )
• ;
• k
• e
• e
• p
• t
• h
• e
• z
• o
• o
• d
• o
• c
• u
• m
• e
• n
• t
• e
• d
• (
• r
• e
• j
• e
• c
• t
• e
• d
• :
• d
• e
• f
• e
• c
• t
• s
• r
• e
• m
• a
• i
• n
• )
• ;
• d
• o
• t
• t
• e
• d
• v
• e
• r
• s
• i
• o
• n
• s
• i
• n
• f
• i
• l
• e
• n
• a
• m
• e
• s
• (
• r
• e
• j
• e
• c
• t
• e
• d
• :
• M
• i
• l
• e
• s
• -
• n
• o
• d
• o
• t
• s
• o
• r
• h
• y
• p
• h
• e
• n
• s
• i
• n
• n
• a
• m
• e
• s
• )
• ;
• c
• a
• p
• i
• t
• a
• l
• i
• s
• e
• d
• n
• a
• m
• e
• s
• (
• r
• e
• j
• e
• c
• t
• e
• d
• :
• c
• a
• s
• e
• -
• s
• e
• n
• s
• i
• t
• i
• v
• i
• t
• y
• r
• i
• s
• k
• ,
• n
• o
• b
• e
• n
• e
• f
• i
• t
• )
• .

Rationale: 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: 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).