Features

F053 parked 25 Jul 2026

Export Champion - the selected winner leaves GAAD for Revit and the other tools

PROPOSAL (Miles, 25 Jul 2026, described as years away): the path runs GLAS on the web, into GAAD, and at some point out again - an Export Champion function sending the selected form to Revit and its peers. The word is already GAAD's own. F027 made the champion the gold one in the Navigator, the string that won, re-championable by selection. This gives that existing idea a destination outside the platform rather than inventing a new concept. THE QUESTION IT RAISES, for whenever it is picked up: a champion is not only a shape, it is a genome and the journey that produced it. So an export can carry three different things - the geometry alone, the geometry plus the genome, or both plus the lineage. The third is the one that matters, because a form arriving in a BIM model carrying its own ancestry is design memory entering the industry's actual model rather than staying inside GAAD. A Revit family knows its type; a GAAD-grown form could know where it came from and what was rejected on the way. CAUTION recorded early: an export is a one-way street, and one-way streets are where memory dies. If a champion is edited downstream the journey stops there, so the export should either round-trip or at minimum stay traceable back to the genome that made it. NOTHING TO BUILD NOW. What matters today is that nothing forecloses it, and the decisions made the same evening are what keep the road open: D202's single host-free genome, metres at millimetre precision (BIM's native tongue, so a genome lands in Revit already speaking the language), and D203's rule that GLAS is a surface whose host is interchangeable. PARKED: recorded so the steer is not lost.

F052 built - in verification 25 Jul 2026

GAAD Glasshouse (GLAS) - the surface where GAAD's languages grow

WHAT GLAS IS (Miles, 25 Jul): a SURFACE, not a place. It can run on the web, in Blender, or one day in the GAAD product itself - GLAS-in-the-product, a commercial GAAD tool. The host is interchangeable and the browser is only its first one. GLAS grows; GAAD remembers. The word 'web' has been cut from this title for that reason. NAMED by Miles on 25 Jul 2026: the GAAD Glasshouse (D203). AFAL is deliberately absent from the name - Q045, 'AFAL is just testing ground language, if it works it works for all languages' - and so is the word preview, because the page runs the real laws rather than a picture of them. The Code Technician built a single self-contained HTML page that renders real AFAL forms live in a browser: pick a species, drag the genes, orbit the form, and the growth law prints on screen as it draws. Five species are built (Spiral, Shell, Cone, Phyllotaxis, Hyperboloid) inside a five-family, eighteen-species frame, the rest locked with a reason given. Regenerate rolls a seed inside each species window with a Strength spread, which retires the old Calm/Wild/Extreme modes. Presets and Save PNG are in. It began as an HTML mock of a cleaner AFAL panel, chosen because HTML iterates in seconds where a Blender add-on takes minutes, and became something else when the same page was found capable of rendering the actual forms: radius and angle rules over an index chain need no engine. That makes it a place to explore and judge a form BEFORE committing it to a slow Blender build. VERIFIED by the Specification Owner rather than taken on trust: no external references of any kind (no CDN, no network call, no build step, CSP-safe), 15,079 bytes of JavaScript, Canvas 2D with hand-rolled point projection and no WebGL, prefers-reduced-motion honoured, population capped at 1200. D197 is implemented correctly - the module scale is growth^(i/(count-1)), so the tip-to-base ratio holds at any Population. Two defects found on review and raised as T032. The load-bearing issue the bench raised itself: this page carries its OWN copy of the growth laws, separate from the add-on's Python, and the two will drift. A website showing a form Blender will not reproduce breaks the one promise GAAD makes. Before this scales the laws must live in one shared definition both sides read. The bench's proposed next step solves it neatly: export a specimen as JSON (species, parameters, seed) - that IS the genome, and it is the file a Blender add-on could read to rebuild the same form - plus mesh export as OBJ or glTF. Answers P054, the browser dream, which until now had no feature against it.

F051 in build - Shell validated, Phyllotaxis rolled 24 Jul 2026

Per-species roll range: the Shell slice

The chain species drew their genes from a per-mode envelope shared by every species, so most seeds land in a species dead zone. A per-species window lets each species roll from its own emergence band. v3_028 proves the mechanism on Shell only: a SPECIES RANGE box shown when Species is Shell, min and max per gene, routing the Shell roll through it while the other four species and the 144 world stay unchanged. Awaits Miles's Blender test. Roadmap: roll to the other four with per-species storage, and reconcile that a Shell mutation still clamps to the mode limits, not the Shell window. Prompted by Miles's emergence recollection (Q042); tuned windows are candidate T1 material for A0020. PROGRESS 25 Jul, from the bench handover: Miles tested v3_028 in Blender and ACCEPTED the Shell window at its defaults - 'shell is fine' - so the first per-species emergence window stands without a tuning pass (Count 60-200, Radius 5-20 m, Growth 0.01-0.40, Rotation 6-30 deg, Twist 0-10 deg, Height 0-20). v3_029 then rolled the mechanism to PHYLLOTAXIS: Miles observed blooms spilling their plots threefold, ground truth traced it to r = Radius x sqrt(i) drawing Radius from the shared Wild envelope, and the phyllo Radius window (1.5-7.5) is a verified 2.89x shrink. Like Shell, Phyllotaxis now ignores Calm/Wild/Extreme - its window IS the envelope. Honest test status: Miles reported 'some issues' with v3_029, not yet itemised - the session pivoted to the clean UX and genome threads at his direction; itemising is A0027. Known v2 detail: a Shell specimen's mutation still clamps to gene_limits, not this window.

F050 built 24 Jul 2026

Growth Generator 144 galleries and ordered presets

Two ways to array 144 growths in a 12x12 grid, spacing auto-sized so cells do not overlap. Generate 144 draws each cell from the current RNG windows and toggles - a gallery of the rule set. 144 x Rule takes the current manual rule and grows 144 variations, each parameter jittered by a Spread fraction; the jitter is proportional so a recipe's zeros stay zero and every cell stays the same kind of form - Vortex then 144 x Rule gives a field of vortexes. Six ordered NATURE presets: Rosette, Helix, Horn, Fan, Vortex, Frond. The 144 field is the D196 harness doing its ruled job: a survey, not where design happens. Generate 144 v3_022; 144 x Rule and Spread v3_027; presets v3_023 and v3_026.

F049 built 24 Jul 2026

The Growth Generator becomes a parametric instrument

The 1994 Growth Generator gained direct controls for taking the model apart. The six Fig 2.17 outputs load their parameters into a MANUAL RULE slider set (Blocks, Rotation, Stack, Move, Climb, Grow X/Y/Z) that grows one rule deterministically. The Fig 2.18 random programme draws each parameter from a panel-set min/max window, defaulting to the 1994 thesis ranges from appendix A17, with a per-parameter toggle so a single behaviour can be soloed - what Miles called dissecting complexity rule by rule (Q041). An M1-M8 memory row saves a standing growth's segments and replays the exact form. Cube or Sphere module choice (D200). Every grow frames the viewport on the whole growth. Built across v3_017 to v3_026.

F048 built 24 Jul 2026

Demo tour: a walked playlist of forms for presenting

A DEMO subpanel walks a nineteen-frame playlist - the six named presets, a five-step D197 growth sweep, an extremes set and a complexity set - by Play (a modal timer Esc stops) or Step. Both morph the single specimen in place at one scene position; hold time is a Seconds field, default 0.1. Introduced v3_015, extended v3_016.

F047 built 24 Jul 2026

Test D197: prove the growth law is wired and holds

A Test D197 button introspects the shared engine graph and asserts the growth law: the power node takes its base from the Growth socket and its exponent from t, the normalised index guarded by max(Count-1,1), and that power drives the instance scale. It also grows a 50 vs 500 Spiral pair so the eye confirms the tip ratio holds at any Population, and prints a per-check pass or fail report. D197 validated in Blender 24 Jul, 5 of 5 checks plus the visual. The first run FAILED on a bug in the test itself - Blender hands out a fresh Python wrapper per node access, so identity comparison fails on the same node; fixed to match on node.name. Rule kept: never identity-compare Blender nodes. Introduced v3_012, diagnostics v3_013, fixed v3_014.

F046 built 24 Jul 2026

Reset AFAL: tear the bench down to first-run state

A Reset AFAL button with a confirm dialog removes every AFAL build - world, specimen, growth, presentation, D197-test and GG-array collections, both shared engines, and the parent, memory and demo slots - and returns the controls to defaults, leaving the default scene and the render and view settings alone. Restores the exact state a fresh script run leaves. Introduced v3_011, confirmed in Blender by Miles, extended as later collections arrived.

F045 built 23 Jul 2026

The 1994 Growth Generator, rebuilt from the thesis

Miles's original Growth Generator from his 1994 MSc thesis Digital Evolutions, rebuilt as its own section of the AFAL Studio panel and transcribed from the thesis pages rather than remembered. It is NOT an AFAL species and does not sit on the chain: it ACCUMULATES, every block derived from the one before rather than from its index. Five rules from the AutoLISP appendix - stack (y), move (x), climb (z), rotate (about z, the TOTAL sweep divided by the block count) and grow (scale ADDITIVE per axis, and free to go negative, which flips the block). Both thesis programmes are built: Fig 2.17's six worked outputs as buttons, and Fig 2.18's evolutionary run as seed plus segments, drawing its ranges from the appendix listing. The module is a 1 m cube, as the original was, so a stack factor of 1 puts faces exactly touching. Axes are the original's, because AutoCAD's plan view puts Y up the page. Implemented in Python with a small node group instancing the cube from baked point attributes, since accumulation is sequential and that is closer to the procedural original than a formula would be.

F044 proposed 22 Jul 2026

AFAL growth-behaviour library: shells, ferns, phyllotaxis, Voronoi, L-systems and more

Feature request to grow AFAL beyond its first behaviour (the spiral/helix) into a library of nature's-maths growth behaviours: shells, ferns, phyllotaxis, Voronoi, L-systems, branching, reaction-diffusion and others. Each is a ROADMAP candidate, not a commitment: every behaviour must walk the same road AFAL just did - its own T1 research (real reading), rules formed and code-matched, before it is built. Each conforms to the shared AFAL behaviour interface (reference, behaviour, parameters, rules, phenotype, mutation, validation, memory). Adding behaviours does not change what AFAL fundamentally is: deterministic, parametric, form from a parameter vector.

F043 in build 18 Jul 2026

Scene-aware Fly Past: Generate world orbit, Navigate string travel, Isolate stage orbit

One Fly Past button that reads the scene and flies the right shot (A0016): Generate orbits the whole world with the camera scaling to the nxn grid; Navigate travels down one lineage string, generation 1 to 3, disc centre to disc centre; Isolate keeps F042's proven single-stage 360. The panel button names the flight for the scene you are in; Render writes 640x480 H.264 MP4 to //Image/flypast/ with a Generate_/Navigate_/Isolate_ prefix. Built in addon v1_030; carried forward into v1_031 alongside the 12x12 grid extension. Validate carries Generate and Navigate step pairs. The choreography (rise over the forest, plan-to-perspective descent, lineage travel) is the next build once the base flights pass Miles's Blender gate.

F042 built 17 Jul 2026

Helicopter fly-past: 360 orbit of the isolated stage

The Isolator camera flies a full 360 degree orbit around the isolated stage, at the rig's existing offset (radius * 2.6, same elevation as the 3/4 still), aim locked on the stage centre. Start and end positions are identical - the orbit opens and closes on the canonical Present Stage framing, so the animation loops continuously. The three-point studio lights stay fixed relative to the stage, so the subject passes through key, fill and rim light as the camera circles. GAAD's first animated camera; the Isolator rig (v1_010/v1_011/v1_017) is the ancestor. Ruled by Miles 17 Jul 2026: shape 2 of 3 (World / Isolator / Navigator fly-pasts) - the cheapest proof, and what it proves carries into the other two. Built in addon v1_024 with two Validate steps (Fly Past starts / stops); awaiting Miles's Blender gate per D161. Proved by Miles in Blender 5.1.2, 17 Jul: orbit runs, Render Fly Past writes the MP4 to //Image/flypast/. Two 5.x API breaks fixed along the way (Action.fcurves, media_type before FFMPEG); shipped chain closed at addon v1_029.

F041 built 16 Jul 2026

Validator enforces field VALUES, not just presence

gaad_validate.py gains ITEM_VOCAB: a per-file map of field to allowed values, checked during the Schema pass. It imports the vocabulary from the generator's colour map rather than restating it, so the list cannot drift between the thing that validates and the thing that renders. First field enforced: decisions.origin (new / evolved / rebirth / 1994). Empty stays legal. Proved by injecting a prose origin into D001: Schema FAIL with the field, the record id, the offending value truncated to 40 chars, and the allowed list. Extending it to another field is one line in ITEM_VOCAB once its vocabulary is agreed.

F040 built 16 Jul 2026

gaad_site_stats.py - the homepage regenerated from the records

A generator that rebuilds the homepage stat cards and the records growth graph from Records/*.json. Counts and id ranges per record type, a rolling two-week window ending at the newest record's date, five plotted series, and a dot per day linking to the newest record that existed on it. It writes between STATS and RECGRAPH markers, inserting them on first run, so it can never touch the rest of the page. Run as: python Scripts/gaad_site_stats.py <website-root>. Not yet wired into gaad_build.py and carries no Validate step.

F039 built 16 Jul 2026

Language cards show readiness and version, coloured by rung

Six language cards on the homepage, ARAL added. Each carries a pill reading its readiness rung and version, read from the language file's own readiness_level (D165) and version rather than typed into the page, and links to that language's HTML view - all six views now published under /languages. The tagline sits beneath as a quiet second line. Frames and pills are coloured by rung: Gold for T7 Live in GAAD, Cyan for T4 Prototype runs, Light Grey for T3 Language agreed. The readiness ladder becomes visible at a glance, and the page cannot drift from the language files.

F038 built 15 Jul 2026

Tape ON / Tape OFF - the record made optional

A radio in the ARAL MUTATION box making the tape a choice rather than a cost. OFF records nothing: Mutate xN and Play run at full rebuild speed, STATUS reports (untaped), any prior tape stays frozen, and the Mutation Scrub greys out while an untaped run is live so it cannot drag a stale tape under a live stage. ON buffers the run in memory and commits to the scene once at run end - whatever the exit - removing the per-generation history copy whose cost grew with tape length. Built in aral_prototype_v1_025, default OFF from v1_027.

F037 built 14 Jul 2026

Mutate xN explorer + tape-deck transport (ARAL prototype)

An exploration rig in the ARAL prototype panel (aral_prototype_v1_011-v1_018): a 'Mutate xN' button + slider (1-100) runs Mutate repeatedly at 0.1s gaps via a modal timer, so emergent mutation is visible step by step (revealed the first real-time run, P061/Q038). A tape-deck transport (Rewind/Play/Stop/Pause over a prototype-local plan history) sits below it, with a big always-visible STOP banner while running. All mutation controls grouped in the MUTATION box, Allow-toggle first. Clear ARAL is a full reset. Prototype scaffolding (D167) - the transport interaction graduates into the platform lineage transport (F036); the local history retires at wiring. Extended 15 Jul 2026 (v1_021-v1_027): the header panel folded into a single STATUS box at the top of ARAL Controls; a stale-panel sweep on register kills panels left registered by prior runs; transport stepping gated on a wall clock and Stop made clickable mid-run (T028); Pause retired and Forward added, so the playhead steps both ways (D173); Tape ON/OFF with buffered commit (D172, F038); panel defaults set from Miles's working values.

F036 proposed 14 Jul 2026

Lineage transport - tape-deck Rewind / Play / Fast Forward for the design memory

A tape-deck transport for walking the GAAD lineage: Rewind steps back through generations, Play auto-advances at a tick, Fast Forward steps forward through bred generations, Pause/Stop hold position. A playback head for the design memory - because the lineage is preserved and nothing is destroyed, the whole evolutionary history can be scrubbed like tape. PROVEN in the ARAL prototype first (aral_prototype_v1_013: Play/Stop/Pause/Rewind over a prototype-local plan history, modal-timer driven, 0.1s tick), where it revealed real-time emergent mutation (Q038). That prototype transport is the proving ground; the platform version drives the Navigator / lineage.json / Backtrack (F006) rather than a local history. Fast Forward is the platform addition (the prototype has Rewind only, since forward = breed new). Status: PROTOTYPE PROVEN, platform build pending. TERMINOLOGY (future, F036): Rewind / Play / Fast Forward / Pause-Stop - the retro tape-deck register is deliberate (Rewind over Backward), warmer and true to the analogue era the 1994 work came from. MATURED 14 Jul 2026 (second session, aral_prototype_v1_019/v1_020): the prototype transport stopped being scaffolding and became a true tape. Before, Rewind was destructive - it popped generations off the history, so the future was erased as you stepped back and Play could only ever breed new. Now a separate PLAYHEAD index moves over a stored tape without destroying it, and the whole interaction settled into one rule Miles arrived at himself: PLAY REPLAYS WHERE TAPE EXISTS AND RECORDS WHERE IT DOES NOT. Rewind steps back one generation per click and replays it intact; Play advances at a speed slider (0.01-1.0s, default 0.2s) replaying recorded generations identically and only breeding fresh once past the live edge; mutating from a rewound point truncates the future and records a new branch, exactly as recording over a cassette erases what was ahead; a generation counter shows the head position; and a MUTATION SCRUB slider drags the head to any recorded generation and replays it, its range fitted to the tape so it can never land on a generation that does not exist. Mutate xN resets the tape and records a fresh 0..N run. The scrub is the piece Miles singled out (Q039, P062): it is Backtrack (F006) made interactive, and the playhead-over-stored-lineage machinery is precisely what the platform Navigator needs.

F035 built - in verification 12 Jul 2026

MSC 2.4 panel - ARAL's first Language Seed live in Blender

A second panel in the ARAL tab (aral_prototype_v1_002-v1_005) rebuilding thesis 2.4 from its seed source: 2.4A 3D Insertions (1:1:1 cube, nine placement grammars incl. the growth-spiral road and the printed three-step final algorithm) and 2.4B Growth Generator (2x1x1 primitive, six genes - number/stack/rotation/movement/scale/climb - with the six Fig 2.17 outputs as gene-exact one-click replay presets, plus the Fig 2.18 random-rules programme). Every run records a full plan; deterministic per seed. Rule semantics stated in print implemented as printed; scale taper, climb rise and clockwise sign flagged as rebirth interpretations (s18) awaiting Miles's eye. First emergent form banked as Q036 (mode 4, 452 cubes, seed 371401). v1_003 one-family-on-stage sweep; v1_004 dead-reference-safe materials; v1_005 default-Cube removal.

F034 in progress 11 Jul 2026

Gravity toggle - a world property that frees generated form from the ground plane

Since 1994 every generated form has stood on the ground. Gravity off lifts that rule - form composes freely in three dimensions, and GAAD steps beyond architecture. Gravity is a WORLD property (not a genome gene, not per-language): the Connector already passes world into random_genome, build and validate, so every language receives it without signature change. Replay obligation: the gravity state is recorded in the stage file alongside language/version fields (s7 family) so a stage always replays as made. Each language decides what gravity-off means for its rules (e.g. TWAL footprints-on-grid is a gravity-on rule). First home: ARAL, the art language born 11 Jul 2026 - gravity migrated there with the sphere when PRAL reset to its five 1994 primitives (languages do not mix). ON preserves stage-plane behaviour; OFF removes the stage and places objects around the world centre.

F033 in progress 10 Jul 2026

GAAD Language Connector - the runtime contract that lets any language run through world/stages/lineage

THE SOLUTION TO T021. GALF defines what an Architectural Language IS but, by its own neutrality rule, cannot own a runtime interface - so languages could be defined but not run through Initial Generation -> Breed -> Navigator/Backtrack -> Present Stage. The GAAD Language Connector is the second contract that closes this gap: GALF stays neutral by SILENCE (names no software), the Connector stays neutral by ABSTRACTION (names verbs, never a vendor). Engines are pluggable adapters behind the interface - Blender is one adapter; a browser renderer (P054, F032) is a peer. CORE SHIFT: seed -> genome. A seed cannot be bred (no locality, no recombination); the Connector makes the design an explicit GENOME - a gene array where each gene is one decision - and build() PURE, so replay is bit-exact (replay, never mutation). Interface verbs: describe, random_genome (the only RNG site), build, mutate, breed, serialize, deserialize, validate. STATE AT FILING: spec GAAD_Language_Connector_v0_001_TWAL.md + reference implementation twal_connector.py (engine-free, never imports bpy; MemoryAdapter proven), both RINGFENCED standalone with TWAL (D144 fence). Three three-seat decisions open at filing: (a) Connector as separate spec referencing GALF; (b) whether platform_status=active contractually requires a conforming Connector; (c) whether the serialize .CEL format is per-language or a shared platform envelope. T021 closes when a language runs through the platform loop via this contract. GRADUATION (when the fence lifts): spec -> Spec/, connector joins the Engine section, TWAL trio -> Languages/, TWAL_CHANGELOG -> releases record, D144 wording repaired to name TWAL/Connector explicitly. KEY DIAGRAM: Website/architecture.html Figure 1 ('CONTRACT - LANGUAGES - CONNECTOR - ENGINE') is the canonical picture of this feature - the four-layer stack (GALF names no engine; five languages conform up to GALF; the Connector names verbs, never a vendor; the Engine is the swappable base: Blender today, a browser/desktop renderer tomorrow). Its caption states the thesis: the seam is the point - swapping the engine changes the base of the stack, not the design above it. Figure 2 on the same page (TWAL, seed to genome to phenotype) is the worked example. UNWIRE REQUIREMENT (Miles, 10 Jul 2026): the Connector must be removable without harming the GAAD platform. Wiring is ADDITIVE-ONLY by design: (1) PRAL's native path is never modified - Connector languages take a parallel branch behind a CONNECTORS registry, so unwiring = deregistering (one dict entry), and with an empty registry the platform is exactly pre-Connector GAAD; (2) no core script may import a connector module at top level - imports live behind the registry lookup, so a missing/broken connector file cannot break addon registration or PRAL generation; (3) stage files made by a Connector language keep their genome payload even when unwired - existing lineages stay readable and honest (the stage reports its language as not-runnable rather than erroring); (4) Validate Scripts proves the unwired state: a step runs the PRAL loop with the registry emptied, so 'unwire is safe' is asserted, not assumed. This is the D144 fence philosophy carried into the platform: connection is a privilege the platform grants, not a dependency it acquires. DIAGRAM NEEDED (Miles, 10 Jul 2026): a new figure for the three-phase wiring plan - (1) stabilise the prototype, (2) Connector wrapper around it, (3) wire to the GAAD panel (unwireable). Shape agreed 10 Jul 2026 (Miles: likes the simplicity): three boxes - Prototype 'the sketchbook' -> sync -> Connector 'the fair copy' -> wire -> GAAD 'the gallery, never changes' - with a return arrow (back to the sketchbook, any time), the fence drawn as a dashed gate before GAAD, and the honesty rule as a strapline: 'A rule is not real until it is in both.' To be drawn in the website Figure style as architecture.html Figure 3.

D144D145

F032 parked 10 Jul 2026

Interactive two-minute demonstration page - one design, one click, the whole GAAD loop

PROPOSAL (Miles, 10 Jul 2026): the next website build is not another feature but a polished interactive demonstration. One page. One design. One click. The page shows: (1) a parent design; (2) four children appear; (3) the user selects one; (4) a new generation grows; (5) the Decision Tree updates; (6) the Design History updates; (7) replay of the complete journey. Success test: someone who has never seen GAAD understands it in under two minutes from this demonstration alone - memorable, complementing the existing site as its front-of-house proof. NOTES (Specification Owner): this is the browser dream (P054) made concrete and small - a renderer as a swappable adapter, running a genome->phenotype loop client-side. TWAL is the natural candidate language (smallest, genome-shaped, engine-free Connector already proven in twal_connector.py); a JS port of the Connector verbs (random_genome, build, mutate, breed, replay) would drive it. Steps 5-7 are the platform's own vocabulary on screen: Navigator (decision tree), lineage (design history), replay-never-mutation (the journey). Depends on the Connector three-seat decisions (T021) settling the genome and serialize form first. MEDIUM OPEN (Miles, 10 Jul 2026): the demonstration could equally be delivered as a video or a diagram rather than an interactive page - decide which medium is best when the feature is developed. The seven-step storyboard and the under-two-minutes test hold regardless of medium. PARKED: recorded so the idea is not lost; not scheduled. Sequencing suggestion: after TWAL graduation, as the flagship F031 deliverable.

D144

F031 parked 09 Jul 2026

Website + AI as the primary read interfaces (with searchable, live records)

INSIGHT (Miles, 09 Jul 2026): 'if i am looking for a record, I ask you or go to the website as it is easy to use.' In practice the two interfaces GAAD is actually read through are (a) the website and (b) asking an AI seat. The JSON source of truth, generators and bundle structure are PLUMBING that Miles does not touch by hand. This reframes priorities: the website is not a side publish artefact, it is the primary reading room, and the AI seat is the primary retrieval method - so both must be first-class and trustworthy. FEATURE CONSEQUENCES to build: 1. Website live data - records on the site should reflect live record data, not a snapshot frozen at publish time. If the website is the primary reader, a stale website is stale memory. (Supersedes the earlier 'live data on hold' note - this raises its priority.) 2. Website record search/filter - a search or filter box so 'find me the NASA thing' works ON THE SITE the way it works when asking the AI. The flat-table-with-category-filter pattern (audit/Records Hub) is the starting point; extend to free-text search across records. 3. Website always in the bundle - the reading room must travel with the project, never be orphaned as a separate zip (see the standing website-in-bundle rule). 4. AI retrieval must be disciplined - the primary 'ask Claude' path depends on the handover rules: search-first, do-not-parrot, verify-then-state (HANDOVER READ FIRST section). An AI that guesses instead of reading the records breaks the interface Miles relies on daily. Also captured this session and related: the daily audit log as a shareable blog post (one HTML page per day, native 4bim theme, deep-links into record HTMLs, opens with a records scoreboard). A website 'Daily' index page (daily.html) and publishing the daily series are the immediate follow-ons. PARKED: not started. Recorded so the strategic steer is not lost. Priority raised from 'on hold' to a recognised primary-interface concern.

D128D144D145

F030 adopted 12 Jul 2026

Validate Scripts: one button drives every command and validates against expected outcomes, watchably

Miles, 07 Jul, end of the Backtrack build day: 'I find I am doing the same tasks over and over again' - a script that runs and tests ALL the commands, like the Integrity test but validating against EXPECTED OUTCOMES, with its own button under Reset GAAD Platform labelled GAAD, so he can watch it run and visually detect errors. Working name GAAD Quality Run; proposed name PROVING RUN (architectural register - a proving run proves the platform; pairs with 'proof shot'), Miles to settle. Design: the in-viewport sibling of the D135 headless smoke test - ONE shared assertion library, two runners: headless (blender --background, CI-style, exit code) and watchable (the GAAD button, stepping through the real operators with a visible pause per step and a running PASS/FAIL readout). Sequence v0.1: Reset -> First Generation -> assert lineage.json + s1_g01 -> breed x3 -> assert string extension + creation index -> Backtrack via Navigator -> assert replay, champion gold, current_position -> breed from pivot -> assert string 2 + pivot record -> Navigator -> assert discs tangent, no overlap, connectors on rims, red/gold state colours, label stamps -> flip Colour/Grey/Bauhaus -> assert material sync in both scenes -> isolate + labels -> assert visibility rules -> summary. Each step declares its expected outcome BEFORE running (D135 practice 1, mechanised). Builds on: Integrity Check (static), gaad_validate.py (records), D135 smoke test (headless). Every future feature must add its step to the Proving Run - the definition of done grows with the platform. NAME SETTLED (Miles, 07 Jul): VALIDATE SCRIPTS. Button under Reset GAAD Platform; the headless runner remains gaad_smoke_test.py. AMENDMENT (Miles, 07 Jul evening): Validate Scripts needs a PAUSE button. Design note for the build: implement as a Blender MODAL operator driving a step queue on a timer - pause/resume/step-once then fall out naturally, and the live PASS/FAIL readout stays visible while paused so an error can be inspected in the viewport mid-run. BUILD v0.1 (08 Jul 2026, addon v0.99.02): delivered as three pieces. gaad_assert.py - the ONE shared assertion library (storage checks proven in-sandbox against clean and deliberately broken data before delivery); gaad_smoke_test.py - the headless runner per Spec/GAAD_SmokeTest_v0_01 (drives the real generator/tree scripts, simulates the backtrack via a lineage current_position edit, exit code 0 = PASS); Validate Scripts button in the panel under Reset GAAD Platform - modal operator on a timer stepping the REAL operators with a visible pause per step, live PASS/FAIL readout, Pause/Resume and Stop. Awaiting Miles's in-viewport proving run. The gaad_tree_layout.py bpy-free extraction remains queued as the companion piece. PROVEN (08 Jul 2026, 15:21, P051): first clean run, 18 steps 0 failures, addon v0.99.11 / generator v0_49 / tree v0_18 / gaad_assert v0.1.4. Report header records timestamp + full script inventory; Pause/Step/Stop live while running. Open follow-ons: T019 platform sweep; the unselected-tip Navigator design question. v1_007 (12 Jul 2026): the proving run now tests the Isolator from the NAVIGATOR as well as the Generator (steps 'Isolator from Navigator' + 'Back to Navigator', after Navigator rebuild) - the 1994 Fig 3.11 Navigate->Isolate flow. Full run: 26 steps, 0 failures, verified with TWAL graduated and live.

D135D132D133

F029 adopted 07 Jul 2026

Circular Navigator stages: the 1994 evolutionary tree language returns

Navigator lineage stages are circular discs, proposed by Miles ('circles like 1994 - they look more genetic') and runtime-confirmed same day ('such a quick fix fable - love it'). Returns the Navigator to the 1994 evolutionary tree plates (thesis Figs 3.21 / 3.28 / 3.29 - specimens under glass, cells in a lineage). The World keeps square stages: square = plot/site, the unit of WORK; circle = cell/specimen, the unit of MEMORY - the geometry itself distinguishes the two scenes at a glance, and the scene boundary quietly teaches the Evolve/Backtrack distinction on every crossing. Aligns the live tool with the website hero's dots-on-a-path and Q024's atoms (atoms are round). Disc diameter = stage size, same thickness, F028 colours, engine stamps and pivot connectors unchanged; raw-mesh 48-segment disc, zero bpy.ops. Shipped in tree v0_11; the decision record is D134.

D134D132D028

F028 adopted 07 Jul 2026

Navigator state colours: red dead ends, gold current champion, tips hidden

The Navigator's colour state language, designed by Miles's viewport markup and runtime-confirmed same day ('BINGO!'): every stage in the lineage array reads its fate at a glance. NEUTRAL GREY = history (a champion on the path); RED = dead end, each preserved string's last champion - the 1994 word made visible, where a line of work was honourably set aside; GOLD = the current champion, the active string's deepest decision, in the same CHAMPION_GOLD the Generator world uses (one colour, one meaning, both scenes - chosen over green for cross-scene consistency, green a one-line constant swap). Empty tip stages (bred but unjudged) are not rendered at all - no platform, no text; their data stays on disk untouched, and the red dead end becomes the string's true endpoint: its last DECISION. Rule of thumb: gold = newest string, that string's last decision - depth in the array is history, gold is recency; gold marks decisions, not transient backtrack position (a future white current_position ring can mark 'where am I now' - lineage.json already knows). Shipped in tree v0_10, carried into the circular discs of v0_11 (D134). Split out of F027 as its own feature at Miles's direction.

D134D133D132D042D028

F027 adopted 07 Jul 2026

Gold champion in the Navigator: see where each string finished, re-champion by selection

Miles, 07 Jul (during the F006 build, captured on hold pending his 0_123 storage-layer testing): in the Navigator view the gold champion is not visible today, yet it is a great visual clue to where a generative string last finished. Proposed: (1) the Navigator shows each string's latest champion in gold - the tip of every string readable at a glance across the lineage array; (2) clicking a stage in the Navigator to select a new champion turns that stage gold and returns to the World view with the same stage championed - the Navigator becomes not just the Track decision point (D133) but the re-championing surface. DESIGN NOTE to resolve when built: D133 agreed that selection never commits and only the button press does; this feature as described has the click turning gold and returning - reconcile whether the gold-turn is preview (commit still on the button) or whether re-championing in the Navigator is a deliberate exception to the selection-never-commits rule. Natural build companion to tree v0_8 (the multi-string Navigator, F024) since both touch the same render pass. Gold champion palette already shared via gaad_palette.py. OFF HOLD + REDESIGNED BY MARKUP (Miles, 07 Jul, after runtime-testing the array): (1) empty tip stages are NOT rendered at all - no platform, no text (their data stays on disk untouched); (2) each PRESERVED string's last champion stage is coloured RED - the dead end, the 1994 word made visible; (3) the ACTIVE string's last champion stage is GOLD (CHAMPION_GOLD, matching the Generator world's champion fill, D042 - chosen over green for one-colour-one-meaning across scenes; green remains a one-line constant swap, DEADEND_RED/CURRENT_GOLD in tree v0_10). Consequence accepted: the unjudged final grid of each string is no longer clickable in the Navigator - the red dead end is the string's last DECISION, the truer endpoint. Shipped in tree v0_10 (v0_9 was a withdrawn tip-label restyle; number retired). Re-champion-by-selection commit question from the original note: resolved in practice by D133 - the button commits, and the backtrack gold-turn on commit is live since addon v0_94. RUNTIME-CONFIRMED (Miles, 07 Jul, 'BINGO!'): tree v0_10 verified live - tips gone, two red dead ends on preserved strings, gold current champion on the active string's deepest decision. Confirmation screenshot banked at Website/episodes/ep4_lineage_array_dead_ends_red_champion_gold_07jul2026.png - candidate EP4 hero image alongside the P050 proof shot. Gold-vs-green settled by viewport: gold stands. SPLIT (Miles, 07 Jul): the colour state language (red dead ends / gold current champion / tips hidden) is now its own feature, F028. F027 remains the record of the original idea and the re-champion-by-selection interaction, resolved via D133.

D133D132D028

F026 adopted 05 Jul 2026

Architectural Language selector (PRAL / GRAL / MHAL)

LANGUAGE section at the top of the panel: a radio selecting the Architectural Language, with the Objects picker inside it (the language owns its objects, D098/D102). PRAL shows its five primitives; GRAL and MHAL are selectable but marked not yet built, gate MUTATION, and grey out First Generation (plus an operator guard). Locks at Gen 1 with the other world-shape choices. Reinstates the D099 selector that D113 parked, under the D123 naming. Built in addon v0_86 (property gaad_architectural_language).

D123D124D099D113

F025 adopted 05 Jul 2026

Stage Isolator render scene

Extend the existing Stage Isolator (F004, VIEW > Stage button) into a proper render scene: when a stage is isolated, present it as a focused render-ready view - clean background, framed camera, no grid or neighbour stages showing through, materials as chosen (Brand or Grey per D120). The Isolator today only hides other stages in the viewport; this feature makes the isolated stage a first-class output. Sits alongside T016 (Navigator materials + grids) - both are about scenes other than the Generator honouring the Colour choice and rendering cleanly. Miles's motivation: 'stage isolator render scene' - a way to present ONE selected design properly, ready to screenshot or share, without leaving the platform. Own session, own D### when built. BUILT 05 Jul 2026 (addon v0_84, carried in v0_85): a separate VIEW > Present Stage button renders the selected stage to a PNG in a new //Image folder - black studio world, key and fill sun rig, framed camera, other stages hidden from the render, materials as chosen (Brand or Grey). Kept as-is by Miles after test; future enhancements parked as T017.

F004D120T016D122

F024 next 7 days 03 Jul 2026

Evolution Tree showing forward AND backtrack lineage

The Navigator today (gaad_tree_v0_6.py) shows the forward lineage - the world as it was evolved. When Backtrack (F006) ships, the same tree needs to show BOTH directions from any moment: what was bred forward from it AND what alternative branches were rewound from. Reads as a directed graph rather than a straight chain - a design's true genealogy. Scope: touches the tree renderer, the Records data model (branch links from Backtrack events), the Navigator report, and how the Generator restores a branched state when a designer clicks a node. Related to T016 (Navigator materials + grids) - would be sensible to fix both in one Navigator pass. Own session, own D### when built.

D110F006F022

F023 open 03 Jul 2026

Rectangular stages (Manhattan-style)

Add rectangular stage footprints as an option alongside the square presets (D120). Reference size: Manhattan avenue-to-avenue block at approximately 80 x 275 metres (roughly 260 x 900 feet). Rectangular stages introduce genuinely different urban DNA: long thin blocks generate a different feeling world from square ones. Scope: touches the generator (stage geometry, per-stage layout, object placement rules, label position), the Navigator (stage previews and layouts), the camera framing (aspect ratio and view-all behaviour), the panel spec (stage-size selector grows a rectangular option) and the D110 grammar (world-shape choice, locks with the square-size selector). Deserves its own session and its own D### when built. Miles: 'just add as new feature'.

D120D110

F022 in build 02 Jul 2026

Rapid Evolution - selection IS the breeding act

Proposed by Miles (open, no action today - his explicit call): in Rapid Evolution mode, picking any object on a stage breeds the next generation from it immediately - no separate Next Generation click. Pick and breed collapse into one gesture; with the fast geometry (D106) a rebuild lands well under a second, so generations run at the speed of clicking. Miles: '1994 could never do this.' His usage narrative, preserved as design input: click, click, click, click - pause (panel control) - click object, spin around, inspect - then resume - click, click - Navigator - explore. Design sketch agreed in discussion: a MODE, not a replacement (toggle; classic two-step remains available); guarded trigger (only variant/stage geometry counts - labels, camera, furniture ignored); busy-lock ignores clicks while a build runs; technically a msgbus subscription on the active object deferring the build to a timer tick, which keeps the T006 safe-state pattern intact inside an event callback. The trap named and accepted for design: every click becomes a commitment - a stray inspection click replaces the generation on stage (JSON records everything, but mid-flow disruption is real), which is why Backtrack (F006) is the natural companion. Mode naming settled at the direction level as Evolve / Explore (with Backtrack the third verb) - see D110/P047; Play/Pause rejected since GAAD never breeds without the user's click. BUILT v1 as 'Rapid Stage Select' 03 Jul 2026 (addon v0_79 + generator v0_40, D119): additive toggle under Next Generation, msgbus watcher firing the existing operator, viewpoint preserved between breeds. First test verdict gold (P048); robustness gap after Navigator/Reset open as T015.

D106D110D118D119

F021 open 02 Jul 2026

Panel usage logging - capture GAAD operator clicks

Proposed by Miles during 0_107 testing: log every GAAD panel operator click. Two values: (1) crash forensics - Blender's own crash log only records bpy.ops calls, and the v0_33/v0_66 changes made GAAD quieter in that log (silent mesh builds, fewer ops); a GAAD-side event log flushed to disk per click survives a crash and gives the exact operator sequence and timing leading up to it, which today's T006 diagnosis lacked; (2) usage feedback - click counts per operator over real use show which panel commands earn their place, giving evidence for future panel decisions (decisions-become-data applied to the panel itself). Sketch agreed in discussion: append-only JSONL at Logs/gaad_usage_log.jsonl (new root folder, deliberately survives Reset); per event: timestamp, operator id + label, scene, grid size, generation, object count, result, duration ms; implemented as one shared wrapper applied to all GAAD operators at registration (no per-operator churn, no panel/UI change, so no conflict with the frozen mock-up D100); local only; a later generator can render usage-stats HTML into the existing pipeline. Open question flagged: visibility - always-on with no UI (simplest) vs a SETTINGS toggle (honest, but a panel addition that touches the D100 freeze). Claude's lean: always-on now, toggle when the panel next unfreezes.

D100

F020 parked-for-v0.04 01 Jul 2026

Document the idea-to-standard specification lifecycle

State explicitly the lifecycle a GAAD specification follows: idea -> draft -> peer review -> reference implementation (validation) -> standard (v1.00). Make it a shared convention future specs follow. Peer-review recommendation 5.

D103

F019 parked-for-v0.04 01 Jul 2026

Shared GAAD Principles record cited by all specs

Create a standalone gaad_principles record (JSON + doc) holding the shared principles (Understand People Before Geometry; Decisions become data; Structured knowledge before learning; platform vs language) that every future GAAD specification references from one source. Peer-review recommendation 4.

D103

F018 parked-for-v0.04 01 Jul 2026

DL v0.04: Terminology section referencing gaad_terminology.json

Add a Terminology section to the DL spec that references the existing gaad_terminology.json record and adds only DL-specific terms, rather than duplicating vocabulary. Peer-review recommendation 3.

D103

F017 parked-for-v0.04 01 Jul 2026

DL v0.04: unknown-key validation as warning within a reserved namespace

Downgrade unknown-key validation from error to warning ONLY within a reserved namespace (e.g. x_ prefix or an 'experimental' block); unknown keys elsewhere remain an error. Allows controlled evolution without losing the no-silent-private-extensions guarantee. Owner refinement of peer-review recommendation 2.

D103

F016 parked-for-v0.04 01 Jul 2026

DL v0.04: required-but-empty human-centred sections

Change People/Place/Experience from optional to required keys that must be present but may be explicitly null with a stated reason (e.g. PAL: applicable=false, reason='abstract primitive language'). Reinforces 'Understand People Before Geometry' while keeping honest validation. Owner refinement of peer-review recommendation 1.

D103

F015 open 30 Jun 2026

Geometry nodes as the primitive method for parametric AL languages

Investigate geometry nodes as the object-creation method for HAL and GRAL primitives (and any future Architectural Language), as an alternative to the direct mesh construction the GAAD generator uses from v0_33 (D106: raw vertex/face data joined per variant; before v0_33 primitives were individual bpy.ops objects, with only the dome using bmesh). Evaluated for new languages only; not a retrofit of the existing five GAAD primitives. TRADITIONAL BLENDER MESH (direct mesh/bmesh data) - current GAAD/MAL approach (v0_33, D106). Pros: simple and proven, already working at 9 to 81 stages; since v0_33 primitives are joined into one mesh per variant so object count stays flat as worlds scale (D106); triangle count, vertex count and bounding box are read directly from the mesh with no extra evaluation step; easy to score after the fact by measuring the finished geometry; no Blender version compatibility risk, since mesh/bmesh APIs are stable across versions. Cons: mutation means modifying the mesh directly (move verts, scale, rebuild), which is more code per shape; each shape variant is effectively hand-built logic in the generator; there is no single source of 'the design's parameters' - height, width and similar values must be inferred back out of geometry after building it rather than read directly. GEOMETRY NODES - candidate approach for new languages. Pros: the object's defining parameters live as readable, mutable input sockets (height, footprint, roof pitch), so they are first-class data rather than inferred from a finished mesh; one node graph can express many variants (a single Garden Room graph can become small or large, flat or pitched roof) rather than needing a discrete primitive type per variant; mutation becomes read parameter, mutate value, re-evaluate, which is closer to genuine genetic breeding than mesh editing, and aligns with D038 scoring since parameters can be scored directly without reverse-engineering geometry. Cons: heavier to evaluate at scale - untested whether 81 stages of evaluated geo-node objects stays performant; triangle and vertex counts require evaluating the dependency graph (object.evaluated_get(depsgraph)) rather than reading raw mesh data directly, which is slightly more code and slightly slower per object; more fragile across Blender versions, since geometry node socket APIs have shifted noticeably between 3.x and 4.x releases; steeper authoring cost, since building the node graph itself is more work than writing a bmesh primitive function. Summary: geometry nodes wins on parameter legibility for D038 scoring (clean, directly readable inputs); traditional objects win on measurement simplicity (trivial triangle/vertex counts, no depsgraph evaluation needed). Both are scoreable under D038; they expose different things easily.

D106

F014 open 29 Jun 2026

Auto-isolate on Create Next Generation

When Create Next Generation is clicked, automatically set the view to Stage Isolator (isolate the selected/champion stage). Saves the user from manually clicking Stage Isolator after every generation advance. The user can still click Show Stages to return to the full grid view.

F013 open 29 Jun 2026

Stage Isolator red state indicator

When Stage Isolator is clicked and a stage is isolated, the button should turn red to indicate the active isolated state. When Show Stages is clicked to restore the full grid, the red is removed and the button returns to its normal appearance. Gives clear visual feedback that the view is currently filtered.

F012 open 29 Jun 2026

Perspective View - EXPLORE viewport preset

A new Perspective View button in the EXPLORE panel section, positioned below 3D View. Switches to a low-angle perspective viewport similar to a street-level or eye-level camera. Complements the existing 3D View (elevated perspective) and Plan View (top-down orthographic).

F011 adopted 28 Jun 2026

Stage Size — Configurable Grid Layout

A Stage Size selector in the Object Collection panel allowing the user to choose the grid layout before creating Generation 1. Three options: 2×2 Classic (4 stages), 3×3 Default (9 stages, the standard layout), and 4×4 Testing (16 stages). The generator builds the grid dynamically using a build_stage_grid(n) function. Each stage keeps the same physical size; only the grid footprint changes. Implemented in generator v0_28 and addon v0_49.

D080

F010 adopted 27 Jun 2026

Plan View & 3D View — EXPLORE viewport presets

Two new buttons in the EXPLORE panel section: '3D View' switches to a perspective view angled at 65° looking down at the stage grid; 'Plan View' switches to a top-down orthographic plan view of all stages. Plan View resolves the 1994 thesis '2D Development Zone' feature (audit row). Both use Blender's region_3d to set view_perspective, view_rotation, and view_distance, then call view_all to frame the grid. Added in addon v0_47.

D078

F009 in-progress 27 Jun 2026

Sidebar Panel Redesign — Group by Intent

Redesign the GAAD Rebirth N-panel, which grew bottom-up so every control carries equal visual weight and reference material dominates. Reorganise into intent groups: Object Collection (setup) > Generate > Explore > collapsible Reports / Records / About & Versions > a divided, guarded Reset. Emphasise the single primary action (Create First Generation on a fresh/reset world, Create Next Generation once Gen 1 exists). Demote reference sections into default-closed collapsible sub-panels, keeping the collapsing header. See D074 (naming), D075 (Type taxonomy / single-Type selection), D076 (mutation toggle wording). UPDATE (27 Jun): added a dedicated MUTATION section (its own home, future home of F008) holding the 'Allow Mutation to Other Types' toggle plus per-object and population mutation sliders (shape switch, width/depth, height, rotation drift, position X/Y, add/remove object, min/max objects) that expose the generator's tuning values (D077) as live scene properties. Mutation renders as a collapsible sub-panel, CLOSED by default, to keep the everyday panel short. GENERATE buttons ordered Create First Generation above Create Next Generation. UPDATE (27 Jun, Chat 6): Mutation sliders are now LIVE — generator v0_26 reads scene properties at call time via _mut() helper, falling back to D077 defaults. Each generation's JSON records the active mutation settings under generation.mutation_settings.

D074D075D076D077

F008 open 27 Jun 2026

Mutation Toggle — Switch Objects On/Off per Generation

A panel toggle to control whether objects (primitives) can be switched on or off during mutation across generations. When enabled, the mutation process can add or remove individual objects from a stage, not just change their properties. Gives the user control over whether each generation can gain or lose objects entirely, as opposed to just mutating existing ones.

F007 open 26 Jun 2026

Genetic Engineering — Inject New Cells

A forward search mechanism that allows the user to artificially accelerate the design toward a goal — called Genetic Engineering (GE) in the 1994 thesis (Fig 3.18, 3.19). Unlike natural mutation which follows the evolutionary path, GE introduces a break in the genetic tree by injecting new cells / a micro phenotype directly. Example from 1994: setting rotation to 10 degrees globally, then using GE to change this gene — the desired outcome can be achieved much faster. GE is an unnatural adjustment and an interference with the evolutionary process, but allows quite radical changes to the evolutionary path. In the algorithm (Fig 3.19), a genetic engineer decision point sits inside the genetic loop — if yes, inject new cells and engineer genes, then re-enter the loop. Severe GE may cause previously recognised features in past generations to be lost (break in genetic tree). This is a future capability once the core backtrack (F006) and seed storage (D030) are in place.

D030D038

F006 next 7 days 08 Jul 2026

Backtrack

Ability to step back or forward through the design lineage - a core feature of the original 1994 GAAD thesis (Fig 3.16, 3.17). In the 1994 algorithm, a Track decision point sits outside the main genetic loop. The user chooses forward or back: Forward track checks if a forward generation exists - if yes, go forward one generation; if no, WARNING: there is no generation forward of this one. Back track checks if a previous generation exists - if yes, go back one generation; if no, WARNING: this is the progenitor, nothing exists before this. Once repositioned, the user re-enters the genetic loop and can grow progeny from that point, creating a new branch. The full genetic path is recorded so pivot progenies are always reachable. The Design Evolution tree is the data structure that makes this possible. Implementing backtrack in Rebirth is a direct test of the revival against the original 1994 system. Depends on seed storage (D030) and is tracked under D045 (backward/forward tracking). ELEVATED 02 Jul 2026: Backtrack is promoted from convenience utility to one of the platform's three core verbs (Evolve / Explore / Backtrack, D110, P047). Rapid Evolution (F022) makes it much more valuable: fearless one-click breeding wants a one-click step-back as its safety net. Candidate companion for the same build when F022 is implemented. NEXT 7 DAYS (Miles, 03 Jul 2026): with EVOLVE shipped as Rapid Stage Select (F022, D119) and the click-click-click loop live at 0.3s per generation (T012 closed, D118), Backtrack is the natural companion - every click is a commitment and evolution needs an undo. Big topic: touches storage (D030 seed reconstruct), the Navigator (F024 fwd+back tree), the D110 grammar (Evolve / Explore / Backtrack) and lineage. Own session, own D### when built. THESIS AUDIT 07 Jul 2026 (Chapter 3 reread, Figs 3.14-3.29): Both Forward and Backward tracking are REPLAY functions - they restore macro phenotypes from genes already stored in the gene bank and never mutate, unlike Forward Search which varies the genes. This maps directly onto D030 (store the recipe, not the cake). Backtrack exists to escape the stated dead-end limitation of Forward Search alone (Fig 3.14): the user backtracks to a PIVOT PROGENY showing greater potential and a new genetic string branches from it (Fig 3.16). Only the current path is recorded as data; dead-end paths stay visible in the tree but are ignored. Unique file naming generation_visitcount_quadrant.CEL keeps revisits distinct (8_3 = 8th generation, 3rd visit; Fig 3.25's worked path alternates forward search and backtracks A-K, including a backtrack right to the progenitor and a fifth genetic string from there). A Right Back button jumps to the progenitor in one step. Genetic Engineering causes a recorded 'break in genetic tree' (Fig 3.18) - a boundary case the Rebirth lineage model must represent. The 4th-dimension framing: time between generations is GAAD's 4th dimension; the user moves forwards and backwards through the design evolution with all design decisions recorded. v0_99: the button self-labels in three states and arms red - 'Backtrack' (idle) -> 'Select Stage for Backtrack' (red, in Navigator) -> 'Backtrack to String {s} / Gen {g}' (red, disc selected) -> commit returns to the Generator as plain 'Backtrack' (D138).

D030D045D110D118D119D138

F005 adopted 26 Jun 2026

Orthogonal Rotation Only

Option to constrain primitive placement to orthogonal rotations only (0, 90, 180, 270 degrees). When enabled, primitives on each stage are placed at right-angle increments only, giving a cleaner, more architectural feel to the generated designs. Implemented in generator v0_24 and addon v0_43 as a toggle in the Object Collection panel.

F004 adopted 08 Jul 2026

Isolator (GAAD Isolator scene)

Panel command Isolator: shows the selected stage on its own in a dedicated GAAD Isolator scene, a peer of GAAD Generator and GAAD Navigator. The stage's objects are linked (not copied) into the Isolator scene so geometry and materials stay in sync with the Generator; the scene carries its own HUD (Isolator - Stage N). Switched from the panel top row alongside Generator and Navigator - one click, no toggle. Reworked from the original visibility-toggle isolate in addon v0_98 (D137); Generator-fed for now.

D079D137

F003 open 26 Jun 2026

generate_handover.py

A script that auto-writes HANDOVER.md from the JSON records at the end of each session. Covers current bundle version, open decisions, latest script versions, sensible next steps, and recent pivotal moments. Removes the need to manually update the handover note daily.

F002 open 26 Jun 2026

GAAD Logo in HTML Records

Update all HTML record pages to include the GAAD logo image (gaad_logo_white.png on dark pages). Currently all pages use the text "GAAD" as a logo placeholder. Needs doing across all six HTML files.

F001 open 26 Jun 2026

Auto Testing Environment

An automated way to test GAAD script changes without manually running through the full Blender workflow each time. Would allow rapid validation of generator, tree, and addon changes, catching regressions before they reach a bundle zip.