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

return-stack

Safety Notice

Copy this and send it to your AI assistant to learn