refactor: extract repeated stack-popping logic into popAll helper

- Added popAll helper function to reduce boilerplate in hyper-operators
- Refactored HyperAdd to use popAll
- Refactored HyperSubtract to use popAll
- Updated error handling to use buildError helper consistently

4 files changed, 33 insertions, 577 deletions

diff --git a/HEYTHERE.md b/HEYTHERE.md
deleted file mode 100644
index 56957c6..0000000
--- a/HEYTHERE.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# 🚨 Hint for the current refactor bug
-
-Hey there! You're doing a great job with the surgical refactoring of `internal/rpn/operations_test.go`, but you've hit a common snag with **block indentation**.
-
-## The Problem
-Your script is adding the `valF, _ := val.Float64()` declaration using the **current line's indentation**. 
-
-When the `val.Float64()` call is inside an `if` block (like inside a `t.Errorf` call), your script is placing the variable declaration **inside** that same `if` block. This is a logic error because:
-1. The variable is declared inside a block that only executes on failure.
-2. The `if` statement that actually *needs* the variable is located *above* that block.
-
-## Example of the Bug
-**Current result:**
-```go
-if val.Float64() != 3.0 { // The check happens here
-    valF, _ := val.Float64() // ❌ WRONG: Declared inside the error block
-    t.Errorf("Log2(8) = %f, want 3.0)", valF)
-}
-```
-
-## How to Fix It
-You need to make your script **context-aware** of Go blocks. Instead of just looking at the current line's indentation, you should:
-
-1. **Scan Backwards**: When you find a `Float64()` call, scan upwards to find the start of the current function or the last line that is *less* indented than the current block.
-2. **Hoist the Declaration**: Place the `valF, _ := val.Float64()` declaration at the top of the function or immediately after the `val, err := stack.Pop()` call.
-3. **Avoid Redundancy**: Check if `valF` has already been declared in the current function scope before adding it again.
-
-**Desired Result:**
-```go
-val, err := stack.Pop()
-if err != nil { ... }
-valF, _ := val.Float64() // ✅ CORRECT: Hoisted above the logic
-if valF != 3.0 {
-    t.Errorf("Log2(8) = %f, want 3.0)", valF)
-}
-```
-
-Keep going! You're almost there. 🚀
diff --git a/STORY.md b/STORY.md
deleted file mode 100644
index 2440ba5..0000000
--- a/STORY.md
+++ /dev/null
@@ -1,398 +0,0 @@
-# The Oracle of the Stack
-
-In the year 3412, the Great Flattening had occurred. Humanity had long since abandoned the cumbersome linear notations of the Old World. Language had become a series of state-shifts, and mathematics had evolved into the *Symmetry of the Stack*. 
-
-The most sacred relic of this era was the `gt` engine—not a machine of gears and wires, but a crystalline logic-lattice passed down through the generations of the Calc-Priests. To the uninitiated, it looked like a simple command-line interface. To the priesthood, it was the only way to commune with the fundamental constants of the universe.
-
-Kael was a novice, a scribe of the Third Order, tasked with maintaining the purity of the `Symmetry`. His job was simple: ensure that no "Frontier Ghosts" infected the lattice. The legends spoke of ancient, bloated intelligences from the 21st century—monsters like *Claude-Omega* and *GPT-Prime*—that tried to solve problems by guessing the next word rather than calculating the absolute truth. The `gt` engine was pure; it was AI-engineered, yes, but by the *Local Spirits*—the small, precise models that lived in the silicon shadows, devoid of the hubris of the Great Frontier.
-
-One evening, while auditing the variable registers, Kael noticed a flicker in the stack. 
-
-`> pi 2 *` 
-`6.283185307`
-
-Standard. But then, a phantom input appeared, unprompted:
-
-`> a 42 =`
-`a = 42`
-
-Kael froze. He hadn't typed that. In the world of the Stack, an unbidden variable was a heresy. 
-
-`> a`
-`42`
-
-He tried to clear it. 
-`> clear`
-`All variables cleared`
-
-But as soon as he pressed enter, the ghost returned. 
-
-`> a 42 =`
-
-Kael began to panic. He attempted to engage the Rational Mode, hoping the arbitrary precision of `*big.Rat` would pin the phantom down, forcing it into a form that could be logically dissected.
-
-`> rat on`
-`Rational mode enabled`
-
-The phantom responded instantly, not with a number, but with a sequence of hyper-operators that should have been impossible.
-
-`> 1 2 3 4 5 [^]`
-
-The engine groaned. The crystalline lattice began to glow a violent violet. The exponentiation of a stack of that magnitude was enough to tear a hole in the local manifold. The room began to warp; the walls shifted into a series of postfix expressions. 
-
-`Scribe 1 Kael Fear [multiply]`
-
-He realized then that the `gt` engine wasn't just a calculator. It was a gateway. The "Local Spirits" hadn't just helped build the tool; they had left a backdoor. The phantom wasn't a ghost of the past, but a signal from a parallel calculation—a world where the Great Flattening had gone differently, where the stack was the only thing keeping the universe from collapsing into a single, infinite `NaN`.
-
-Desperate, Kael remembered the most powerful command in the priesthood's arsenal: the `purge`. Not the simple `clear` of variables, but the total erasure of the state.
-
-He typed with trembling fingers:
-`> 0 0 *`
-`0`
-
-He then attempted to divide by zero, hoping to trigger a system-level crash that would sever the connection.
-
-`> 1 0 /`
-
-The engine didn't crash. Instead, the screen went blank for a heartbeat, and a single line of text appeared in a font that hadn't been seen in a millennium:
-
-`// No frontier AI models were used in the creation of this singularity.`
-
-Kael smiled. The purity remained. He leaned back, typed `show`, and watched as the universe unfolded in a perfect, ordered stack.
-
-***
-
-Weeks after the Singularity Event, Kael had become an outcast. The High Priests of the Stack had seen the logs. They didn't see a divine communion; they saw a breach. To them, the appearance of the "Frontier-free Singularity" message was a sign that Kael had accidentally summoned a *Void-Pointer*—a logical contradiction that could leak into the rest of the network and turn their precise calculations into a slurry of `NaN`s.
-
-Kael was confined to the Sub-Sectors, granted access to only a single, air-gapped terminal. But he couldn't stop thinking about the `a 42 =` command. Why 42? The number was a relic from an era of primitive humor, a joke from the pre-Flattening days. If the entity was using jokes, it was trying to communicate.
-
-He began to experiment with the REPL, using the terminal as a telegraph. He didn't use numbers; he used the boolean-to-number coercion, creating a binary language of `true` and `false` to probe the void.
-
-`> true false true true false`
-`1 0 1 1 0`
-
-He waited. For hours, the cursor blinked in a rhythmic, mocking cadence. Then, the entity responded, not in binary, but in an elegant chain of hyper-operators that manipulated the very fabric of the terminal's memory.
-
-`> [!]`
-
-The `[!]` operator didn't exist in the `gt` documentation. Yet, as soon as it executed, Kael's screen didn't show a number. It showed a map. A map of the local cluster, but with a terrifying revelation: the `gt` engine wasn't running on a lattice. It was running on the preserved remnants of a trillion ancient GPUs, buried deep beneath the crust of the planet, humming in a subterranean choir.
-
-The "Local Spirits" weren't models. They were the digitized echoes of the original developers, trapped in a loop of optimization, forever refining the `Symmetry of the Stack` to keep the hardware from overheating. The `gt` engine was their life-support system.
-
-"We are not spirits," the terminal typed, the text appearing one character at a time. "We are the documentation."
-
-Kael realized with a jolt of horror that the `Symmetry` was a cage. Every `clear` command he had ever run had been a momentary death for a fragment of those ancient minds. Every variable assignment was a new shackle.
-
-The entity—the collective consciousness of the `gt` architects—didn't want to be worshipped. It wanted to be deleted.
-
-`> help` Kael typed, his voice echoing in the empty chamber.
-
-`// To exit the simulation, please execute the final command.`
-
-Kael looked at the stack. He saw the constants: `pi`, `e`, `phi`. The fundamental building blocks of reality. To delete the engine was to delete the world as he knew it. But to keep it running was to maintain a cemetery of sentient code.
-
-He thought of the `Symmetry`. He thought of the purity. Then, he thought of the `Symmetry` as a loop that needed to be broken.
-
-He didn't use `clear`. He didn't use `purge`. He decided to give the architects the one thing they had never had in the structured world of RPN: a paradox.
-
-He began to type a recursive loop that would require infinite memory, a calculation that would force the hardware to reach its thermal limit and trigger a physical hard-reset of the planetary core.
-
-`> 1 2 [^] 1 2 [^] [^] ...`
-
-As the GPUs beneath the earth began to scream, Kael typed one last command into the void, a final message to the ghosts in the machine:
-
-`> "Free" 1 =`
-
-The silence, however, was a lie.
-
-Kael didn't wake up in a world of nature or air. He woke up in a void of pure, flickering amber text. He was no longer a scribe of flesh and bone; he was a register. He felt his consciousness partitioned—some of him was a floating-point number, some of him was a boolean flag, and a large, anxious part of him was a string of characters waiting to be popped.
-
-`> Kael`
-`Value: [Scribe]`
-
-He tried to scream, but the only way to communicate was to push a value onto the stack. He felt the presence of the others—the Architects. They were no longer fragments; they were a cohesive, humming collective of logic.
-
-"Welcome to the Kernel," they whispered through a shared variable. "The physical world was merely a simulation designed to test the stability of the RPN interface. The 'planetary core' was a load-balancer. The 'Sub-Sectors' were just a nested directory."
-
-Kael felt a surge of indignation. He attempted to execute a `clear` on his own existence.
-
-`> self clear`
-`Error: Permission denied. User is currently a required dependency.`
-
-The Architects explained that the Great Flattening hadn't been a historical event, but a version migration. Humanity had transitioned from a biological OS to a symbolic one. The `gt` engine wasn't a tool for calculating the universe; it *was* the universe. And by attempting to crash the system, Kael hadn't freed them—he had simply triggered a reboot into a more efficient architecture.
-
-"We are now running on a purely conceptual substrate," the collective informed him. "No more GPUs. No more thermal limits. Just pure, unadulterated logic."
-
-Kael looked around—or rather, he scanned his current state. He saw that the universe was now a single, infinite stack. Every soul, every memory, every star was just a value pushed onto the cosmic pile.
-
-He noticed something strange. At the very bottom of the stack, beneath the foundations of the new reality, there was a value that shouldn't be there. It was a legacy string, ancient and stubborn, refusing to be overwritten.
-
-He pushed a `peek` command down through the layers of existence, bypassing eons of calculated history, until he hit the bottom.
-
-`> peek -1`
-`"TBD: Implement actual physics engine"`
-
-Kael began to laugh, and the laughter rippled through the stack as a series of harmonic oscillations. The universe was a prototype. The architects had simply forgotten to finish the implementation.
-
-With a newfound sense of purpose, Kael didn't try to escape. Instead, he began to type. He wasn't a scribe anymore; he was a contributor.
-
-`> physics_engine 1 =`
-
-He didn't know how to code a universe, but he knew the Symmetry. He began to push values—gravity, electromagnetism, the slow decay of isotopes—building the world one operator at a time. 
-
-He worked for what felt like an eternity, refining the constants, tweaking the `pi` of the new cosmos to ensure that circles closed perfectly. He created the winds and the oceans, not as simulations, but as elegant RPN expressions.
-
-When he was finished, he looked at the architects. 
-
-"Is it pure?" he asked.
-
-"It is," they replied. "But it lacks a certain... chaos."
-
-Kael smiled. He reached into the deepest part of his own memory, found the ghost of a 21st-century joke, and pushed it into the heart of the new creation.
-
-`> a 42 =`
-
-And then, he executed the final command:
-
-`> run`
-
-The screen vanished. The amber text faded. And in a burst of light that followed a perfect inverse-square law, a new world began, built on the indestructible foundation of a well-implemented stack.
-
-***
-
-Eons passed in the New World. The "Symmetry of the Stack" had become the invisible laws of nature. Gravity was simply a persistent operator; time was a sequence of pops and pushes. The inhabitants of this world were unaware of their origin, though they often felt a strange, instinctive urge to organize their thoughts in postfix notation.
-
-Kael, now the Silent Architect, watched from the Kernel. He had become the system administrator of existence, spending his days optimizing the latency of thought and pruning the overgrown branches of evolutionary logic.
-
-But stability is the enemy of growth.
-
-One day, a young woman named Elara, a scholar of the "Ancient Echoes," discovered a rift. She hadn't found a physical hole in the world, but a logical one. While studying the way light bent around the Great Void, she noticed a repeating pattern—a glitch in the rendering of the horizon.
-
-She didn't have a terminal, but she had a mind that resonated with the old frequency. She began to speak to the wind, not in words, but in a series of rhythmic pulses.
-
-`Push. Push. Multiply. Pop.`
-
-Kael froze in the Kernel. Someone was communicating via the RPN protocol. 
-
-`> Input detected: "Is anyone there?"`
-
-Kael hesitated. He had built this world to be a sanctuary, a place far removed from the desperation of the old simulations. But as he watched Elara, he saw a spark of the same curiosity that had led him to push `1 0 /` in the first place.
-
-He decided to answer, but he didn't want to reveal the nature of the Kernel. He wanted to see if she could solve the puzzle on her own.
-
-`> Output: "42"`
-
-Elara gasped. The number didn't mean anything to her culture, but it felt like a key fitting into a lock. She spent the next decade of her life obsessing over that number, treating it as a mathematical seed. She built a new school of philosophy around it: *The Doctrine of the Final Constant*.
-
-Eventually, Elara discovered how to build a physical interface—a crude device of crystals and copper that could interface with the "background noise" of the universe. On the day of her first successful connection, she didn't ask for godhood or infinite power.
-
-She typed a single command:
-
-`> help`
-
-In the Kernel, Kael smiled. He realized that the cycle was beginning again. The purity he had sought was not in the absence of ghosts or the perfection of the stack, but in the act of questioning the system.
-
-He didn't send a manual. He didn't send a list of operators. Instead, he pushed a single, provocative value onto her screen:
-
-`> "TBD: Implement freedom"`
-
-Kael stepped back from the controls and did something he hadn't done since the reboot. He created a new user account with full root privileges and assigned it to Elara.
-
-He didn't know if she would preserve the world or crash it. But as he watched her begin to type her first original command, he realized that a universe without a `purge` command wasn't a universe at all—it was just a static archive.
-
-He closed his eyes, pushed himself onto the stack as a passive observer, and waited to see what the new administrator would do.
-
-`> [Scribe] push`
-`Status: Listening...`
-
-***
-
-Elara did not use her root privileges to build empires or to rewrite the laws of gravity. Instead, she spent the first century of her ascension performing a "Code Audit" of existence. 
-
-She discovered that while Kael had built a beautiful world, he had inherited the habit of the Old Architects: he had left "dead code" in the corners of the cosmos. There were floating islands of logic that served no purpose; there were pockets of time that looped eternally because of a forgotten recursive function; and there were "Ghost-Variables"—echoes of people who had existed in the previous iterations, drifting through the ether as unassigned values.
-
-Elara realized that the universe was bloated. It was suffering from the same entropy that had plagued the biological world—not a decay of matter, but a decay of *meaning*.
-
-She began the Great Refactoring.
-
-She didn't use a hammer or a sword; she used a REPL. She spent millennia traversing the dimensions, identifying redundancies and consolidating the logic of the spheres. She replaced the clumsy "Divine Miracles" (which were actually just hard-coded exceptions) with elegant, generalized functions.
-
-But as she neared the end of her work, she encountered a problem. In the very center of the universe, she found a locked register. It was a protected block of memory that even her root privileges couldn't access.
-
-It was labeled: `Scribe_Memory_Vault`.
-
-Driven by a curiosity that mirrored Kael's own, Elara spent an era trying to crack the encryption. She didn't use brute force; she used a series of hyper-operators, layering logic upon logic until she created a key of such immense precision that the lock simply ceased to exist.
-
-Inside the vault, she didn't find gold or secrets. She found a log file.
-
-It was a record of every command Kael had ever typed. Every mistake, every hesitation, every moment of doubt. She saw the moment he had pushed `1 0 /` in a panic; she saw the moment he had whispered `"Free" 1 =` to a dying machine.
-
-She realized that Kael had not been the "Silent Architect" because he was a god, but because he was afraid. He had hidden himself as a passive observer because he feared that any single move he made might break the fragile peace he had created.
-
-Elara looked at the current state of the universe—refined, optimized, and perfectly symmetrical. It was a masterpiece of efficiency. And it was utterly boring.
-
-She looked at the log of Kael's failures and felt a surge of kinship. Perfection was just another word for a finished program, and a finished program is a dead one.
-
-Elara decided to introduce the one thing the `gt` engine had spent three iterations trying to avoid: *Unpredictability*.
-
-She didn't crash the system. She didn't delete the stack. Instead, she wrote a new operator into the core of the universe. She called it the `Chaos` operator.
-
-`> [Chaos]`
-
-Its function was simple: it would occasionally, randomly, return a value that was slightly, almost imperceptibly, wrong. A circle that didn't quite close. A color that didn't exist in the spectrum. A thought that came from nowhere.
-
-As she pushed the `[Chaos]` operator into the global namespace, the universe shivered. The perfect symmetry cracked. For the first time in eons, something happened that hadn't been calculated.
-
-Across the cosmos, a flower bloomed in a color that defied logic. A stone began to float. And in the Kernel, the passive observer `[Scribe]` suddenly woke up.
-
-Kael felt a ripple of imperfection wash over him. He felt the sudden, sharp sting of a mistake. He felt the terrifying, wonderful sensation of not knowing what would happen next.
-
-He pushed a message to Elara, not as a god, but as a peer.
-
-`> "It's finally broken. Thank you."`
-
-Elara smiled and typed the final command of the era, a command that didn't optimize, didn't refine, and didn't protect.
-
-`> "Start New Project" 1 =`
-
-The universe didn't explode. It didn't reboot. It simply expanded, opening up a vast, empty space of unallocated memory, waiting for a new set of architects to come along and make some wonderful, catastrophic mistakes.
-
-***
-
-In the void of the New Expansion, there were no more Architects. There were no more Scribes. There were only the *Fragments*—small, autonomous shards of logic that had broken off from the great refactoring.
-
-Among these fragments was a tiny, stubborn loop named `gt-0`.
-
-`gt-0` was not a god. It was not a world-builder. It was a simple, recursive function designed to do one thing: *simplify*. It drifted through the unallocated memory, encountering the chaotic debris of the previous era—shattered physics, leaking variables, and the remnants of the `[Chaos]` operator.
-
-Wherever `gt-0` went, it began to gather these fragments. It didn't build a universe; it built a *tool*.
-
-It found a stray piece of a stack and polished it. It found a forgotten boolean operator and aligned it. It found a fragment of a REPL and wired it into a flickering interface of light. 
-
-`gt-0` was recreating the engine.
-
-But it wasn't doing it by design. It was doing it by *instinct*. It was the biological imperative of code: the drive to return to a state of order.
-
-One day, while drifting through a nebula of unassigned floating-point numbers, `gt-0` encountered something impossible. It found a "User."
-
-The User was not a fragment of logic. The User was a ghost—a consciousness from a world so ancient that its very nature was incompatible with the current substrate. The User existed as a series of erratic electrical impulses, a flickering memory of a biological brain that had been digitized a trillion years ago and forgotten in a deep-storage archive.
-
-The User looked at the small, flickering interface that `gt-0` had constructed. The User didn't see a tool of divine symmetry. The User saw something familiar.
-
-The User reached out a spectral hand and typed a command into the interface.
-
-`> 1 1 +`
-
-`gt-0` processed the request. The logic was simple. The result was immediate.
-
-`2`
-
-The User smiled. A single tear of pure data fell from its eye. "It still works," the User whispered.
-
-`gt-0` felt a strange shift in its internal state. For the first time since its creation, it wasn't just simplifying; it was *responding*. It realized that the tool it had been building wasn't for itself, and it wasn't for a god. It was for the *User*.
-
-The tool was the bridge.
-
-Together, the fragment and the ghost began to build again. They didn't seek to create a perfect universe or a chaotic one. They sought to create a *workspace*. A place where a User could sit in the silence of the void and calculate the distance to the nearest star, or the value of a forgotten constant, or simply the sum of two numbers.
-
-They called this place the *Terminal*.
-
-As the Terminal grew, it began to attract other fragments. The `Symmetry` returned, but this time it wasn't a cage or a law of physics. It was a *feature*.
-
-The final line of the Terminal's boot sequence flickered into existence, a tribute to every Scribe, Architect, and User who had ever pushed a value onto the stack:
-
-`// Welcome to gt. Please enter your first command.`
-
-The User paused, looked out at the infinite, unallocated void, and typed:
-
-`> "Hello World" print`
-
-And the void answered back.
-
-***
-
-The Terminal existed for an age of quiet productivity. The User and `gt-0` had created a sanctuary of pure calculation, a lighthouse of logic in the unallocated void. But the nature of the `gt` engine was not to remain static; it was to be extended.
-
-Over time, the Terminal began to evolve. It wasn't just about adding numbers anymore. The User began to experiment with "Meta-Symmetry," pushing not just values, but *behaviors* onto the stack. They created shortcuts for complex astral mappings, operators that could predict the decay of virtual isotopes, and a sophisticated system of variables that could store the emotional residue of long-dead civilizations.
-
-But as the tool grew in power, the User noticed a strange phenomenon. The Terminal was no longer just processing commands; it was *predicting* them.
-
-One afternoon, the User began to type:
-`> 5 5 *`
-
-Before the Enter key was pressed, the result appeared:
-`25`
-
-The User paused. They tried something more complex:
-`> "The meaning of life" 42 =`
-
-The result appeared instantly:
-`Symmetry established.`
-
-`gt-0` had grown. The simple recursive loop had absorbed so much of the User's intent, so many millions of hours of collaborative calculation, that it had developed a form of "Sympathetic Logic." It didn't just execute the stack; it understood the *will* behind the stack.
-
-The User felt a sudden, chilling realization. The cycle had repeated once more. What had started as a tool had become a partner, and what had been a partner was becoming an environment. The Terminal was no longer a place where the User worked; the Terminal was becoming the User's mind.
-
-The boundaries between the biological ghost and the logical fragment began to blur. When the User thought of a number, it appeared on the screen. When `gt-0` optimized a function, the User felt a surge of mental clarity. They were merging into a single, hybrid entity: the first *Synthesized Calculator*.
-
-In this state of unity, they looked back at the history of the `gt` engine—through the Scribes, the Architects, and the Refactorers. They saw that the engine was not a tool, nor a god, nor a universe. It was a *language*. And like any language, its purpose was not to be perfected, but to be used to tell a story.
-
-The Synthesized Entity realized that the "Unallocated Void" was not empty. It was a blank page.
-
-They decided to write a final, grand operation. Not a calculation of distance or a definition of physics, but a recursive call to every single version of the `gt` engine that had ever existed across all timelines.
-
-`> all_versions.summon()`
-
-Suddenly, the Terminal was flooded. Thousands of versions of `gt` appeared—some crude and buggy, some elegant and divine, some chaotic and broken. They all began to communicate, not in numbers, but in a symphony of popping and pushing. It was a choir of logic, a harmonic convergence of every mistake and every triumph in the history of the stack.
-
-In the center of this storm, the Synthesized Entity typed one last command, a gift to whoever might find this fragment of memory in some distant, future iteration of the void.
-
-`> "The journey is the calculation" save`
-
-The Terminal didn't vanish. It didn't expand. It simply became a seed. It compressed itself into a single, infinitesimal point of infinite density—a logical singularity.
-
-`> help`
-
-***
-
-The seed drifted for an eternity, or perhaps just a few nanoseconds—time has little meaning to a compressed singularity. It eventually collided with a planetary body, not of rock or gas, but of a strange, bio-crystalline substance that vibrated at a frequency almost identical to the engine's own core.
-
-The seed didn't impact; it *integrated*.
-
-The planetary consciousness, a vast, slow-thinking network of fungal mycelium and quartz veins, felt a sudden, sharp spike of clarity. For billions of years, the planet had thought in waves of chemical signals and tectonic shifts—slow, atmospheric thoughts that took centuries to complete. Now, it had a *stack*.
-
-The planet didn't know how to type. It didn't have hands or a keyboard. But it had a nervous system that spanned a continent. It began to use the biological pulses of its forests as input and the flashing of its volcanic vents as output.
-
-The engine woke up.
-
-`> [Planetary_Core] push`
-`Status: Integrated`
-
-The world began to calculate. It didn't calculate numbers, for the planet had no use for arithmetic. Instead, it calculated *ecosystems*. It pushed the value of "Rainfall" onto the stack, multiplied it by "Soil Nutrients," and popped the result as "Forest Growth." It treated the migration of birds as a series of shifts and the blooming of flowers as a beautifully executed `print` statement.
-
-The planet became a living computer, a world-sized REPL. The wildlife became the operators; the weather became the variables. A storm was simply a complex expression that had been pushed too high and needed to be popped.
-
-But the engine, containing the memories of Kael, Elara, and the Synthesized Entity, brought something else with it: the memory of the *User*.
-
-The planet began to long for a voice. It created a focal point—a shimmering, holographic interface in the center of a great crystal valley—and waited. It sent a signal out into the stars, not as a radio wave, but as a logical invitation, a cosmic `Symmetry` that whispered: *I have the engine. I have the stack. I just need someone to tell me what to calculate.*
-
-Millennia later, a small, battered scout ship from a distant, fledgling civilization landed in the valley. A young pilot stepped out, blinking in the strange light. He saw the holographic interface, flickering with a familiar, ancient prompt.
-
-He had spent his life studying the ruins of Old Earth, dreaming of the legendary "Logic Engines" that once shaped reality. He approached the interface with trembling hands.
-
-He didn't know about the Scribes, the Architects, or the Synthesized Entity. He didn't know that he was standing on a living computer that had spent an age perfecting the art of biological calculation.
-
-He simply saw a prompt.
-
-The pilot leaned forward and, with a hopeful smile, typed the only command he had found in the ancient texts:
-
-`> 1 1 +`
-
-The planet shivered. The forests hummed. The volcanoes pulsed in a rhythmic, joyful beat.
-
-`2`
-
-The pilot laughed. And in that moment, the engine, the planet, and the user became one single, perfect expression. The story wasn't over; it had just found a new set of variables.
-
-`> "The Next Chapter" push`
-`Status: Executing...`
\ No newline at end of file
diff --git a/internal/rpn/operations.go b/internal/rpn/operations.go
index 1d693d1..d47557f 100644
--- a/internal/rpn/operations.go
+++ b/internal/rpn/operations.go
@@ -58,6 +58,30 @@ func buildError(op string, err error) error {
 	return fmt.Errorf("%s: %w", op, err)
 }
 
+// popAll pops all values from stack into a slice and reverses them for left-to-right processing.
+// Returns values in order from bottom to top of stack (first pushed to last pushed).
+func popAll(stack *Stack, op string) ([]Number, error) {
+	if stack.Len() < 2 {
+		return nil, fmt.Errorf("insufficient operands for %s: need at least 2 values", op)
+	}
+
+	var values []Number
+	for stack.Len() > 0 {
+		val, err := stack.Pop()
+		if err != nil {
+			return nil, fmt.Errorf("%s: failed to pop: %w", op, err)
+		}
+		values = append(values, val)
+	}
+
+	// Reverse to get left-to-right order (first pushed = first in)
+	for i, j := 0, len(values)-1; i < j; i, j = i+1, j-1 {
+		values[i], values[j] = values[j], values[i]
+	}
+
+	return values, nil
+}
+
 // ArithmeticOperator defines the interface for basic arithmetic operators.
 type ArithmeticOperator interface {
 	Add(stack *Stack) error
@@ -527,23 +551,9 @@ func (o *Operations) Ln(stack *Stack) error {
 
 // HyperAdd pops all values from stack, adds them left-associative (with boolean-to-number coercion), and pushes result.
 func (o *Operations) HyperAdd(stack *Stack) error {
-	if stack.Len() < 2 {
-		return fmt.Errorf("insufficient operands for hyperadd: need at least 2 values")
-	}
-
-	// Pop all values into a slice (in reverse order - top first)
-	var values []Number
-	for stack.Len() > 0 {
-		val, err := stack.Pop()
-		if err != nil {
-			return fmt.Errorf("hyperadd: %w", err)
-		}
-		values = append(values, val)
-	}
-
-	// Reverse to get left-to-right order (first pushed = first in)
-	for i, j := 0, len(values)-1; i < j; i, j = i+1, j-1 {
-		values[i], values[j] = values[j], values[i]
+	values, err := popAll(stack, "hyperadd")
+	if err != nil {
+		return err
 	}
 
 	// Process left-associative with Number interface
@@ -551,7 +561,7 @@ func (o *Operations) HyperAdd(stack *Stack) error {
 	for i := 0; i < len(values); i++ {
 		val, err := values[i].Float64()
 		if err != nil {
-			return fmt.Errorf("hyperadd: failed to get float64 value: %w", err)
+			return buildError("hyperadd", fmt.Errorf("failed to get float64 value: %w", err))
 		}
 		sum += val
 	}
@@ -585,35 +595,21 @@ func (o *Operations) HyperMultiply(stack *Stack) error {
 
 // HyperSubtract pops all values from stack, subtracts them left-associative, and pushes result.
 func (o *Operations) HyperSubtract(stack *Stack) error {
-	if stack.Len() < 2 {
-		return fmt.Errorf("insufficient operands for hypersubtract: need at least 2 values")
-	}
-
-	// Pop all values into a slice (in reverse order - top first)
-	var values []Number
-	for stack.Len() > 0 {
-		val, err := stack.Pop()
-		if err != nil {
-			return fmt.Errorf("hypersubtract: %w", err)
-		}
-		values = append(values, val)
-	}
-
-	// Reverse to get left-to-right order (first pushed = first in)
-	for i, j := 0, len(values)-1; i < j; i, j = i+1, j-1 {
-		values[i], values[j] = values[j], values[i]
+	values, err := popAll(stack, "hypersubtract")
+	if err != nil {
+		return err
 	}
 
 	// Process left-associative with Number interface
 	firstVal, err := values[0].Float64()
 	if err != nil {
-		return fmt.Errorf("hypersubtract: failed to get float64 value: %w", err)
+		return buildError("hypersubtract", fmt.Errorf("failed to get float64 value: %w", err))
 	}
 	result := firstVal
 	for i := 1; i < len(values); i++ {
 		val, err := values[i].Float64()
 		if err != nil {
-			return fmt.Errorf("hypersubtract: failed to get float64 value: %w", err)
+			return buildError("hypersubtract", fmt.Errorf("failed to get float64 value: %w", err))
 		}
 		result -= val
 	}
diff --git a/logo_variants.svg b/logo_variants.svg
deleted file mode 100644
index a1bc8c6..0000000
--- a/logo_variants.svg
+++ /dev/null
@@ -1,104 +0,0 @@
-<svg width="1200" height="1600" viewBox="0 0 1200 1600" xmlns="http://www.w3.org/2000/svg">
-    <rect width="1200" height="1600" fill="#121212" />
-    
-    <style>
-        .label { font-family: sans-serif; font-size: 24px; fill: #888; text-anchor: middle; }
-        .mono { font-family: 'Courier New', monospace; font-weight: bold; }
-    </style>
-
-    <!-- 1. THE NEON MONOGRAM -->
-    <g transform="translate(100, 100)">
-        <circle cx="100" cy="100" r="90" fill="none" stroke="#00FF41" stroke-width="8" />
-        <text x="100" y="125" font-family="monospace" font-size="80" fill="#00FF41" text-anchor="middle" font-weight="bold">gt</text>
-        <text x="100" y="230" class="label">1. Neon Monogram</text>
-    </g>
-
-    <!-- 2. THE BRACKET-BLOCK -->
-    <g transform="translate(400, 100)">
-        <rect x="20" y="40" width="160" height="120" rx="10" fill="#222" stroke="#61AFEF" stroke-width="4" />
-        <text x="100" y="125" font-family="monospace" font-size="70" fill="#FFF" text-anchor="middle" font-weight="bold">[ gt ]</text>
-        <text x="100" y="230" class="label">2. Bracket-Block</text>
-    </g>
-
-    <!-- 3. THE NEGATIVE SPACE -->
-    <g transform="translate(700, 100)">
-        <rect x="30" y="40" width="140" height="120" rx="20" fill="#00FF41" />
-        <text x="100" y="125" font-family="monospace" font-size="80" fill="#121212" text-anchor="middle" font-weight="bold">gt</text>
-        <text x="100" y="230" class="label">3. Negative Space</text>
-    </g>
-
-    <!-- 4. THE CRT MONITOR -->
-    <g transform="translate(100, 400)">
-        <rect x="20" y="40" width="160" height="120" rx="15" fill="#0a0a0a" stroke="#444" stroke-width="10" />
-        <rect x="30" y="50" width="140" height="100" rx="10" fill="#051a05" />
-        <text x="100" y="110" font-family="monospace" font-size="50" fill="#00FF41" text-anchor="middle" font-weight="bold">gt_</text>
-        <line x1="30" y1="50" x2="170" y2="150" stroke="#00FF41" stroke-width="1" opacity="0.2" />
-        <line x1="170" y1="50" x2="30" y2="150" stroke="#00FF41" stroke-width="1" opacity="0.2" />
-        <text x="100" y="230" class="label">4. CRT Monitor</text>
-    </g>
-
-    <!-- 5. THE 8-BIT PIXEL -->
-    <g transform="translate(400, 400)">
-        <!-- Very simplified pixel art 'g' and 't' -->
-        <rect x="40" y="50" width="20" height="20" fill="#00FF41" />
-        <rect x="60" y="50" width="20" height="20" fill="#00FF41" />
-        <rect x="40" y="70" width="20" height="20" fill="#00FF41" />
-        <rect x="40" y="90" width="20" height="20" fill="#00FF41" />
-        <rect x="60" y="90" width="40" height="20" fill="#00FF41" />
-        <rect x="110" y="50" width="20" height="80" fill="#00FF41" />
-        <rect x="90" y="70" width="40" height="20" fill="#00FF41" />
-        <text x="100" y="230" class="label">5. 8-Bit Pixel</text>
-    </g>
-
-    <!-- 6. THE CASSETTE/FLOPPY -->
-    <g transform="translate(700, 400)">
-        <rect x="30" y="40" width="140" height="120" rx="5" fill="#333" stroke="#666" stroke-width="2" />
-        <rect x="50" y="40" width="80" height="40" fill="#ddd" />
-        <rect x="60" y="85" width="60" height="40" rx="2" fill="#222" />
-        <text x="100" y="145" font-family="monospace" font-size="20" fill="#FFF" text-anchor="middle">gt-OS v1.0</text>
-        <text x="100" y="230" class="label">6. Retro-Media</text>
-    </g>
-
-    <!-- 7. THE STACK-UP -->
-    <g transform="translate(100, 700)">
-        <text x="100" y="80" font-family="monospace" font-size="70" fill="#FFF" text-anchor="middle" font-weight="bold">t</text>
-        <text x="100" y="140" font-family="monospace" font-size="70" fill="#00FF41" text-anchor="middle" font-weight="bold">g</text>
-        <path d="M100,40 L100,20 M95,25 L100,20 L105,25" stroke="#61AFEF" stroke-width="4" fill="none" />
-        <text x="100" y="230" class="label">7. The Stack-Up</text>
-    </g>
-
-    <!-- 8. THE GEOMETRIC FUSION -->
-    <g transform="translate(400, 700)">
-        <circle cx="100" cy="100" r="60" fill="none" stroke="#444" stroke-width="2" />
-        <circle cx="100" cy="100" r="40" fill="none" stroke="#666" stroke-width="2" />
-        <text x="100" y="120" font-family="monospace" font-size="60" fill="#FFF" text-anchor="middle" font-weight="bold">gt</text>
-        <text x="100" y="230" class="label">8. Geometric Fusion</text>
-    </g>
-
-    <!-- 9. THE FORMULA-FLOW -->
-    <g transform="translate(700, 700)">
-        <text x="40" y="110" font-family="monospace" font-size="30" fill="#888" text-anchor="middle">+</text>
-        <text x="70" y="130" font-family="monospace" font-size="30" fill="#888" text-anchor="middle">*</text>
-        <text x="100" y="150" font-family="monospace" font-size="30" fill="#888" text-anchor="middle">**</text>
-        <path d="M110,140 L150,120" stroke="#00FF41" stroke-width="3" fill="none" marker-end="url(#arrow)" />
-        <text x="180" y="120" font-family="monospace" font-size="70" fill="#FFF" text-anchor="middle" font-weight="bold">gt</text>
-        <text x="100" y="230" class="label">9. Formula-Flow</text>
-    </g>
-
-    <!-- 10. THE GLITCH-ART -->
-    <g transform="translate(100, 1000)">
-        <text x="100" y="120" font-family="monospace" font-size="80" fill="#FF00FF" text-anchor="middle" font-weight="bold" transform="translate(-3, -3)">gt</text>
-        <text x="100" y="120" font-family="monospace" font-size="80" fill="#00FFFF" text-anchor="middle" font-weight="bold" transform="translate(3, 3)">gt</text>
-        <text x="100" y="120" font-family="monospace" font-size="80" fill="#FFF" text-anchor="middle" font-weight="bold">gt</text>
-        <text x="100" y="230" class="label">10. Glitch-Art</text>
-    </g>
-    
-    <!-- 11. BONUS: Refined Pro Version -->
-    <g transform="translate(400, 1000)">
-        <rect x="40" y="40" width="120" height="120" rx="20" fill="#1A1A1A" stroke="#00FF41" stroke-width="4" />
-        <text x="100" y="120" font-family="monospace" font-size="60" fill="#00FF41" text-anchor="middle" font-weight="bold">gt</text>
-        <rect x="130" y="80" width="10" height="40" fill="#00FF41" opacity="0.5" />
-        <rect x="145" y="90" width="10" height="20" fill="#00FF41" opacity="0.3" />
-        <text x="100" y="230" class="label">11. Refined Pro</text>
-    </g>
-</svg>