Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
inventory:refs:-ref:pub/bar/brass-lantern.ymlacquired:"2026-01-23T10:00:00Z"condition:"good"note:"Found in the cellar"
Location as Pointer (Code as Space)
The pointer syntax is bidirectional. Not just "what you carry" — also "where you ARE."
Any object's location: field uses the same pointer syntax. This means characters, artifacts, and entities can exist inside any file type:
# Character standing on a TypeScript functionname:Alicelocation:src/lib/utils.ts#fetchDatanote:"Reviewing this function with the team"# Artifact placed at a specific line rangename:BugMarkerlocation:src/auth/login.ts:45-67note:"The authentication bug lives here"# Entity inside a JSON configname:ConfigWatcherlocation:package.json#/dependencies/sveltenote:"Monitoring version changes"
Code Review as Adventure
A hacking party can literally stand inside source code:
# The review partyparticipants:- { name:Alice, location:"src/api/handler.ts#processRequest" }
- { name:Bob, location:"src/api/handler.ts#validateInput" }
- { name:Carol, location:"src/api/handler.ts:89-95" } # The problematic linessession:topic:"Why does validation fail on unicode input?"room:"src/api/handler.ts"context:"Standing around the processRequest function"
What This Enables
Use Case
Location Pointer
Code review
Stand on functions, discuss them
Bug hunting
Place markers at suspicious lines
Pair programming
Multiple characters at same location
Architecture tours
Walk through a codebase as rooms
Documentation
Annotate code with character observations
The codebase becomes a dungeon. Files are rooms. Functions are objects. Line ranges are specific spots. Characters can go there, look around, leave notes, argue about what they see.
Pickup Modes
Two fundamentally different ways to pick something up:
TAKE REF — Lightweight Pointer
> TAKE REF TO brass-lantern
You now have a reference to the brass lantern. (weight: 0)
What happens:
Create pointer in your inventory
Object stays where it is
Object's location field updates: location: "characters/don/inventory"
You have zero weight added
Use when:
Just need access to it
Don't want to carry weight
Shared resource (dispenser, catalog)
Can't physically move it (too heavy)
TAKE OBJECT — Deep Copy
> TAKE OBJECT cookie
You pick up the cookie. (weight: 0.1)
What happens:
Copy entire object into your inventory
Your file gets bigger (embedded object)
Weight added to your load
Original MAY stay or be deleted (your choice)
Use when:
Small object, negligible weight
Want to OWN it completely
Need to modify it freely
Don't want inheritance chain
Picking Up Boxed Items
GOLDEN RULE: Once boxed, always boxed.
If something already has a file (is "boxed"), picking it up preserves everything:
# kitchen/acme-catalog-001.yml already exists with:# inherits: street/acme-catalog.yml# annotations: ["circled portable hole"]# dropped_by: palm# Don picks it up AS OBJECT:# File moves to: characters/don/acme-catalog-001.yml# All annotations preserved!# Don picks it up AS REF:# inventory: [ref: "kitchen/acme-catalog-001.yml"]# File stays in kitchen, Don just has pointer.
Drop Modes
Three fundamentally different ways to put something down:
DROP AS BOX — Create New File
> DROP brass-lantern AS BOX
Created: kitchen/brass-lantern-001.yml
What happens:
Create new YAML file at destination
New file inherits: from your ref's target
Adds boxed metadata (who, when, where)
You can KEEP your original ref (sharing) or consume it
Boxed item now has its own existence and local state
Boxing creates an instance:
# kitchen/brass-lantern-001.ymlobject:inherits:"pub/bar/brass-lantern.yml"# Instance metadatainstantiated_at:"2026-01-23T14:00:00Z"instantiated_by:"don"instantiated_from:"inventory"# Local state (can now diverge from prototype)condition:"slightly worn"inscribed:"Property of Don"
DROP AS BEAM — Move Actual File
> DROP brass-lantern AS BEAM
File moved to: garden/brass-lantern.yml
What happens:
Actual file relocates to destination
No inheritance created
All properties preserved (it's the same file)
You NO LONGER have it
Origin is now empty (file moved)
Use when:
Giving something away permanently
Moving heavy objects
Avoiding inheritance chains
The thing should BE here now
DROP INTO — Insert in Container List
> DROP cookie INTO treasure-chest
Cookie added to treasure-chest.yml contents list.
What happens:
Target file has a list (contents, items, inventory)
Your item inserted into that list
No new file created
Packed storage in existing file
Container file structure:
# treasure-chest.ymlobject:name:"Treasure Chest"contents:- { id:gold-coins, proto:economy/gold.yml, count:100 }
- { id:ruby, name:"Ruby", weight:0.5 }
-ref:magic-scroll.yml# ← your item inserted here
Boxing Protocol
Boxing (like Java boxing) — instantiating a pointer into a real file with identity.
When you have a lightweight pointer and DROP AS BOX, the reference gets boxed — instantiated into a YAML file that inherits from the pointer's target. Like Java's int → Integer, but here it's pointer → YAML file with identity.
The Journey of an Object
# THE JOURNEY OF A CATALOG:# 1. ORIGIN: street/acme-catalog.yml (prototype, dispenser)# 2. DON TAKES REF at street:don.inventory: [ref→street/acme-catalog.yml]
# (No file created yet, just pointer)# 3. DON DROPS AS BOX in kitchen:# Creates: kitchen/acme-catalog-001.yml# inherits: street/acme-catalog.yml# boxed_by: don, annotations: ["circled hole"]# Don's ref is consumed.# 4. PALM TAKES AS OBJECT from kitchen:# File moves: palm.inventory/acme-catalog-001.yml# All annotations preserved!# Kitchen is now empty.# 5. PALM DROPS AS BEAM in study:# File moves: study/acme-catalog-001.yml# Still has Don's annotations!# Palm no longer has it.# 6. BUMBLEWICK TAKES AS REF from study:bumblewick.inventory: [ref→study/acme-catalog-001.yml]
# File stays in study.# 7. BUMBLEWICK DROPS AS BOX in garden:# Creates: garden/acme-catalog-002.yml# inherits: study/acme-catalog-001.yml# boxed_by: bumblewick, annotations: ["added doodles"]# Now there are TWO catalogs:# - study/acme-catalog-001.yml (Don's original box)# - garden/acme-catalog-002.yml (Bumblewick's copy)# Full provenance chain preserved at every step!
Boxing Golden Rules
Once boxed, always boxed — Instances travel intact
Instances accumulate history — Each handler can add provenance
Inheritance chains — Instances can inherit from instances
Local state divergence — Instances can override their prototype
Transport Modes
For heavy objects you can't carry:
BEAM / TRANSPORTER
Use a reference as a targeting system:
> TAKE REF TO grand-piano
You have a reference to the grand piano. (weight: 0)
> GO concert-hall
You arrive at the concert hall.
> BEAM grand-piano HERE
*shimmer* Piano materialized!
concert-hall/grand-piano.yml created.
How it works:
Take lightweight REF to heavy object
Travel to destination (carrying only the pointer)
BEAM command uses ref as target
Object teleported/moved to your location
Ref consumed, you have actual object here
FORKLIFT Mode
Mechanical assistance for moving heavy objects:
> SUMMON FORKLIFT
Forklift arrives.
> LOAD bronze-statue ONTO forklift
Statue loaded.
> GO garden
You move to garden, forklift follows.
> UNLOAD bronze-statue AS BEAM
Statue placed in garden/bronze-statue.yml
Fungibles
Fungible items are identical and interchangeable. No individual tracking — just a count.
Counts can be fractional! 3.5 gold coins, 0.25 moolah, 2.7 kg of flour — why not?
The pointer syntax is a universal structural editing protocol for YAML and JSON. Same addressing, same operations, syntax-independent.
The Insight
If you can TAKE a subtree, you can PEEK at it.
If you can DROP a subtree, you can POKE it.
If you can move subtrees between files, you can edit structure.
Pointers are addresses. Addresses enable operations.
Operations
Operation
Command
Effect
PEEK
PEEK path#key.subkey
Read value at path
POKE
POKE path#key.subkey = value
Write value at path
SNIP
SNIP path#subtree
Extract subtree (leaves hole)
PULL
PULL path#subtree
Extract into inventory or new file
SPLICE
SPLICE value INTO path#list
Insert into list/array
APPEND
APPEND value TO path#list
Add to end of list
SET
SET path#key = value
Create or overwrite key
DELETE
DELETE path#key
Remove key entirely
CLEAR
CLEAR path#key
Set to null/empty
DUPLICATE
DUPLICATE path#subtree TO path2#newkey
Copy subtree
MOVE
MOVE path#subtree TO path2#newkey
Relocate subtree
Examples
# PEEK — read a value>PEEKconfig.yml#settings.timeout30# POKE — write a value >POKEconfig.yml#settings.timeout=60Done.# SNIP — extract and remove>SNIPcharacters.yml#npcs.henkHenkextractedtoinventory.(holeleftinnpcs)# PULL — extract to file>PULLcharacters.yml#npcs.henkTOhenk.ymlCreatedhenk.ymlwithHenk'sdata.# SPLICE — insert into list>SPLICE {name:"Cookie", weight:0.1} INTOchest.yml#contentsInsertedatposition0.# APPEND — add to end>APPEND"new item"TOinventory.yml#refsAddedtorefslist.# SET — create or overwrite>SETroom.yml#visited=trueSetvisitedtotrue.# DELETE — remove key>DELETEcharacter.yml#temp_dataRemovedtemp_data.# DUPLICATE — copy subtree>DUPLICATEtemplate.yml#npc_baseTOcharacters.yml#npcs.bobBobcreatedfromnpc_basetemplate.# MOVE — relocate subtree>MOVEold.yml#settingsTOnew.yml#configSettingsmovedfromold.ymltonew.yml#config.
Syntax Independence
These operations work identically on YAML and JSON:
Source
Target
Works?
YAML
YAML
✓
JSON
JSON
✓
YAML
JSON
✓ (auto-convert)
JSON
YAML
✓ (auto-convert)
The pointer addresses structure, not syntax. The underlying tree is the same whether serialized as YAML or JSON.
Nested Paths
# Deep addressing>PEEKgame.yml#characters.party.members[0].inventory.weapons[2]"Vorpal Sword"# Wildcards for bulk operations>DELETEconfig.yml#users.*.temp_tokensDeletedtemp_tokensfromallusers.# Conditional addressing>PEEKnpcs.yml#[?(@.faction=="rebels")]
[allNPCswherefactionis"rebels"]
Atomic Operations
For complex edits, use transactions:
# BEGIN/COMMIT for atomic multi-step edits>BEGINEDITgame.yml>SET#player.health = 100>APPEND"heal-potion"TO#player.inventory>DELETE#player.status.poisoned>COMMITAtomiceditapplied.# ROLLBACK on failure>BEGINEDITgame.yml>SET#player.gold = -500 # Invalid!>ROLLBACKEditcancelled.
Integration with Inventory
Structural editing IS inventory manipulation:
Inventory Action
Structural Equivalent
TAKE REF
PEEK (get address)
TAKE OBJECT
SNIP (extract copy)
DROP AS BOX
PULL to new file
DROP INTO
SPLICE/APPEND
BEAM
MOVE
Same protocol, different metaphors. Characters "pick up" and "drop" things. Editors "snip" and "splice" structure. Both are moving subtrees via pointers.
Commands
Command
Action
TAKE [item]
Pick up (default: smart mode)
TAKE REF TO [item]
Pick up as pointer
TAKE OBJECT [item]
Pick up as deep copy
DROP [item]
Put down (default: smart mode)
DROP [item] AS BOX
Create new file with inheritance
DROP [item] AS BEAM
Move actual file
DROP [item] INTO [container]
Insert into list
BEAM [item] TO [dest]
Teleport without carrying
INVENTORY
List carried items
CAPACITY
Show limits and usage
FUNGIFY [pile]
Convert to fungible stack
UNFUNGIFY [stack]
Convert to individual items
Smart Defaults
When you don't specify mode, the system chooses:
TAKE defaults:
Situation
Default Mode
From dispenser
REF (repeatable)
Boxed item
OBJECT (preserve annotations)
Heavy item
REF (can't carry)
Small unique item
OBJECT (don't leave behind)
DROP defaults:
Situation
Default Mode
Have reference
BOX (create instance)
Have object, giving away
BEAM (transfer)
Have object, sharing
BOX (keep original)
In your own space
BEAM (organizing)
Weight and Capacity
capacity:max_weight:45# Total carrying capacitymax_bulk:10# Volume limitrefs_free:true# References don't count!current:weight:12# Sum of objectsbulk:3refs:15# Unlimited pointers
Why refs are free: A reference is just a string — a path to something. It costs nothing to carry a path. The weight only comes when you carry the actual thing.
