Place

A place is a directory declared a space, marked by .place/ the way .git/ marks a repository. It is the WHERE of the platform, and the only semantic ontology laid over the substrate at the infrastructure level.

$ place init -n desk -d "a desk"
initialized place  desk  →  /home/you/desk

That is the whole of becoming one. Note what it did not do: it did not make a repository. A place is usually a Git repository as well, and everything below about pins and timelines assumes it, but the declaration and the repository are two separate acts.

The superrepo of a constellation

A place’s own tracked content is deliberately thin. At its root live three kinds of thing: installed entities, each a submodule; nested places, the same mechanism one level down, fractally; and loose objects — ordinary files with no semantic value at this altitude, tracked anyway so that a cloned place travels whole.

The place is the Git manager for what it holds. From inside it you install, enumerate and operate:

$ entity install /srv/git/acme.note.git
acme.note
$ place ls
acme.note	/srv/git/acme.note.git	80019cd59830ee70291f3d10a8036ff6960a3649

Installing takes any URL Git accepts — a path on this machine, or an address across the network, which is the same command with a different argument. Distribution is the substrate’s, and the place adds nothing to it.

Name, origin, and the commit this place holds it at. That last column is the pin, and it is not bookkeeping the place keeps on the side — it is a gitlink in the place’s own tree, mode 160000, which you can see in the index beside the ordinary files:

$ git ls-files -s
100644 bfa9a43… 0	.place/.gitignore
100644 0fc5fb4… 0	.place/place.yaml
160000 80019cd… 0	acme.note

Which is why the place’s tracked mass stays tiny while the constellation it holds can be enormous. We take Git’s submodule anatomy and decline its porcelain — git submodule has no model for a bare repository with many refs and worktrees standing at once — so the gitlink is written directly.

Installing always answers where, because the tree of places is the search path. Resolving a name walks upward, so choosing the place is a decision about reach rather than a detail of the act. You can watch the walk happen by accident: entity create run from a directory that is not a place anchors the entity in the nearest ancestor that is, and entity which will tell you which one it picked.

The control plane ignores itself. A place’s .place/ holds bare repositories, arming tables, and an act’s private area standing for as long as a body runs — all of which would otherwise read as untracked work in progress. So the directory is created ignoring the whole of itself but its declaration:

$ cat .place/.gitignore
*
!place.yaml
!.gitignore

Infrastructure that never travels must also never show up as a change.

Timelines — the WHEN of a space

A place’s branches are timelines. This is not a metaphor the primitive borrows; it is the cosmology it takes seriously — a thing exists in space and in time or it does not exist. Place and timeline together are one spacetime coordinate, of version time. The wall-clock moment at which something happened belongs to the event, never to the substrate.

The rich primitive takes the ontology’s word where the lean Entity keeps Git’s branch, and the difference runs deeper than vocabulary: a place’s branch always means time, while what an entity’s branch means is its application’s to say.

$ place timeline ls
 	experiment
*	master

What a timeline tracks is a configuration of the constellation: which entities are installed, pinned at which commits, plus the loose objects. Materialize a timeline and what stands there are those submodules at those pins — that configuration is what the place holds true at that timeline, which is why the pin is a declaration rather than a record.

$ place materialize
acme.note	/home/you/desk/acme.note	80019cd59830ee70291f3d10a8036ff6960a3649

Two properties follow, and neither is something we built. Timelines are cheap — forking one forks the configuration, never the entities’ mass, since object stores are shared by every timeline that references them. And several stand at once, materialized in parallel as worktrees, which is precisely what worktrees are for. One is the folder you walk into by default, privileged by convention and nothing else; the others are no less real. place timeline ls answers correctly from inside each.

The primitive reads the timeline; Git steers it

place timeline has one subcommand, ls. Creating a timeline is git branch and standing in one is git worktree — the primitive reads where you are rather than moving you there. Whether it should own those verbs at all, or leave time to the substrate that already keeps it, is open.

Note what travels and what does not. The pin lives in the place’s tracked tree, so it crosses to every timeline and every clone; the repositories the pins point at live under .place/, which the place ignores by design. A constellation therefore carries its configuration everywhere and its mass only where the object store is reachable — which is the same fact that makes forking a timeline cheap, read from the other side.

When the place advances a pin is not decided

A pin is a declaration of truth at the smallest scale we have: this place says this commit is what it holds true about that entity. Which makes the question of when it advances a policy rather than a mechanism, and it is open open.

Today it does not advance on its own. Commit twice through an entity installed in a place and place pin still reads the old sha while entity tip reads the new one — and git status on the place is clean, because the ignored control plane hides the drift.

Both horns are real. Record every mutation and the timeline stops being a landscape and becomes a transaction log of everything that ever happened anywhere inside it. Record deliberate snapshots and a cloned place silently materializes state the user has already left behind — which, under the declaration reading, is not an inconvenience but a false statement. Candidates: the owning application declares its own cadence, a reactor advances pins on a rule, or a snapshot becomes an explicit act with product meaning, the way a document is saved.

What a place is not

Not a folder. A folder is a place with WHO and WHEN amputated — space collapsed to containment, with no notion of who installed what, at which version, in which history.

Not a namespace or a registry. Nothing is looked up in it; things are anchored in it, and the anchoring is physical.

Not the interpreter of its contents. It knows an entity is here, where it came from and what commit it is held at. It has never read inside one.