artifactory

Files (4)

• CARD.yml
• GLANCE.yml
• README.md
• SKILL.md

SKILL.md (first lines)

# Artifactory 🏭

> **The Engine of Creation. It builds, edits, and destroys — including itself.**

An **artifactory** is an artifact factory: a general-purpose constructor that reads, writes,
edits, destroys, and persists artifacts — text, directories, characters, skills, graphics — across
the **filesystem** and **git**. It is both **abstract** (an operator, like `lambda`) and
**concrete** (a thing in the world, like *Ubik*). It is **class and instance** at once: a
description of how to build, and a built thing that builds.

> [!TIP]
> This is the operational engine other skills call. `play-learn-lift` decides *what* to make;
> the artifactory *makes it, versions it, and can unmake it.*

## Why it exists

Most tooling splits creation, editing, and deletion into unrelated commands. The artifactory
treats them as **one composable operation set over a persistent, versioned store**:

- **Tokens in, artifacts out.** Reading consumes tokens; writing generates them. The artifactory
  is where LLM work becomes **durable, inspectable, versioned** objects.
- **Persistence is first-class.** State lives in files and git — the tape outlives the run.
- **Self-reproduction with a governor.** It builds shows, skills, and characters that build more
  — but it knows when to stop (the anti-*Autofac* clause below).

## The axis of eval

The deepest idea: an artifact sits on the **instructions ↔ data ↔ graphics** axis, and the
artifactory moves it along that axis.

| Facet | The artifact is… | Example |
|-------|------------------|---------|
| **Instructions** | a spec to execute | `yaml jazz` read as a construction plan |
| **Data** | inert content to store/query/transform | the same yaml as records |
| **Graphics** | a rendered view | markup facades, diagrams, images |

It is **homoiconic**: one pass's output is the next pass's program. This is `eval`/`apply` for the
filesystem — a skill is a `lambda`, `INSTANTIATE` is application, and construction is evaluation.

## Operations

Creation, editing, and destruction are the same engine at different signs.

| Method | Does | Notes / gate |
|--------|------|--------------|
| **CREATE** | Build a new artifact from a spec | Stamp provenance |
| **READ** | Load & sniff an existing artifact | Understand before changing (the inspector) |
| **EDIT** | Patch / monkey-patch / upgrade / refactor in place | *Ubik* maintenance: debug, patch, reboot |
| **DESTROY** | Remove an artifact — reversibly | git is the undo; **human approval** for destructive ops |
| **PERSIST** | State ⇄ filesystem ⇄ git | append-only logs; the tape survives |
| **INSTANTIATE** | Clone a prototype into an instance | class → instance; clone, don't build from scratch |
| **TIMELINE** | commit / branch / merge / PR / issue / discussion | audit trail; **never force/merge to main** without approval |
| **COMPOSE** | Chain with other skills | the substrate skills build on |

### Git as the construction timeline

The artifactory doesn't just write files — it writes **history**. Branch to try a construction,
merge when it works, open a PR to propose one, file an issue to request one, use discussions to
deliberate. **Branch timelines are experiments; merges are decisions; PRs are proposals.** Every
artifact arrives with a commit that says *why*.

### Git is time flowing over a static universe (no, literally)

The filesystem tree is a **static snapshot of a universe-state** at one instant — in MOOLLM, the
actual universe: rooms, characters, objects, journals, rules. A **commit** freezes that entire tree,
content-addressed by hash, immutable forever. **Git** is the **directed acyclic graph** of those
snapshots — a **trans-dimensional** representation of time laid over otherwise timeless static file
trees. Not a line: a **branching, merging, many-worlds graph**. Branches are parallel timelines;
merges reconcile them; `checkout` teleports you to any instant in that space-time.

The artifactory is the **transition rule** that runs on this. It **reads** the representation of the
universe (snapshot *N*), applies **CREATE / EDIT / DESTROY**, and **writes** the next universe
(snapshot *N+1*); git records the trajectory. So the claim "**it runs the creation simulation on the
representation of the universe**" is not poetry — it's a plain description of the mechanics. **No
shit, it actually does.**

| Simulation / cosmology | Git + filesystem mechanism |
|------------------------|----------------------------|
| a world / universe-state | the working tree (a directory + file snapshot) |
| a frozen instant | a **commit** → tree object, content-addressed |
| **time** | the **commit DAG** (branching, merging) |
| parallel timelines (many-worlds) | **branches** |
| reconciling timelines | **merges** |
| teleport to an instant | **checkout** |
| the **rule** that evolves state | the **artifactory** (CREATE/EDIT/DESTROY) |
| the space-time record of the run | **git history** |

### Many-worlds, precisely — and that's *why this works*

The many-worlds framing is not a loose metaphor; it **precisely describes git in its full glory**.
Everett's interpretation is a **branching tree of self-consistent histories** — no collapse, every
possibility a real world. Git is that structure made of content-addressed snapshots:

| Everett / many-worlds | Git |
|-----------------------|-----|
| an entire world-state | a **commit** (immutable, content-addressed) |
| branching into parallel worlds | `git branch` / any divergent commit |
| the world you currently observe | **HEAD** |
| decoherent, non-interacting histories | independent branches |
| the record of every world you've been in | the **reflog** (worlds are never truly lost) |
| an alternate history | `rebase` / rewritten lineage (the old world still exists) |

Git even has **one superpower physics doesn't**: in standard many-worlds, branched worlds never
recombine — but **`merge` reconciles divergent timelines** into one. Git is many-worlds *plus a
join operator*.

Put plainly: **git is a parallel-universe timeline editor** — `checkout` picks which world you
stand in, `branch` spawns one, `merge` rejoins two, the reflog means none is ever lost. It inverts
PKD's *"Faith of Our Fathers"* (where the drug enforces a *single* consensus reality and the hidden
truth is plural): with git the plurality is the *reality*, editable and safe, not a horror to be
hidden. Most people use git daily without noticing they're operating a many-worlds machine — so
naming it this way is a small **calm-technology** win: *you already live in parallel timelines;
here is the editor* — a powerful, learnable, industry-standard tool made visible instead of drugged
and hidden.

**This precision is exactly why the artifactory works.** Because git faithfully realizes a
branching space of immutable, recoverable worlds, the engine can **run the creation simulation
across many candidate worlds at once** — try a construction in one branch, a different one in
another, keep what survives, and **never destroy a world** (it's still in the reflog). Speculative,

From SimHacker/moollm, MIT.

More from SimHacker/moollm