[:<~>:]

• Recovered the complete STM32 UART packet format, including sync byte, flags, sequence number, command, payload length, payload and CRC.
• Reverse engineered the CRC implementation (CRC-16/CCITT-FALSE, polynomial 0x1021, initial value 0xFFFF) and reproduced it in software.
• Recovered the packet builder function and fully understood how Linux constructs packets before sending them to the STM32.
• Confirmed payload endianness: packet headers use big-endian command IDs, while multi-byte payload values are transmitted little-endian.
• Recovered the descriptor structures used internally by cubeclient for packet generation and transmission.
• Reverse engineered the common transmission routine (A68E4) responsible for sequence numbers, packet creation and UART transmission.
• Identified several ILaser commands, including laser enable, position control and additional control packets.
• Recovered the complete Uart class implementation, including constructor, read(), write(), close() and the serial port configuration routine.
• Recovered the UART baud-rate lookup table and character-size lookup table used during serial port configuration.
• Confirmed that cubeclient communicates with the STM32 exclusively via /dev/ttyS1.
• Verified that UART communication is performed through a C++ virtual interface (IUart/Uart), with the low-level implementation hidden behind virtual dispatch.
• Located and reconstructed the Uart vtable, identifying the locations of all major UART methods.
• Disassembled the service factory responsible for constructing and registering the global UART service.
• Confirmed that the UART service is passed into higher-level objects rather than accessed globally after initialisation.
• Investigated multiple virtual call sites and determined that the serial port is opened exclusively through virtual dispatch rather than direct function calls.
• Reached the point where nearly all remaining unknowns require runtime observation rather than further static analysis.
• Established that we now understand the Linux-side communication protocol well enough to begin writing a clean-room GroveCube replacement daemon that communicates directly with the STM32 without relying on Petcube's original software.

• Identified and fixed the kernel module ABI mismatch by enabling CONFIG_ARM_UNWIND.
• Rebuilt the RTL8188EU driver with the corrected kernel configuration.
• Successfully loaded the rebuilt driver into the PetCube kernel without module loader failures.
• Confirmed the driver reaches rtw_drv_init() and enters usb_dvobj_init().
• Traced the new crash to usb_dvobj_init() line 611 using addr2line.
• Determined the next issue is a USB structure layout mismatch around usb_device->actconfig.
• Added new diagnostics to inspect struct usb_device before dereferencing actconfig.
• Verified the new diagnostic code is in place and ready for testing tomorrow.

• Completed a comprehensive reverse engineering survey of the Petcube Gen 1 hardware and firmware.
• Confirmed that the entire operating system runs from the removable microSD card; no active NAND storage is used.
• Mapped the SD card layout and identified the purpose of all major partitions, including the bootloader, recovery environment, root filesystem, and firmware update partition.
• Documented the complete boot process from the Allwinner A13 Boot ROM through Linux to the Petcube application.
• Created a full backup image of the working development SD card and verified it with a SHA-256 checksum, establishing a permanent restoration point.
• Preserved the original failing SD card untouched to maintain an authentic recovery source.
• Decoded the Allwinner script.bin hardware configuration, revealing GPIO assignments, memory configuration, peripherals, and STM32 control pins.
• Confirmed that the companion STM32 microcontroller is responsible for low-level hardware functions including laser control, mirror control, LED control, calibration data, and production information.
• Determined that Linux communicates with the STM32 over the I²C bus (/dev/i2c-1), rather than directly controlling the hardware.
• Mapped the internal software architecture, identifying three local gRPC services:
  • EventServer
  • ConfigService
  • PeripheralService
• Located the engineering command-line interface (CLI) used by the original firmware for diagnostics, calibration, registration, and production tasks.
• Identified the dedicated LaserService responsible for laser playback, live control, and mirror positioning.
• Confirmed that mirror positioning and laser brightness are controlled independently through functions such as SetCoilsPos() and SetLaserBrightness().
• Discovered human-readable laser pattern files describing mirror trajectories as X/Y coordinate sequences with timing information.
• Confirmed that the firmware supports both prerecorded laser patterns and live network-controlled laser operation over UDP.
• Recovered evidence of factory calibration data for the mirror coils and RGB LED.
• Mapped the proprietary software contained under /home/petcube, separating the original Petcube applications from the underlying Linux system.
• Established a safe development workflow based on cloned SD cards and verified backups, allowing future experimentation without risking the original hardware.
• Current project focus shifts from gaining access to understanding and replacing individual software components while preserving the original hardware platform.
• Long-term objective: transform the Petcube from a closed commercial device into a fully understood and programmable embedded Linux robotics platform.

• Decided to obtain a real TLS certificate using acme.sh with DNS TXT validation instead of HTTP validation.
• Registered the first ACME account and generated the account key successfully.
• Generated the DNS challenge tokens for both thegrovelab.net and www.thegrovelab.net.
• Learned how DNS-01 validation works by creating the required _acme-challenge TXT records.
• Discovered that the TXT records never appeared because the domain was still using the ns5/ns6/ns7 nameserver infrastructure while the DNS Manager only controlled ns9/ns10.
• Tracked the problem down using dig, whois, and direct queries against the authoritative nameservers.
• Understood the difference between a domain's authoritative nameservers and the DNS zone being edited.
• Migrated the domain from the old DNS platform to the new ns9.dnsireland.com / ns10.dnsireland.com infrastructure.
• Recreated the complete DNS zone on the new platform, including A, CNAME, MX, and ACME TXT records.
• Watched DNS propagation in real time using dig NS, dig A, and dig TXT until the Internet began serving the new zone.
• Successfully completed DNS validation and obtained the first Let's Encrypt ECC certificate for thegrovelab.net.
• Generated the certificate, private key, intermediate certificate, and full certificate chain using acme.sh.
• Uploaded the certificate and matching private key into the LetsHost SSL manager.
• Verified the installation using curl -Iv https://thegrovelab.net/, confirming a valid TLS 1.3 connection and successful certificate verification.
• Brought https://www.thegrovelab.net online with a trusted Let's Encrypt certificate.
• Learned a practical end-to-end workflow covering DNS, authoritative nameservers, DNS propagation, ACME challenges, certificate generation, certificate installation, and HTTPS verification.

• Successfully diagnosed the previous Microsoft C/C++ 7.0 installation as an incomplete, failed install caused by missing runtime files.
• Discovered the correct hard disk installation method for Microsoft C/C++ 7.0 using extracted floppy images.
• Solved the long-standing installation problem by identifying that the installer requires source directories named DISK1 through DISK9, not DISK01 through DISK09.
• Completed a clean installation of Microsoft C/C++ 7.0 on the Compaq Armada 1500c after years of unsuccessful attempts.
• Verified the installation by successfully launching the Microsoft C/C++ 7.0 Optimizing Compiler and confirming a healthy toolchain.
• Restored the complete historical development environment, including Programmer's WorkBench, CodeView, reference manuals and development tools.
• Compiled and executed the first C program on the restored system, printing:
  Hello from Armada and Microsoft C/C++ 7.0
• Established the Compaq Armada 1500c as the dedicated vintage programming workstation for exploring The Black Art of 3D Game Programming.
• Documented an obscure installation quirk that is likely to help future restorations of Microsoft C/C++ 7.0.
• Explored future ideas for integrating the Armada into the Grove Lab as a permanent development resident via Wi-Fi, SSH, Telnet or a direct serial console.
• Confirmed that a project envisioned years ago—the reason the Armada was originally acquired—has finally become reality.

• Performed a clean installation of Debian 13 on the 2019 iMac (AEONTILE), replacing the previous heat-corrupted installation.
• Recovered the system after the installer's DHCP failure by manually configuring the network interface.
• Restored the APT package manager by recreating the missing Debian repository configuration.
• Diagnosed and repaired the missing start-stop-daemon link, restoring normal package installation.
• Installed essential administration tools and configured sudo access for the slaine user.
• Enabled secure remote administration by configuring and testing OpenSSH.
• Identified the Broadcom BCM4364 wireless chipset and traced the missing Apple firmware through kernel diagnostics.
• Extracted the original Broadcom Wi-Fi firmware directly from the macOS installation using the T2Linux firmware extraction tools.
• Successfully brought the BCM4364 wireless interface (wlp5s0) online after resolving the required firmware components.
• Installed NetworkManager and connected AEONTILE to the local Wi-Fi network.
• Verified full network functionality over Wi-Fi, including DHCP, DNS resolution, and access to thegrovelab.net.
• Completed the "Iron Test" by disconnecting Ethernet and successfully reconnecting to AEONTILE exclusively via Wi-Fi over SSH.
• Established AEONTILE as a fully operational Grove Lab workstation, ready for software development, experimentation, and future projects.

• Prepared the first shellac and methylated spirits test mixtures and learned the basics of mixing shellac by weight.
• Discovered that the grass composite readily absorbs shellac, strengthening the material while preserving its natural feel.
• Successfully treated the prototype grass d20, confirming improved rigidity and durability with only a modest colour change.
• Applied shellac to a hand-carved pine chess knight and observed the wood grain and warm finish come to life.
• Tested shellac on a bamboo box, exploring its effect on bamboo as a natural finish.
• Coated a Grove Lab symbol test piece to evaluate compatibility between marker ink and shellac.
• Established the untreated grass paper specimen as the archive control sample for future aging and finish comparisons.
• Observed that the grass composite retains alcohol longer than wood, revealing differences in how the materials absorb and release the finish.
• Confirmed that shellac can strengthen natural fibre composites without making them lose their grass-like character.
• Took the first practical steps toward using shellac as a standard finishing process within the Grove Lab's Natural Material Research Station.
• Added validation to ignore empty or invalid transmissions in the room.
• Resolved file permission and transmission issues by encoding messages before sending.
• Renamed "SPACE" to "LETTER GAP" to better reflect Morse code terminology.

• Created the first working Transmission Room for the Grove Lab.
• Added live Morse decoding beneath the transmission.
• Implemented Morse audio playback for dots, dashes, and full transmissions.
• Added support for letters, numbers, and common punctuation including @ and .
• Stored transmitted messages with timestamps in a transmission log.
• Resolved file permission issues for the transmission archive.
• Discovered the room naturally teaches Morse code through use.
• Renamed the READY development system from GroveLab to ready.
• Identified cloud-init as the hostname override and disabled its startup services.
• Disabled ModemManager and reviewed all remaining running system services.
• Defined the core READY philosophy: install tools only when a real project requires them.
• Decided to keep the initial toolset focused on C, Python, Make and CMake.
• Clarified the difference between apt update and apt upgrade.
• Designed and refined the READY terminal banner and identity.
• Successfully accessed and filtered the Grove Lab website using curl, grep and a Unix pipe.
• Established a guiding principle: don't make computing harder than necessary, but don't make it so easy that it stops teaching.

• Changed the Hermes to a moving-paper view with a fixed typing position.
• Expanded the writing window to show more of the page for easier cross-referencing.
• Fine-tuned the carriage pointer alignment with the next character.
• Confirmed that permanent typing and overtyping create the desired typewriter workflow.
• Tested automatic page saving and settled on JPEG as the current output format.
• Decided to remove menus and dialogs in favour of a simple, self-discovering interface.
• Agreed that the line feed option is unnecessary and should remain manual.
• Defined Hermes as a set of writing rules rather than a strict hardware emulation.
• Planned optional sound support through a single setting in profile.py.
• Decided to distribute Hermes as a recovered "HERMES EMULATION BACKUP ARCHIVE" rather than as a standalone application.
• Confirmed that Grove artefacts earn their place through use before becoming part of the Lab.
• Embedded the real Tailscale backend into ScaleTail and verified it starts successfully.
• Confirmed the backend creates its encrypted state store and LocalBackend without errors.
• Implemented real backend control for Connect and Disconnect.
• Added backend state inspection and confirmed the initial state is NoState.
• Connected the "Login with Auth Key" button to the real authentication path.
• Performed the first real authentication attempt with a one-off Tailscale auth key.
• Verified the auth key reaches the real backend and initiates registration.
• Identified the next blocker: encrypted state persistence fails with an Android security exception before registration completes.
• Confirmed the remaining challenge is Android storage compatibility rather than Tailscale authentication or networking.

• Created ScaleTail v0.6 with Java → C → Go logging.
• Confirmed Go code executes and returns safely on Android 4.4.2.
• Added secure string passing from Java to Go for auth keys.
• Implemented auth key masking inside the Go bridge.
• Built a persistent Go backend loop with heartbeat logging.
• Added clean backend start and stop functionality.
• Verified Java commands continue working while the Go backend is running.
• Introduced a Go command bus for backend communication.
• Queued and processed Login, Connect and Disconnect commands through the command bus.
• Added backend state tracking and heartbeat status reporting.
• Confirmed commands are safely ignored after backend shutdown.
• Discovered Tailscale's experimental authkey_intent branch.
• Identified auth keys as the preferred future login path over browser authentication.
• Mapped the architecture from Java UI through JNI and Go to the future Tailscale backend.
• Reached ScaleTail v1.0 with a complete end-to-end prototype backend architecture.

• Identified the Johne Wien XVI watch as a likely post-war Swiss "Wehrmachtswerk" with local Viennese provenance.
• Discovered that Ludwig Johne was the watchmaker behind the Johne name in Ottakring.
• Examined the watch case, service marks, and movement clues without opening the watch.
• Cleaned and lubricated the 1931 Meccano clockwork motor bearings.
• Diagnosed the end-of-run jerks as mainspring stick-slip caused by old grease.
• Repeatedly flushed decades of old grease and dirt from the motor.
• Accidentally removed the mainspring and completed a full spring service.
• Cleaned the mainspring and barrel, then applied a thin, even layer of fresh grease.
• Designed a prototype mainspring insertion tool from a snus can and learned a better assembly method.
• Reassembled the entire motor and restored smooth, jerk-free operation.
• Measured the motor's runtime and confirmed stable, smooth power delivery.
• Recovered the "lost" bottle of Moebius oil from one shelf lower than expected.
• Began planning a future Grove Lab project that gives the restored spring motor a new purpose.

• Created the initial Hermes_1943 emulator project structure.
• Added the original Hermes 1943 typeface to the project.
• Created a configurable machine profile for paper, ribbon and carriage settings.
• Calibrated character width and margins against the real Hermes Baby.
• Increased the internal paper resolution for sharper typing.
• Implemented permanent typing onto the page without text editing.
• Added a carriage pointer to show the next typing position.
• Implemented realistic carriage movement with backspace and return.
• Implemented the bell position and mechanical hard stop.
• Decided to model the software as a faithful Hermes emulator rather than a word processor.

• Explored the foxhole radio and the role of the antenna, coil, diode, ground and earphone.
• Built an intuitive model of coils as magnetic memory rather than amplification.
• Reframed resistors as components that transform organized electrical energy into heat.
• Developed an energy-first view of circuits instead of an electron-first view.
• Separated the concepts of electrons, fields, energy and the propagating pattern.
• Built a new mental model of capacitors using separated charge and electric fields.
• Identified the battery as a chemical charge separator maintaining non-equilibrium.
• Discussed equilibrium as the driving force behind electrical circuits.
• Explored Grove Lab calligraphy and its artifact-like aesthetic.
• Experimented with typewriter-inspired symbols and modular letterforms.
• Reflected on typewriter design as a creative constraint and a form of meditation.

• Designed and implemented the Auditorium Resident System.
• Added a procedural noise floor, residents and hall reverb.
• Replaced buttons with a text-based Live Microphone switch.
• Published the Auditorium on the Grove Lab website.
• Established the Tilephonic Field as a live listening instrument.
• Developed the concept of selectable Tilephonic listeners.
• Typed and archived the first public Grove Lab homepage.
• Verified the dynamic IP updater and event logging.
• Outlined a new direction for the Grove BBS.
• Discovered that compressed grass composite can hold complex molded shapes.
• Successfully molded and dried the first grass-fiber D20 half.
• Confirmed that the composite can be sanded after fully curing.
• Found that sanded surfaces create a good texture for future glue joints.
• Produced the first successful grass-fiber relief sculpture (Stinkor).
• Discovered that fermented grass develops a pleasant tobacco-like aroma.
• Confirmed the aroma survives drying in the finished composite.
• Investigated the failed blender and narrowed the fault to the switch or control circuit.
• Built and evaluated the first working Scarab business card prototype.
• Identified weaknesses in the spring, latch, and wing mechanism.
• Decided the resting state should be closed, not spring-open.
• Shifted the design toward historically inspired Egyptian winged scarab amulets.
• Simplified the overall silhouette to a rounder, more iconic scarab.
• Separated the visual design from the mechanical design for easier iteration.
• Decided the scarab remains the visual centerpiece while the wings become the mechanism.
• Concluded that the underside is the most authentic location for contact information.
• Studied feather structure to understand how wing geometry is organized.
• Developed the idea of a two-segment folding wing with shoulder and wrist hinges.
• Realized the opening motion itself should become the signature feature of the object.
• Established a clear direction for the next prototype based on simpler forms and hidden mechanics.

• Completed the first explorable version of the Grove Library.
• Added the Acer Iconia A1-810 as the first borrowable artifact.
• Created the initial /rooms/library/ archive structure.
• Added the first environmental storytelling elements to the Library.
• Introduced the .smallprint style for subtle hints.
• Introduced the .leader style for highlighted titles.
• Completed the Grove BBS dynamic IP updater service.
• Scheduled automatic IP updates with cron.
• Verified the first successful automated website update.
• Integrated downloadable text artifacts into the Library.
• Added gentle hints encouraging visitors to keep borrowed items.
• Experimented with the Hermes 1943 typeface for the Grove.
• Added embedded fonts with a monospace fallback.
• Verified full compatibility with text-only browsers.
• Refined the Grove's visual identity and navigation.

• ✓ Recovered approximately 600 GB of storage by removing an old Time Machine snapshot.
• ✓ Created space for the future Aeon Tile by repartitioning the 2019 iMac.
• ✓ Prepared and flashed a Debian 13.5 installation USB stick.
• ✓ Connected the Cisco Catalyst switch into the Grove network and confirmed basic operation.
• ✓ Successfully completed a Debian installation with working network configuration.
• ✓ Diagnosed GRUB, initramfs, and root filesystem boot issues on the iMac.
• ✓ Manually booted Debian by identifying the correct partition and supplying the missing root= parameter.
• ✓ Reached the Aeon Tile login prompt for the first time.
• ✓ Performed thermal testing on the iMac and gathered useful cooling diagnostics.
• ✓ Confirmed that the Linux boot problem and the thermal problem are likely separate issues.
• ✓ Rediscovered how digital sound ultimately emerges from numbers, voltages, and moving air.
• ✓ Realized that a modern computer can become a powerful software synthesizer through code alone.
• ✓ Explored browser-based sound synthesis using the Web Audio API.
• ✓ Refined the concept of the Auditorium as the Grove's dedicated space for sound experiments.
• ✓ Reunited the old Tilephonic Field concept with the modern Grove and Auditorium vision.
• ✓ Expanded the Tilephonic Field idea to include weather, radio activity, satellites, time, and visitor traces.
• ✓ Confirmed that expression itself—not recognition—is the true purpose of the Grove.
• ✓ Identified the recurring pattern behind the Grove: Listen. Understand. Leave a trace.

• Connected to GROVE-SW1 via Cisco console cable from the 2012 iMac.
• Verified Cisco Catalyst WS-C2960-48TC-S hardware and IOS version.
• Confirmed the switch was factory reset and free of previous configuration.
• Renamed the switch from "Switch" to "GROVE-SW1".
• Learned basic IOS navigation and privileged EXEC mode.
• Inspected running configuration, interfaces, flash, and system information.
• Connected the Pi 400 to FastEthernet0/1.
• Observed link state changes as the port came online.
• Observed VLAN1 automatically transition from down to up.
• Verified interface status using show interfaces status.
• Verified interface health using show ip interface brief.
• Observed GROVE-SW1 dynamically learn the Pi 400 MAC address.
• Learned how Ethernet switches build and use MAC address tables.
• Learned how to safely exit a serial console session using GNU Screen.
• Built a temporary wooden stand and mounted GROVE-SW1 above the VCR.
• Verified stable operation after several hours with minimal heat output.
• Successfully commissioned GROVE-SW1 as the Grove's first enterprise switch.
• Created the ScaleTail fork branch
• Identified the original crash source: libgio.so → sigfillset → Android 4.4 crash
• Successfully built and installed a modified Tailscale APK on the Acer
• Lowered APK compatibility from Android 5.1+ territory down to KitKat-compatible installation
• Removed Gio from the application startup path
• Replaced the Gio launcher with a custom Android MainActivity
• Proved the Acer can launch a modern rebuilt app without Gio
• Tracked down and removed the next crash (onConnectivityChanged native callback)
• Booted ScaleTail v0.0 on real hardware
• Displayed the first ScaleTail screen: "ScaleTail v0.0 – No Gio loaded."
• Demonstrated that the Acer Iconia A1-810 is still capable of running newly compiled custom software in 2026
• Mapped the Tailscale architecture enough to identify the backend/UI separation
• Found the backend event bridge (requestBackend() → backendEvents)
• Established a plausible path toward a minimal Android 4.4 Tailscale client
• Converted grass balls into loose fiber stock (better drying, storage, and processing)
• Confirmed full sun drying produces the "green tea" aroma
• Extracted and concentrated grass pigment ("green blood")
• Determined grass extract is a pigment, not a glue
• Completed the floating display concept for the First Grass Ball
• Finished and placed the First Grass Ball artifact under its glass dome
• Successfully used grass pigment and garden dirt for scenic weathering
• Identified the likely causes of the blender failure (investigation pending)
• Built up a reserve of dried fiber stock for future experiments
• Officially promoted lawn clippings from waste to raw material inventory
• Got the domain working
• Got the Grove online
• Created the room structure
• Added the BBS page
• Created a restricted FTP user
• Verified the include-based IP system will work
• Proved the concept end-to-end