Return Stack

"Where you've been is where you can go back to."

What Is It?

Return Stack treats navigation history as a first-class continuation — a stack of saved positions you can manipulate like browser history or a call stack.

The Metaphor

| Programming | Browser | MOOLLM | |-------------|---------|--------| | Call stack | History | Return stack | | Return address | Back button | Previous room | | Stack frame | Tab | Room context | | Push | Navigate | ENTER | | Pop | Back | BACK |

Commands

| Command | Effect | |---------|--------| | ENTER room | Push current room, enter new one | | BACK | Pop stack, return to previous room | | FORWARD | Redo after BACK (if available) | | HISTORY | Show the stack | | BOOKMARK | Save current position | | GOTO bookmark | Jump to saved position | | STACK | Show all open "tabs" (parallel stacks) | | FORK | Create new tab from current position |

Example Session

> ENTER workshop
[Stack: lobby]

> ENTER storage
[Stack: lobby → workshop]

> ENTER archive
[Stack: lobby → workshop → storage]

> BACK
Returning to storage...
[Stack: lobby → workshop]

> BACK
Returning to workshop...
[Stack: lobby]

> HISTORY
  1. lobby (start)
  2. workshop
  3. storage
  4. archive ← furthest
  
Current: workshop (position 2)

Bookmarks

Save positions for later:

> BOOKMARK "interesting-spot"
Bookmarked: workshop as "interesting-spot"

> ENTER research
> ENTER data-room
> ENTER sub-analysis
[Deep in the hierarchy]

> GOTO interesting-spot
Returning to workshop...
[Stack cleared, at bookmark]

Forking (Tabs)

Create parallel exploration paths:

> FORK
Created new tab from workshop.
Tab 1: lobby → workshop
Tab 2: workshop (active) ←

> ENTER experiment-A
[Tab 2: workshop → experiment-A]

> STACK
Tab 1: lobby → workshop
Tab 2: workshop → experiment-A ←

> TAB 1
Switching to Tab 1...
[Now at workshop via tab 1]

As Continuation

The return stack IS a continuation:

# Stored in character's pocket
return_stack:
  - path: "./lobby"
    context: {examining: "welcome-sign"}
  - path: "./workshop" 
    context: {crafting: "blueprint-v2"}
  - path: "./storage"
    context: {searching: "rare-materials"}
    
# Current position
current: "./archive"
context: {reading: "old-records"}

When you BACK, you don't just return to the room — you restore the context you had there.

Portable Journey

The stack travels with you:

> INVENT
Inventory:
  - notebook
  - pen
  - return_stack: [lobby → workshop → storage]

You can:

Save your journey to a file
Share it with others
Replay someone else's exploration
Branch from any point in their journey

HyperCard Heritage

HyperCard had:

Stacks of cards
"Go back" button
Breadcrumb trail
Bookmarks

MOOLLM extends this:

Rooms as cards
BACK command
Return stack as data
Bookmarks as saved positions
FORK for parallel exploration

Implementation

# character.yml
name: explorer
location: ./archive

navigation:
  return_stack:
    - room: ./lobby
      entered: "2024-01-15T10:00:00"
    - room: ./workshop
      entered: "2024-01-15T10:05:00"
      context:
        active_task: "crafting"
    - room: ./storage
      entered: "2024-01-15T10:15:00"
      
  bookmarks:
    interesting-spot:
      room: ./workshop
      context: {task: "blueprint-review"}
    start:
      room: ./lobby
      
  forward_stack: []  # After BACK, stores where you came from

Dynamic Deoptimization

The Self programming language (source of our prototype inheritance) pioneered dynamic deoptimization: aggressively inlining code for performance, then reconstructing the "logical" call stack on demand when debugging.

The LLM does this naturally for narrative:

| Self | MOOLLM | |------|--------| | Inlined bytecode | Flattened conversation | | Deoptimized frames | Reconstructed causality | | Breakpoint trigger | "How did we get here?" | | Stack trace | Causal chain from evidence |

The stack isn't explicitly maintained, but it's recoverable.

How It Works

When you ask for history, the LLM examines:

evidence_sources:
  - session_log: "Append-only narrative trail"
  - room_state: "Accumulated changes"
  - character_location: "Current position"
  - file_timestamps: "Order of modifications"
  - chat_context: "Recent decisions"

And synthesizes a virtual stack trace:

Deduced navigation:
1. lobby (start)
2. workshop (examining blueprints)
3. storage (found locked chest)
4. workshop (returned for key) ← BACK
5. storage (unlocked chest)
6. archive (following map) ← current

This is introspection without instrumentation — the same insight that made Self's debugger magical.

Dovetails With

Action Queue — The complement: stack = past, queue = future
Room — What you're navigating between
Coherence Engine — Tracks navigation state
Adventure — Narrative exploration
Session Log — Records the journey
Prototype — Self language heritage
Debugging — Stack traces on demand

Protocol Symbols

RETURN-STACK      — Navigation history as data
BACK / FORWARD    — Stack manipulation
BOOKMARK / GOTO   — Saved positions
FORK              — Parallel exploration
HYPERCARD-HIERARCHY — The room/card model

See: PROTOCOLS.yml