life: end a container and its contents together

PerishFire commented

2026-08-19 09:46:02 +00:00

Owner

Keel refused to end a row while anything still pointed at it, and that refusal
did not distinguish a reference from a container. A root relation is not an
ordinary edge: it names the container a row belongs to, the row's identity is
derived from it, and the query language spells it with a colon for that reason.
A contained row outliving its container is not a policy this model can hold.

Ending a row now ends the rows rooted in it, deepest first, in the transaction
that ends the row itself. Containment is single-parent and acyclic, so the set
is a tree and there is no second reading of what ending a container means. A
lease propagates the instant rather than the fact, so scheduling a container to
expire schedules its contents for the same moment and nothing is briefly
orphaned in between.

The tie check now asks whether anything outlives the horizon being written,
instead of whether anything is live now. That is the same question when the
horizon is now, and the right question when it is not.

References are untouched. A live edge that is not containment still refuses the
end, because the pointing row belongs to somebody else and its author declared
a dependency, not a home. The gate's own test now says both halves in one
breath: an actor cannot go while a stranger's issue names them as author, and
the same actor goes cleanly once nothing outside their own subtree points in,
taking their repositories and the issues inside them.

This is the removal codehull's closure route was written by hand to work around.
That sweep listed twenty-three units and their order, which is the shape of an
engine gap living in a caller; it can go once this reaches a release.

Co-Authored-By: Claude Opus 5 (1M context) noreply@anthropic.com

Keel refused to end a row while anything still pointed at it, and that refusal did not distinguish a reference from a container. A root relation is not an ordinary edge: it names the container a row belongs to, the row's identity is derived from it, and the query language spells it with a colon for that reason. A contained row outliving its container is not a policy this model can hold. Ending a row now ends the rows rooted in it, deepest first, in the transaction that ends the row itself. Containment is single-parent and acyclic, so the set is a tree and there is no second reading of what ending a container means. A lease propagates the instant rather than the fact, so scheduling a container to expire schedules its contents for the same moment and nothing is briefly orphaned in between. The tie check now asks whether anything outlives the horizon being written, instead of whether anything is live now. That is the same question when the horizon is now, and the right question when it is not. References are untouched. A live edge that is not containment still refuses the end, because the pointing row belongs to somebody else and its author declared a dependency, not a home. The gate's own test now says both halves in one breath: an actor cannot go while a stranger's issue names them as author, and the same actor goes cleanly once nothing outside their own subtree points in, taking their repositories and the issues inside them. This is the removal codehull's closure route was written by hand to work around. That sweep listed twenty-three units and their order, which is the shape of an engine gap living in a caller; it can go once this reaches a release. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

PerishFire added 1 commit

2026-08-19 09:46:02 +00:00

life: end a container and its contents together

guard / guard (pull_request) Successful in 2m16s

Details

guard / guard (push) Successful in 1m55s

Details

d9e22f0bfa

Keel refused to end a row while anything still pointed at it, and that refusal
did not distinguish a reference from a container. A root relation is not an
ordinary edge: it names the container a row belongs to, the row's identity is
derived from it, and the query language spells it with a colon for that reason.
A contained row outliving its container is not a policy this model can hold.

Ending a row now ends the rows rooted in it, deepest first, in the transaction
that ends the row itself. Containment is single-parent and acyclic, so the set
is a tree and there is no second reading of what ending a container means. A
lease propagates the instant rather than the fact, so scheduling a container to
expire schedules its contents for the same moment and nothing is briefly
orphaned in between.

The tie check now asks whether anything outlives the horizon being written,
instead of whether anything is live now. That is the same question when the
horizon is now, and the right question when it is not.

References are untouched. A live edge that is not containment still refuses the
end, because the pointing row belongs to somebody else and its author declared
a dependency, not a home. The gate's own test now says both halves in one
breath: an actor cannot go while a stranger's issue names them as author, and
the same actor goes cleanly once nothing outside their own subtree points in,
taking their repositories and the issues inside them.

This is the removal codehull's closure route was written by hand to work around.
That sweep listed twenty-three units and their order, which is the shape of an
engine gap living in a caller; it can go once this reaches a release.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Land-Source: life/cascade@de59ee476a

PerishFire merged commit d9e22f0bfa into main

2026-08-19 09:48:24 +00:00

Rows
Columns

life: end a container and its contents together #169