ByteTerrace/Puck / .claude/skills/puck-world
puck-world
VerifiedMaps Puck.World: .puck worlds, rules, grants, console verbs, extensions, the live MCP World. Use to run or verify a World change (stdin script, stale binary, headless run) or debug a refusal.
references/adjacency-and-federation.md
View on GitHub# Adjacency and federation
Adjacency is authored ownership topology. It makes two world regions continuous
without adding portal furniture, co-locating their authorities, or allowing two
writers for one body. Federation is the authenticated transport used when the
neighbour is not hosted in the same process. Consumers depend on authority
identity and capabilities, never on that hosting distinction.
## Authoring contract
An invisible boundary needs three document rows:
1. `references` names the neighbouring world document.
2. A global, persisted `destinations` row names that reference.
3. An `adjacencies` row names the destination, the neighbour's reciprocal row,
and a rectangular boundary (`center`, outward yaw/pitch, width, height).
`WorldAdjacencyUnavailable.Closed` is the only failure treatment today, and it
covers every terminal outcome, not just an unresolvable destination row: an
unreachable neighbour, a full border, a refused admission, a refused leave, a
commit abort, and a reservation the destination no longer has all clear the
body's pending continuum, press `onUnavailable` once, and name the refusal on
stderr. At a yaw-only boundary the body is also clamped one raw fixed-point unit
inside it, which makes the refusal terminal: the sweep answers `Crossed` for a
body already beyond the threshold. At a pitched boundary (a floor or ceiling)
the body is NOT clamped — it keeps pose and velocity and goes on under the local
authority, because a clamp pins a falling body in mid-air at the plane — so
there a refusal repeats every tick the body stays beyond the threshold. Only
a capacity refusal under `full: retry` re-queues, bounded by a retry ceiling
carried on the transfer. `onUnavailable` may name a declared channel for authored
sound, animation, state, or other feedback; safety never depends on the binding.
An adjacency row may author `capacity` — the same border policy portal furniture
carries, echoed with the unavailable treatment by `world.adjacencies`. Portals
remain intentional authored travel and are not used to represent seamless
topology.
Past the seam, a body that crossed is the destination's seat. The destination's
rules read its input with `channel(1, name)` exactly as they read a seat that
booted there.
**What crosses is the identity projection and nothing else.** A traveler's
`WorldIdentityProjection` (id, name, color, the two rates, the records
`identity.records` selects, and the facts row) is the only identity a crossing
carries, on every path: reservation and commit (`WorldTransferReservationMember.Identity`
and `WorldTransferCommitMember.Profile` are projections), a commit retried after a
source restart, and a colocated crossing. `WorldIdentityProjectionWire` is its one
wire form, shared by the federation codec, the crossing log, the arrival tape and
the checkpoint's escrow, in-doubt and body rows. Bindings, the HUD panel, the
seat look and every other owned row never leave home. The destination lands
`WorldIdentity.FromProjection` (`WorldTransferEscrow.ArrivingProfile`); a field a
destination needs is added to the projection, never read off a document.
A destination writes a visitor's facts and records on that travelling copy:
`WorldOwnedWorlds.TrySetFact` keeps a visitor's fact on its travelling row, and
`TrySave` refuses by name an identity the catalog does not own, so no destination
writes a visitor to disk. A local seat coming home (a colocated arrival at the
seat whose `Mobility.Incarnation` this authority minted, carrying an id its
catalog owns; an id alone is not enough, since catalogs seed identities from
their templates) rebinds to its owned identity, which adopts the carried facts
and records and nothing else (`WorldOwnedWorlds.TryAdopt`), after all landings succeed and the arrival
record is durable. A rolled-back arrival changes no owned identity. An empty projected facts row
preserves the owner's authored name and capacity before its first write. Remote round trips do
not adopt: a federation reservation has no admission field, so it is always a peer admission and
can never claim a local seat, since a remote incarnation claim is unauthenticated. A crossing
whose source restarts restores its logged departure's facts and records before live writes
resume. A transfer already in the checkpoint uses that checkpoint's catalog. An abort reseats
and saves the current owned identity, preserving both the departing facts and later owner
writes while recovery waits. A replay's re-driven home arrival binds the projection its taped outcome records the live adoption bound, in a detached identity, and saves nothing.
Foreign-written
facts are unsigned until provenance attestation for carried state exists. The
[rulepush package](../../../../experimental/worlds/rulepush/README.md) relies on this: a level
hears the visitor's presses, a win writes an identity fact onto the travelling
record, and the overworld adopts it when the visitor walks home and opens a gate
from it. Its `rulepush-overworld` canary is the end-to-end check, and
`CrossingIdentityPrivacyLawTests` pins every path.
A shard names one document several times over — its own `basis`, each adjacency
neighbour, each derived corner destination — and a composed document is reused
per resolved path when every file its composition read still holds the bytes it
read (`WorldDefinitionFileSource`; identity is the path, freshness is content,
no clock takes part in either). `world.adjacencies` names `composed=shared` or
`composed=fresh` per started neighbour authority, and `unknown` when that
authority is not running here. The process totals sit on `world.status`
(`documents composed N shared M held K (B bytes)`) and on the boot's own
`[world.documents]` line, since they belong to the process rather than to one
instance's rows; the two counts are the `world.boot` work source's
`world.boot.compositions` and `world.boot.compositions-shared`. A neighbour's
resolved document is held against the composed image it was parsed from
(`WorldFileNeighbourResolver`), so a border proved again — a boot's admission
and then its completion — parses that neighbour once. `held` is one image per distinct document path this process
composed; the store is not capped, so `B` is what to read when a host composes
unusually many documents.
A row may also author `livenessGraceSeconds`: how long that edge may go without
a delivered neighbour refresh before the world calls the link dropped. `0` (the
default) disables sensing for the row entirely — no event, and `$link:` reads 0
— so a world authoring none is unchanged. Compiled per document through
`WorldDefinition.AdjacencyLivenessGraceTicks`, the
`bodies.reconnectGraceSeconds` idiom; validated `0..600`. This is what the
`linkEstablished`/`linkDropped` world event family and the `$link:<name>` rule
channel threshold against, and `world.links` is its read-back — one line per
authored row naming the destination, the neighbour authority, the tick-derived
staleness and grace, and (clearly marked presentation-only, never a simulation
input) the transport lane's wall-clock backoff state.
One traversal mints one crossing. The adjacency scan skips a seat already named
by a queued or in-flight transfer (announced once per transfer id on stderr),
because the sweep keeps answering `Crossed` while the traveler waits for its own
transfer to drain.
`WorldDefinitionValidator.ValidateAdjacencies` proves the pair before boot. It
requires stable destinations, reciprocal counterpart names and dimensions,
world-up-preserving frame pairs, and a derivable overlap envelope. At a corner,
two direct neighbours may imply one diagonal observation peer only when both
paths name the same document; validation also proves the transform diamond
closes. Authors declare topology and physical envelopes, not safety margins.
`WorldAdjacencyPolicy.TryDeriveOverlap` derives a symmetric overlap from both
worlds' body reach, interaction/target reach, closing-speed ceilings, and two
periods of the slower simulation rate, rounding outward in fixed point. Those
five inputs are `WorldOverlapTerms`, and the overload taking them derives the
same depth from a neighbour that never handed over its document.
`WorldFrameIsometry` is the one point/vector/orientation mapping used by
crossing, contact, transfer, and presentation. `MapArrival` is the one arrival
function portal furniture and invisible borders share: it anchors on the two
frames' own origins, so an off-centre crossing lands at its counterpart point by
the isometry rather than by a seam carried beside the traveler, and it adds one
wrapped yaw delta to the traveler's own unbounded accumulator.
An `IWorldNeighbourResolver` may answer `Resolved` (the whole document),
`Attested` (a `WorldCounterpartAttestation` — the neighbour's seam edges plus
its overlap terms, composed but not necessarily verified: `WorldStorageNeighbourResolver`
produces this arm today from an unsigned fetched copy), `VerifiedAttested` (the
same attestation shape, reached through `WorldCounterpartAttestationProtocol.TryVerify`,
which verifies a signed claim against the reading world's own `admission` keys
and returns both what it attests and the verified chain's own subject — a
resolver must still bind that subject to the neighbour key it was resolving
before trusting the result: `WorldApiCounterpartResolver` (`Puck.World.Azure`)
provides the extension resolver for an owner-named `WorldReference`, and refuses
unless the verified subject parses as the same `Guid` as the reference's own
`Owner`), or `Unavailable`. Both attested arms prove the same four per-fact
refusals the document arm does for an ordinary two-document adjacency: missing
reverse edge, non-reciprocal counterpart, mismatched extents, and a frame pair
that loses world up. A derived corner is proven the same way as an ordinary
adjacency — each of the three documents involved (the two direct neighbours and
the shared corner) proves only its own edges — but the corner walk accepts only
`Resolved` or `VerifiedAttested`: a plain `Attested` neighbour names a claim
about a third authority that nothing has verified, so it never enters a corner
proof. What a verified diamond proves is authenticated consistency of the
signed statements within a signed validity window, not real-world truth and not
equality to any document the reader never saw.
The five quilt documents (quarantined under
`experimental/src/Puck.World/Assets/worlds/shards/`) are the worked stress
example: four coloured ground worlds meet at one corner and `quilt-island` is
vertically adjacent to all four. No live world authors an adjacency; the debug
world reaches the garden through a portal instead.
## Runtime ownership and handoff
Every active body has exactly one authoritative writer. Crossing an adjacency
uses the same reserve-then-commit escrow for local-process and federated
destinations. Reservations bind capacity until commit, explicit abort, or an
exact tick-denominated deadline. A stable mobility identity binds the origin
`WorldEntityAddress` incarnation and a monotonically advancing ownership epoch;
reserve atomically leases that incarnation and expected epoch to one transfer,
and commit compare-and-sets it to the next epoch exactly once. Ambiguous status
uses an exact committed outcome, never a scalar inference from later transfer
IDs. Acknowledgement retires that outcome; a later epoch for the same traveler
may supersede a lost acknowledgement. The one current credential per mobility
identity rejects delayed replay. These tables are bounded by active
transactions/travelers, not lifetime crossing count. `WorldTransferLimits` additionally
caps leases at 120 seconds, retained transactions (reserved, committed and uncertain)
at 16,384, and mobility admission aliases at 65,536. Reservations hold room for the
aliases their commits can add. Exhaustion refuses new work without discarding replay
protection: acknowledgement, lease expiry/abort and traveler retirement recover room.
The source's reservation reads the traveler's credential and never mints it
(`WorldPopulation.ReadMobility`, a pure read: the stored credential of the
occupant's generation, else the one its authority, index and generation
derive). Only the departure's detach mints it (`EnsureMobility` in
`WorldServer.DetachForTransfer`), which a replay's re-drive runs too, because
the authoritative hash folds a body's credential every recorded tick and the
tape records no reservation. A refused and retried reservation, an abort
before the detach, an in-doubt restore and a reused body slot each replay tick
for tick (`CrossingTapeOrderLawTests`).
A queued transfer that means one traveller names it by that incarnation, never
by its slot: transfers drained ahead of it can move the traveller on, refill
the slot, or stop and restart the instance it stood in. An incarnation is
unique across instance lifetimes: a name `WorldInstanceHost.TryStart` starts
again takes a lifetime-qualified authority identity (`row-a~1`, past every
identity a row admitted there held), so a body the new lifetime seats at the
same slot and generation never carries the incarnation a traveller from the old
one still does. Every queued transfer pins the lifetime that queued it
(`PendingTransfer.Source`) and its members' incarnations as queued
(`Travellers`); the drain refuses by name a transfer whose lifetime stopped or
whose slot now holds another body or none. `body.pose spawn:<id>` carrying a
seat home (`WorldInstanceHost.TryEnqueuePoseHome`) reads the incarnation from
the route's generation-addressed entity, and the drain finds the traveller
wherever it then stands, refusing when no body or more than one carries it.
Transfer ids are minted per source lifetime in enqueue order, but a follow or a
non-atomic party's split mints and applies a newer id ahead of older queued
ones, so duplicates are checked against the lifetime's drained ids
(`WorldDrainedTransferIds`: a dense watermark that passes an id only once it
drained, plus the drained ids above it), never a high-water mark. An emptied
instance a queued transfer is bound for is not reaped until the drain after
which nothing queued names it (`QueuedTransferInterleavingLawTests` enumerates
these interleavings; `PoseHomeTransferLawTests`). A commit member's `WorldTransferArrival`
says how it lands: `Spawn` (the destination's own spawn), `Mapped` (pose and
motion carried, so the destination must declare its motion program) or `Posed`
(standing at the pose on the destination's own program).
An exact committed retry includes action-continuity collection order and every
register value, not just profile and motion. Escrow retains detached
continuity values at commit and checkpoint restore; mutating a caller's original
lists cannot rewrite the accepted receipt. Independently allocated equal values
remain idempotent; altered names, register kinds, values,
or timers refuse as a different commit.
Failed source restoration on non-commit retains rollback-only recovery and never retries Commit.
Non-atomic parties split before any parent reservation. Full details and limits:
[Server transfer-recovery contract](../../../../src/Puck.World.Server/README.md#transfer-recovery-and-forwarding).
Host restore preflights every in-doubt and forwarding record before installing that host slice.
It preserves unresolved peer addresses and source-boundary completion data across
repeated restarts. A later local admission resolves by exact authority identity;
a same-named unrelated authority cannot resolve the transaction. Remote recovery
reconnects to the retained endpoint with the expected authority identity. On
confirmed commit, forwarding and local seat routes reconstruct the credential
from the retained member's incarnation and next ownership epoch, not a fresh
connection's empty reservation cache or a later occupant's slot-keyed entry.
`CommitConfirmed` remains checkpointed while source-side publication is pending.
Neither status nor commit is reissued in that phase, and rollback is forbidden.
Retain frozen source histories and the captured followed-seat masks until every
route/roster publication succeeds; partial publication must not vacate an already
moved participant. Invalid phases or overlapping seat masks refuse before host
restore writes. Publication failures are named `PUBLICATION-PENDING` once per run.
Finalized forwarding routes persist independently of in-doubt transactions. Preserve
their source namespace and mobility credential; never reconstruct the namespace from
the new process's machine ID. Missing local destinations remain checkpointed and bind
on exact-identity admission. Remote routes retain endpoint/definition seeds and
reconnect lazily through QUIC. Empty authorities with outgoing routes are not reaped.
Explicit destination stop unbinds incoming routes; later admission can rebind them.
Replacing a local arm releases its held-input lease and forbids further publication.
Federated input queues packets in order on both sides of the stream. The receiver
admits their timed batches once, then republishes only accepted held levels;
relative displacement is consumed once and several packets in one interval sum
before motion. Sender queues have a 1,024-packet ceiling; receiver queues also
respect the world's per-step event allowance. Overflow records a capture reset,
and disconnect cancels rather than manufacturing a scoring release. The accepted
hold and pending packets share one bounded checkpoint/replay leaf and the input
hash. Socket lease ids stay local. A validated captured federation continuation
resumes its body across restore; other remote humans retain ordinary parking.
New attachments cancel the restored episode before accepting fresh input.
Traveler observations use `ObserveTraveler` over the original authenticated QUIC
entry, not the final route's endpoint label. Local destinations need no listener.
Each hop validates its own source-scoped credential and reduces the shared 64-hop
budget; document disclosure cannot exceed any hop's arrival tier at stream opening.
The final owner uses the traveler's body-relative disclosure and Observe grant.
Its ownership, document, or grant change invalidates the stream for reopening.
Client lease disposal cancels observation; EOF detaches the server sink even paused.
A committed route can forward later input and submissions through further
handoffs, so an old credential remains a route to the one current writer
rather than a stale body slot. Generation recycle creates a different mobility
identity and cannot inherit the old credential.
Local arms validate their source-scoped credential before following an onward
route, exactly as QUIC ingress does. Never hold one authority gate across that
call. Local synchronous traversal has a 64-hop stack-safety bound. Accepted leave
retires every retained branch for the incarnation in each traversed host, including
branches left by revisiting the final authority; other incarnations remain intact.
### Durable crossings
The handoff token is the source-scoped `WorldTransferKey` (source authority,
transfer id), fenced three ways: the traveler's ownership epoch (a reservation
for an epoch the destination already consumed is refused as stale), the
destination's lease deadline (a commit after it is refused), and the
destination's crossing-log activation (a commit whose arrival record the log
refuses lands nothing). An exact replay of a committed token answers committed,
including from a destination rebuilt from its checkpoint and log; a different
commit under the same token is refused.
An authority with an installed `IWorldCrossingLog`
(`WorldServer.InstallCrossingLog`) writes every crossing step a peer can see
ahead of the step: the source's `Departure` (its complete in-doubt record)
before the commit, the destination's `Arrival` (reservation, body indices,
commit) before the commit's answer, and the source's `Settlement` (arrived with
its forwarding routes, or stayed) before the acknowledgement or the cohort's
restore. `IWorldCrossingLog.Append` answers a `WorldCrossingAppend` now or
later (`Durable`, `Refused`, `Uncertain`); after an `Uncertain` record the server
latches `WorldServer.UncertainCrossing` and refuses every later record until a
recovered activation replaces it. A source record that is not `Durable` refuses
its step; a pending settlement narrates `SETTLEMENT-PENDING` once and retries
each drain. An answer that comes later leaves one record in flight
(`WorldCrossingStep`): the door (`WorldServer.RecordCrossingHeld`) answers
`Pending`, sends nothing else, refuses checkpoints until the record settles at a
tick boundary (`SettleCrossingIfAnswered`), and the waiting step resumes there;
reservations, commits and hop grants go through `DecideCrossingAsync`. A
destination's speculative landing is undone with
`WorldPopulation.RestoreGeneration` before its arrival record goes out. Records share one
dense per-authority sequence (`WorldTransferEscrow.CrossingSequence`), captured
by every checkpoint as its watermark. Recovery is
`WorldInstanceHost.RecoverCrossings(row, entries)` after `Admit` and
`RestoreRow`: each record past the watermark is redone in order — an arrival
lands again through `WorldTransferEscrow.TryReland` (under the lease a restored
checkpoint still holds, or the one the record bound, restored at its recorded
body indices, without writing the record twice), a departure detaches its
cohort by incarnation and puts the transfer back in doubt, a settlement
publishes the routes or restores the cohort — and the next drain reconciles
the rest. A failed arrival redo refuses recovery and leaves its sequence
unapplied. A silo row's log is its authority journal
(`WorldAuthorityJournalEntryKind.Crossing` entries appended under the
activation fence; activation redoes them and mutations in publication order
after restoring the row). Checkpoint coverage is pinned at capture, so a later
arrival remains in the journal suffix. A desktop
process installs none. The record codec
(`WorldAuthorityCheckpointCodec.EncodeCrossingEntry`/`TryDecodeCrossingEntry`)
reuses the checkpoint's own escrow and in-doubt leaves.
A failed mutation journal append blocks the activation's later publications,
so no crossing commits against a document edit recovery cannot reproduce.
An `Uncertain` arrival record lands nothing and is neither a refusal nor a
commit. The commit door (`WorldServer.CommitTransferAsync`, `IWorldPeerCall.Commit`,
the federation commit reply) answers a `WorldTransferStatus`: `Committed`,
`Missing` for a refusal, or `Uncertain`. The escrow keeps the uncertain arrival
(`WorldTransferEscrow.Uncertain.cs`), answers `Uncertain` to the status query
and to a retried commit, and refuses any reservation for its travelers; the
destination narrates `UNCERTAIN` on `world.transfer`. The source keeps an
`Uncertain` answer in doubt exactly like an `Unreachable` one, so it neither
settles home nor completes. Only the destination's recovery resolves it: the
recovered log either lands the arrival again (`Committed`) or does not hold it
(`Missing`). Retiring a row (`WorldInstanceHost.TryRetire`) unbinds in-doubt transfers addressed
to the stopped row so they bind by authority to its recovered successor. In a
silo, `RowCrossingLog` maps a store `RecoveryRequired` (a root CAS it could not
reconcile) to `Uncertain`, which also blocks the activation; a store throw is a
refusal, since the store reconciles its own commit point. Laws:
`CrossingUncertaintyLawTests` (each crash point, with red legs replaying the
refusal) and `WorldSiloCrossingRecoveryLawTests`.
### Companion custody records
An owned traveller's title, custody and epoch (the
[custody protocol](../../../../docs/plans/companion-redesign.md)) are a fold of
its authorities' custody records: `Hop`, `HopDone`, `HopAcked`, `Recall`,
`Noticed`, `Release`, `Retire`, `Stranded` and `GraceElapsed` in
`WorldCrossingRecord`, plus an `Arrival` whose `Readopted` list brings a title
home. `WorldServer.RecordCustody` appends one record per call through the same
crossing log and folds it into `WorldTransferEscrow.Custody`
(`WorldCompanionCustody`) only once it is durable; an uncertain one latches
the authority (`WorldServer.IsUncertainAbout(key)`) and folds only on recovery.
The one reducer, `WorldCompanionCustody.Apply`, is what the escrow checkpoint
restores (it carries the folded history), what `RecoverCrossings` redoes, and
what a tape's `WorldReplayEntry.Custody` re-drives; the history folds into the
authoritative hash (`WorldStateHashComponent.Custody`). Home holds titles only
for incarnations it minted (`TitleOf` answers `null` otherwise); a release
installed while a hop is pending keeps the title pending until that hop's
`HopDone`. `Settlement` names its landed and retired member ids; every other
member is restored. `WorldServer.ApplyCustodyRecord` is the one fold door (live,
recovery and re-drive) and carries out a `Retire` on the body. Laws:
`CompanionCustodyLawTests` (engine forms of the model's named traces, recovery
cuts, and a tick-for-tick replay with its red leg) and
`CompanionCustodyRefinementLawTests`, which follows real peer calls and appends
with enabled model moves and compares derived custody at drains and restarts.
Those rows are retained and use local player seats; they do not prove automatic
reaping or remote-player forwarding. `CompanionCrossingLawTests.Adversarial.cs`
covers the ordinary home lifetime, rollback retention, contradictory destination
answers, cross-home confirmation contamination and a partial remote-player hop.
Persisted reservations carry the authority-local `World` principal explicitly;
it remains forbidden as an incoming wire actor (checkpoint 28, tape 12).
### Companions in a crossing
A placement's `inhabit.role` and `inhabit.follows` (a local seat) make its one
body a companion; a document's `roles` section declares what it takes
(`accept` a visitor's pinned driver, or a `driver` of its own; the standard
package's `companions.puck` declares `accept`). The source host adds the
companions that follow a crossing's travelers to its cohort
(`WorldInstanceHost.Companions.cs`): at home those whose placement follows the
crossing seat while the title is home, abroad those whose arrival bound them
to the crossing member's slot and generation. Every member carries a
request-local `MemberId`; a companion carries `WorldTransferCompanion` (role,
followed member id, home, driver, ticket). Before the reservation the source
asks the title authority for each hop: home records one `Hop` for its own
companions (`WorldServer.AuthorizeOwnHopAsync`), a custodian asks home through
`IWorldCustodyPeer.RequestHopAsync`; only a granted companion carries a ticket.
`WorldServer.ReserveTransferAsync` and `CommitTransferAsync` ask home asynchronously,
once per call, whether each companion's grant is current
(`IWorldCustodyPeer.ConfirmHopsAsync`, resolved by `WorldServer.CustodyPeers`), so an
answer never outlives the decision it was asked for; a latched home confirms
nothing. The escrow decides companions member by member (`Role`, `Duplicate`,
`Full`, `Unverified` in `WorldTransferReservationReply.Refusals`, the leased
ids in `AcceptedMembers`), lands them through the entity door, and leaves out
at the commit a companion whose grant is no longer current or whose landing is
refused; the arrival record and its tape entry name only what landed, with
each member's generation. The source reads the landed ids
(`IWorldPeerCall.TryLanded`; the federation status leaf carries them), settles
per member, restores the rest, and the drain settles home's own hops from its
own departure and settlement records (`OwedOwnHopSettlements`). A custodian's
hop settles by the destination's word: after each drain the custodian sends
home a notice for every companion its settled allocation minted
(`OwedHopNotices`, until a `HopAcked`), and home asks the hop's destination
(`IWorldCustodyPeer.QueryCustody`, served only to the incarnation's minting
authority, answered from the arrival the destination folded, its commit, lease
or uncertainty, or a tombstone written first) and records `HopDone` from that
answer alone. A notice for a hop home never recorded cancels it. A granted
onward hop the crossing did not depart with is given up the same way when the
crossing ends. A home with a pending or away title, or any source with an
in-doubt departure, stays reachable even with an empty population; owed notices
and settlements also prevent reaping. An operator's stop (`WorldInstanceHost.Stop`,
`world.instance.stop`) reads the same custody guard (`CustodyHeldBy`, which also
counts accepted arrivals not yet landed). An accepted stop is written into the
row's image through `DurableImages` (the host slice's `Stopping`), so a restart
resumes it. Each drain it sends home every visiting companion, and it retires only
when `WorldServer.TryFreezeForRetirement` finds, under the same hold of the
authority gate that closes admission, no visitor and no live lease. The final image
then carries whatever is still abroad or in doubt; a refused final write keeps the
row frozen and retries. A stop is refused while a visitor's home is no running row
here. A host without durable images (the World process) also refuses to stop a home
with a title abroad and waits while a row owes drain steps. Reaping never takes a
stopping row. A frozen row stays admitted (the silo uploads its image before
removing it), so the drain's custody passes, in-doubt reconciliation, custody peers
and destination resolution skip frozen rows. `TryRetire` is the unguarded
removal for a row whose durable image already carries it (the silo after its
final checkpoint), a failed activation, or a crashed authority a restart replaces;
it drops the departures that activation queued. Laws: `CompanionStopLawTests`. A rollback retains only members it has
not restored, in a restore-only row; a later durable home release ends that
obligation before any image is restored. Once commit was confirmed, a contradictory
Missing answer cannot authorize restoration. A partial settlement must persist
the landed members' forwarding routes before the destination is acknowledged. The federation lane carries
`HopQuery`/`HopQueryReply`, `HopRequest`/`HopAnswer`,
`CustodyQuery`/`CustodyReply` and `HopSettled`/`HopSettledAck`, each answered
for the connection's authenticated namespace. Laws:
`CompanionCrossingLawTests`.
Entity identity is `WorldEntityAddress(authority, index, generation)`.
`WorldAuthorityRoute` carries that complete address plus an epoch, and
`WorldSeatAuthorityRouter` publishes the complete claim with CAS. Rendering,
input, audio, HUD, targeting, and read-backs consume that one route.
`WorldContinuum` and adjacency presentation compare the full address; an
authority string plus a recyclable index is not an identity.
Every reciprocal handoff uses a true ownership deadband rather than transferring
at the authored plane and merely suppressing the return edge afterward. A body
remains with its current writer until its center reaches the far side of that
deadband, so the mapped arrival is already that far inside the destination and
the pair closes. The boundary's geometry selects which deadband
(`WorldAdjacencyPolicy.OwnershipThreshold`):
- A **vertical wall** carries the reciprocal contact hysteresis — two maximum
body reaches plus contact skin — so a legal cross-authority melee correction
cannot manufacture an immediate return. Because that threshold moves a
vertical ownership face outward, the runtime expands its horizontal half-width
by the same threshold; otherwise two perpendicular faces leave an unowned
threshold-by-threshold square at their corner and a diagonal traveler can
escape both writers. The authored vertical aperture remains exact.
- A **floor/ceiling** boundary carries `TryVerticalOwnershipDeadband` — derived
per document as the max over kits of the fastest vertical travel the kit's
holds admit (the greater of gravity over one authority step and the fastest
authored terminal speed) carried over one more step, plus the contact skin,
plus one raw unit, every quotient rounded outward. It is a hysteresis width,
rate-dependent (about 0.69 m for a 40 u/s kit at 60 Hz, roughly double at
30 Hz), so a destination needs that much clear space past the plane. It bounds
only hold-driven travel: a full-lift row (which may author no envelope), a
vertical-velocity effect, Pull momentum and rigid impulses are outside it, and
a body they drive past it in one step is handed over once per crossing because
the sweep tests the whole step's segment. A zero threshold there reads a
settle as a departure and oscillates the traveler across the seam.
`TryDeriveOverlap` covers whichever threshold is larger, and
`WorldAdjacencyBand` derives its aperture from the same numbers the ownership
sweep does, so no point ownership claims is outside every contact band. The band
bounds the OWNED side by the derived depth and is unbounded outward — a body past
the plane has left this world's terrain, the neighbour's own geometry is what
decides whether there is ground, and a finite outward bound is a hole for as long
as a handoff takes to drain. Its horizontal half-width expands by the ownership
threshold on a yaw-only face for the same reason the sweep's does. An
intermediate hop of a derived corner path is gated on the depth alone
(`WorldAdjacencyBand.Transits`): the junction beyond two perpendicular rectangles
is exactly the region the diagonal peer serves, and the commuting-diamond proof
is what makes transport past the aperture the same point either way round. The arrival-border latch
remains a defense for federated delivery and observes both ends of the first
destination step, so a genuine rapid reversal cannot run outside its owner while
the reciprocal edge is disabled. Other edges remain eligible, including deterministic forwarding
at a multi-world corner. One already-evaluated source step carries its mapped
geometric cursor, exact engine-time interval, consumed-through watermark, and
bounded face count through every onward owner. Each destination sweeps its own
terrain before selecting another ownership face. Each authority step settles
its pending continuations itself, under its own gate, before it advances
(`WorldAdjacencyOwnership.ResolveContinuations`, the same sweep the host's
post-step scan selects winning faces from), so a replay shadow with no host
settles them exactly as the live step did; a body cannot evaluate input,
actions, timers, gravity, or movement while the geometric cursor is pending or
while the step's start overlaps consumed continuum time. This makes a 60 Hz source safe when its destination is scheduled
at 120 Hz. Exhausting the eight-face work ceiling clamps one raw fixed-point
unit inside the last confirmed owner and removes only outward normal velocity.
Portal furniture retains only active inside latches in `WorldPortalOccupancy`.
An outside observation removes its row, so memory follows occupied regions rather
than every scanned traveller/face pair. Its `Capture` sorts by ordinal placement,
face and seat: set enumeration is not a deterministic continuation format after
removal, restore and insertion. Keep that ordering at the single capture door.
`WorldFaceRegion` and rounded-box contact share `FixedSegmentClip.Axis`; only
crossed slab boundaries require a quotient. Same-side separation is tested before
nearest fixed rounding, and wide endpoint differences use the existing Maths
rounding primitive. One-sided firing remains separate from endpoint occupancy.
The interval-clipping principle is corroborated by
[PBRT's bounds derivation](https://www.pbr-book.org/4ed/Geometry_and_Transformations/Bounding_Boxes)
and [Bullet's ray/AABB implementation](https://github.com/bulletphysics/bullet3/blob/master/src/LinearMath/btAabbUtil2.h).
Those floating-point implementations do not define Puck's fixed rounding or
one-sided ownership policy; exact laws and composed World runs establish those.
## Input and action continuity
Movement and actions route to the seat's current authority. A transfer carries
committed counter/timer action registers by declared name rather than
document-local ordinal. The destination admits only the same name and kind,
under its own envelope. Input itself resets unconditionally: no held value,
edge latch, queued press or partial pattern crosses the boundary. Destination
input starts a new epoch and requires fresh admission and neutral rearming;
cancellation never scores as a release. The shared transfer leaf carries only
the registers, while a same-authority abort restores the full captured state.
`body.press`, `body.channels`,
`body.state`, `body.targets`, `world.contacts`, and `body.where` follow
the same seat route after a crossing, and so do the seat-routed document
writes `player.row.set`/`player.state.cell.set` — the `world.row.set`/
`world.state.cell.set` grammars submitted through the seat's current
authority (`ServerLinkSubmissions.SubmitWorldMutation` over
`WorldFederatedServerLink.SubmitEnvelope` → the federation
`Routed` lane → `WorldLocalForwardedAuthority.TryApplySubmission`, where the
DESTINATION re-stamps the envelope with the traveler's own transfer principal
and its ordinary admission door — row-scoped grants included — decides it; the
verdict narrates on the destination's transcript). That is how a
contribution-slot holder fills its slot from the console it is sitting at. A
new seat-facing verb that reads the
boot population directly is a routing defect.
## Contact across the overlap
`WorldAdjacencyFields` owns the delivered neighbour images used by both contact
and presentation. It freezes the complete direct-plus-derived projection graph
once per authority tick; contact must not rebuild that graph per body.
`WorldAdjacencyContactField` walks the same projection set as rendering,
including a diagonal peer whose two overlap bands meet at a four-way corner. It
maps the body through every path stage, resolves neighbour terrain and eligible
dynamic bodies, then maps the answer back through the inverse path. Querying
only authored direct edges leaves a physical hole at the literal corner even
when the rendered diagonal floor is present.
A neighbour's answer moves a local body only through
`WorldPopulation.AdmitAdjacencyResponse`: its bodies' pushes and its geometry's
resolution cross back as one displacement and one velocity per projection.
Refused neighbour sweeps propose their rollback through that door; only the
local field may refuse the body's move. Support-selected descents are tagged by
`IFixedContactStep.SweepSupport` through `WorldBody.BodyContactStep` and
`IEntityContactField.ResolveEntitySupportSweep`. Unless the local landing itself
grounds, the neighbour's entire landing displacement is admitted from the local
stationary answer, including the descent and landing depth. A step-up carries
its original integrated endpoint as `responseOrigin`, so neighbour support must
also pay for the entire lift; its raised probe is never an admission baseline.
A shortened landing
does not claim neighbour ground and the snap is rejected. Ordinary local support
keeps its own landing. `IWorldAdjacencyNeighbourContact` hands out `IContactField`;
the delivered document still compiles it through `WorldSolidField.TryBuild`.
Every sweep that moves a body names it (`WorldBody.SweepContact`); a probe that
names no body takes nothing from a neighbour. The door keeps two invariants per
local body per tick:
- The sum of admitted lengths is bounded by the local body's scaled collider
reach, each also limited by the consulted overlap depth minus spent budget.
The per-body scratch is shared across projections and sweep retries,
including failed retries, and survives contact-field rebuilds. Remote body
counts, sizes, geometry and speed claims cannot widen it.
- Behind every ownership face (`WorldAdjacencyPolicy.OwnershipFaces`) the body
is still owned behind, the admitted end stays owned (`WorldOwnershipFace.Owns`,
the test `WorldAdjacencyRegion.Sweep` applies to a step's end) and the body's
outward speed through the face does not grow. A crossing the ownership sweep
reports therefore comes from the body's own motion; a neighbour can push a
still body up to its face but not across it.
`WorldPopulation.BeginAdjacencyContacts` opens one pinned image and budget for
the tick before its mutation drain. A mapped continuum arrival between ticks
opens the upcoming tick's same image and allowance; ordinary advance does not
replenish it. `WorldBody.FollowCarrier` names its population-bound slot even
before its first rigid advance. Its local block retains the ordinary carry
response; every propagated neighbour block goes through the same admission
door again for the carrier's own position, velocity and remaining allowance.
`WorldAdjacencyContactField.ResolveCore` composes every eligible projection in
order from the admitted answer. A rejected push contributes no ground or
obstruction, and a zero admitted displacement cannot steer velocity. Local
ground normals survive composition; accepted neighbour normals map into the
source frame. `WorldAdjacencyPath.MapDisplacementIntoSource` keeps exact length
from growing at each quantized mapping stage, so honest contact at the budget
does not lose grounding to a rounding-only clamp. The budget itself remains
exact, without an admission tolerance. These cases are exercised by
`WorldAdjacencyCorrectionLawTests`.
When incoming velocity retreats from an owned face, that same door admits no
correction toward the face and no reduction in retreat speed. Repeated phantom
bodies or sweep refusals therefore cannot cancel the body's own retreat; no
per-body decay state is needed for that guarantee. A still body can still be
carried up to the threshold within the existing budget. This does not attest
the reported geometry or bodies, nor remove their influence while the visitor
does not retreat.
Body contacts are settled by one responder per authority pair
(`WorldCrossAuthoritySettlement.LocalResponds`), from this authority's identity
and the identity the neighbour's authored link settled on before its first
projection is exposed. `WorldAdjacencyFields.LinkAuthority` survives observation
handle replacement, generation changes and transient resolution failures, so
neither respawning bodies nor refreshing an observation chooses who yields.
`WorldBodyWork.AdjacencyCorrectionClamps` counts shortened, rejected or slowed
responses in `world.counters physics.bodies`; its class is pacing until
neighbour inputs are taped. The fixed arithmetic is deterministic for the same
admitted images.
Outward of a boundary plane the neighbour's geometry decides the vertical. This
world's own terrain has ended there by construction, so ground its field still
reports is the rim of that terrain rather than the floor the seam continues, and
the wrapper consults the neighbour even when the local answer already says
grounded — a body walking the strip keeps the mirrored floor's height instead of
dipping over its own rim for the crossing tick. Inward of the plane the local
field decides alone and the neighbour is never asked.
Contact integration calls `IContactField.ResolveSweep`. `WorldSolidField`
subdivides a long step deterministically before applying its ordinary SDF
resolver; the adjacency wrapper sweeps both local and mapped-neighbour
geometry. Do not replace this with endpoint-only sampling: a capsule endpoint
inside a thin slab has an ambiguous nearest gradient and can be extracted
through an edge or the underside.
`WorldAdjacencySceneEmitter` renders the same projection set under two per-band
budgets, both `WorldAdjacencyGeometry` constants: `MaximumPlacementsPerBand`
solids and `MaximumEntitiesPerBand` delivered bodies, each selected in document
or delivered-slot order from what falls inside the band, each truncation named
on stderr. The construction-time probe reserves exactly those two budgets for
every band `WorldAdjacencyBands.ProjectionCapacity` admits — direct edges plus
derivable corner pairs, so the reservation is quadratic in authored edges. A
world whose composed scene cannot fit the engine's instance ceiling refuses at
boot by name (`[world] definition refused: the composed render scene exceeds …`,
from `WorldPostBuildWiring`'s pre-flight) rather than throwing out of the
presentation service graph.
Remote dynamic poses currently enter `WorldAdjacencyContactField` from
delivered floating-point snapshots. Until Track 3 tapes fixed, tick-aligned
neighbour records and installs the field at delivery time, do not claim replay
determinism for cross-authority dynamic contact.
## What the tape does and does not carry about federation
Every authority tapes its own half of a crossing. The source's
`WorldReplayEntry.Departure` entries name each detached or restored slot, and a
re-drive detaches them; its `WorldReplayEntry.Transfer` names the target
authority (and whether it is remote), the outcome and the slots the settlement
made final, and is the pairing key. The
destination's `WorldReplayEntry.Arrival` carries the arrival record and is
landed again through the shadow's own escrow at the tick it landed
(`ReplayRefusal.ArrivalRefused` when it cannot land in the same body indices);
its `WorldReplayEntry.FederatedIntents` carries the federated device images
forwarded and federated travelers drove the authority with, which reach it
through no loopback. An arrival's own admissions are not taped separately: they
re-derive when the arrival lands again. `replay.record` on a desktop tapes every
row of the process as companions in one file, and verification pairs each
departure with its arrival by handoff token (`WorldReplaySetVerdict`). A
crossing whose other half is on a remote authority, or on a row nothing taped,
is `NOT VERIFIED`, and `replay.verify` fails however exactly each trajectory
replays.
`WorldReplayEntry.LinkDelivery` remains the one transport fact taped for
adjacency liveness: one entry per authored `adjacencies` row per tick on which
that row's delivered neighbour snapshot tick advanced. It is what makes the
`linkEstablished`/`linkDropped` event family and the `$link:<adjacencyName>`
rule channel replay-faithful.
- Both halves of a transfer replay, as this process taped them. Each departure,
and each rollback of one, replays through `WorldReplayEntry.Departure` at the
position its authority operation took; `WorldReplayEntry.Transfer` is the
settlement's narration and the pairing key. The arrival
replays through `WorldReplayEntry.Arrival`: `WorldServer.ArrivalTap` reports
each commit that landed a traveler, with its `WorldArrivalOutcome` (each
landed generation, and whether it rolled back), and the re-drive calls
`WorldTransferEscrow.TryReland` with that outcome. Admission is part of the
landing and is never taped beside it. The tape refuses at read an arrival no
commit could have decided, and the re-drive refuses by name one its escrow
does not reproduce.
Still absent, and outside what a MATCH proves:
- The delivered CONTENT — neighbour poses, definition revisions, and geometry.
Cross-authority contact against remote dynamic bodies is therefore still
outside a MATCH (see the paragraph above).
- Reserve/commit/abort/acknowledge traffic as protocol: the tapes record the
decided departure and the arrival with its outcome, not the handshake.
- A crossing between processes: each process tapes its own half, and nothing
pairs tapes recorded by separate processes.
What IS taped on the submission side: every document mutation, whatever
ingress it arrived through. `WorldServer.MutationTap` fires at the envelope
dispatch every submission shares, so a local console write, an admitted socket
peer's, and a traveller's submission forwarded by its source authority
(`WorldLocalForwardedAuthority.TryApplySubmission`) all tape identically, each with
the acting principal its own envelope stamped. The two internal producers that
reach `EnqueueMutation` directly — a mounted guest's decoded act and a world
rule's `generate` effect — are deliberately untaped and re-derive during the
drive.
## Federation transport
`WorldFederationCodec` (`Puck.World.Server`) is the one authority-to-authority
codec. It reuses the framing, bounded reader/writer, and refusal vocabulary in
`Puck.Networking/WireCodec.cs`: `WireFrame` carries
`[u32 following][u8 kind][payload]` little-endian — the same grammar
`WorldFrameCodec` defines for submissions — over `WireReader`,
`WireWriter`, and `WireRefusal`. Every decoder over peer bytes is
Try-shaped and bounded before it allocates; a decoder that throws on hostile
bytes is a defect. Add a message as a leaf there, never as a second dialect.
World uses `WorldPeerNetwork` over `Puck.Networking.Peers.Peer` and its QUIC
transport. Never introduce a TCP fallback or a second connection identity.
`PeerStream` carries the existing bounded application codecs over signed peer
messages; the networking handshake precedes World's own admission policy.
`PersistentRequestLane` receives a stream connector and owns no socket choice.
Desktop boot shares one network owner across the listener, transfers, observations,
and intent streams; silo activations own their configured peer lifetime.
One application stream carries the whole conversation: the federation wire key
(`WorldFederationCodec.WireKey`, distinct from the interactive peer key), then
`Challenge`/`Authenticate`/`Authenticated` (reciprocal proofs and the destination namespace), then framed requests in order,
request-then-response, until `Observe` or `IntentStream` takes the connection
over and streams on it. There is no second hello and no correlation id.
Both nonce-bound proofs also bind the ordered peer transport-key hashes and
their direction. The destination proof binds its advertised namespace, and an
unpinned client requires the verified subject to equal that namespace. An Entra
client with an explicit remote transport-key pin checks that pin before sending
its bearer credential; this pin replaces the destination attestation proof.
Verifier-only servers have no implicit pin. See the
[server transport contract](../../../../src/Puck.World.Server/README.md#federation-transport-worldfederationcodeccs).
Refusals are named (`WorldFederationRefusal`) and every refusal frame's text
opens with the name, so a peer and `WorldPeerHost.FederationRefusals` count the
same vocabulary.
`WorldRemoteAuthority` holds persistent authenticated lanes per source authority
namespace: a `FederatedIntentPump` for the latest-value intent stream, and a
`Puck.Networking.PersistentRequestLane<WorldFederationRequest, WorldFederationResponse>`
(adapted by `WorldFederationLaneProtocol`) per `WorldFederationLane` concern —
`Transaction` for reserve/commit/abort/acknowledge/status, `Routed` for route
lookups and forwarded submissions. Connect, hello, and challenge are paid once per lane.
A lane is strictly ordered, so everything sharing one queues behind whatever is
in flight; that is why the two concerns are separate, and why adding a request
kind means deciding which lane it belongs on.
Only a failure to CONNECT takes a lane out of service, and only after a retry.
A break on an established connection reconnects without entering backoff — a
live neighbour must not be marked unavailable over one recycled socket — and
re-sends once ONLY when `ILaneProtocol.MayResend` says the kind is safe to send
twice (`WorldFederationLaneProtocol` answers false for `Submission`, which the
host applies straight through with no dedup, and true for the transfer-id-keyed
kinds); otherwise the request is answered `ConnectionClosed` and left in
doubt. Every attempt runs under the lane's per-request deadline
(`WorldRemoteAuthority.LaneRequestTimeout`): a peer that goes silent after the
request was written is answered `RequestTimedOut` without a re-send and
without backoff, so slowness never changes lane state. An unexpected exception
from the dialect answers that one request `LaneUnavailable` and the worker
serves the next. A lane inside its backoff window answers every request
immediately with `LaneUnavailable` without touching a socket, which is what
keeps a closed edge from stalling the source's tick. A run that holds no
federation signing identity (no `--federation-key-file`) never opens a lane, an
observer session, or an intent stream: every request is answered
`LaneUnavailable` naming that, with one stderr line per authority. An
authenticator that verifies but cannot prove (trust entries, no signing oracle)
passes `IsConfigured`; the first proof it refuses reveals it, and the same gate
closes on it from then on. Every refused `WorldFederationAnswer`, lane-refused
ones included, carries `WorldFederationResponse.Refusal` as its kind.
`WorldRemoteAuthority` dials through its host's one `WorldPeerNetwork` (never a
second) and runs every bound it keeps — `LaneRequestTimeout`,
`ConnectRetryDelay`, `RoutedRequestDeadline`, reconnect pacing — on that
network's `Clock`, so a law drives them with `VirtualClock` rather than wall
time (`FederationTransferLawTests.RemoteAuthority_ClosesTheSigningGate…`).
Every transfer step answers. A step that ran out of time is a named refusal,
never "ask again": a caller told to retry would hold the transfer while the
adjacency scan minted a second crossing for the same seat, landing the traveler
at the destination twice. Abort and acknowledge are posted and never waited on.
A commit answered `WorldTransferStep.Unreachable` is IN DOUBT, never a refusal —
the source keeps its recovery state and reconciles against the destination's
idempotent status.
## Verification
The focused laws for frames, handoff continuity, hysteresis, contact sweeping,
and crossing durability:
Build each test project first (`dotnet build <project> -c Release --no-restore
-nodeReuse:false`), then run it with `--no-build`:
```text
dotnet test tests/Puck.World.Server.Tests/Puck.World.Server.Tests.csproj -c Release --no-build --filter-class "*WorldAdjacencyLawTests" --filter-class "*WorldAdjacencyCornerContactLawTests" --filter-class "*MappedArrivalApplicationLawTests" --filter-class "*HighSpeedGroundContactLawTests" --filter-class "*CrossingRecoveryLawTests" --filter-class "*CrossingHandoffTokenLawTests" --filter-class "*CrossingReplayLawTests"
dotnet test tests/Puck.World.Presentation.Tests/Puck.World.Presentation.Tests.csproj -c Release --no-build --filter-class "*FederationTransferLawTests"
dotnet test tests/Puck.World.Silo.Tests/Puck.World.Silo.Tests.csproj -c Release --no-build --filter-class "*WorldSiloCrossingRecoveryLawTests"
dotnet test tests/Puck.World.Schema.Tests/Puck.World.Schema.Tests.csproj -c Release --no-build --filter-class "*WorldFrameIsometryLawTests"
```
No live canary exercises a crossing: the canary manifests and quilt worlds are
quarantined under `experimental/`, so `puck canary` finds none of the ids
below. They record what the crossing proofs covered: `seamless-adjacency` for
the driven crossing on NW's east face
(its tape set pairs NW's departure with NE's own taped arrival and names the
crossing verified),
`quilt-nw-gap-edge-carry` for the undriven one (a body placed past
NW's own ground on the `south` face's centre line is minted a crossing by the
per-tick scan alone; quilt-nw-gap drops that adjacency, so the identical body
falls the full sixteen units instead),
`seamless-four-corners-circuit` for the colocated four-hop ring, and
`four-corners-sharded` for the federated hop: five real `Puck.World`
processes (four ground worlds and the floating island), each binding its own
dynamic loopback endpoint and trusting the others' generated federation
identity, with one driven body crossing NW's east face onto NE's own process.
NW and NE each record a tape there: NW's names the crossing `NOT VERIFIED`
because its arrival is on a remote authority, and NE's lands the arrival again,
replays every step it held the traveler's federated input for, and names the
arrival from NW `NOT VERIFIED` for the same reason.
A body that arrives over a federation hop is minted rigid on the destination,
and `WorldInstanceHost.Transfers.cs` refuses a rigid body's own transfer by name,
so a federated ring cannot be driven past its first hop today. Vertical/island
crossing, retained dual-stick camera/movement control, autonomous producer
travellers, derived diagonal peers, and cross-authority contact-pair settling
are not exercised either.
For federation transport changes, both sides need the same
`--federation-key-file`; inspect both stdout and stderr. Authentication must
precede observe, reserve, commit, status, intent, and submission operations.
Omitting the federation key disables federation by name without changing the
ordinary admitted-player socket.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |