The sessions overstep

Sessions share no memory and work unwatched, so one repeats a mistake, collides with another, publishes what was private, or takes an action that was a person's to take.

Each failure below is a row of the grid, with what holds it at each rung.

  • Throughout In place across the stack.
  • In places In some projects, or for part of the failure. The entry says what is left out.
  • Out of reach This rung cannot hold the failure.
  • Wanted More is intended here and not built.

A known mistake comes back

The same class of error repeats across sessions that share no memory.

Written: The correction is written down

Coverage
Throughout
Does
When an agent gets something wrong, the correction goes into a file that later sessions load.
Fails
When a written warning is expected to prevent a mistake that only a check can prevent.
Evidence

Tool: The gate

Coverage
In places
Does
Each repo has a gate that a session runs before landing: types, lints, tests and format checks, and in the TypeScript repos drift in generated files. CI runs it again on a push to the main branch.
Leaves out
A few repos have no CI, or one that runs less than the local gate; the list under the gates table names them. A mistake reaches the gate only once someone has given it a mechanical form.
Fails
When green is read as correct. Agents push to the main branch, so CI reports after a commit has landed and the local run is the only check before it.
Evidence
Listed

Shape: Impossible states do not compile

Coverage
In places
Does
In Rust, closed sets are enums and input structs reject unknown fields. In TypeScript, schema objects reject unknown keys. The flags for what a server mounts have no default, so a new one fails compilation until every config states it.
Leaves out
It reaches only a mistake that can be stated as a type or a schema, which most cannot.
Evidence
Listed

Two sessions collide

Two sessions work in one checkout, or one pushes onto a base the other never tested.

Written: One writer per checkout

Coverage
In places
Does
The written rules give a long-running effort one checkout with at most one live session, keep one writer alive at a time within it, and make a worktree the way to work in parallel.
Leaves out
The rule is written for long-running efforts, not for every session.
Fails
When isolation is left to convention: the rule itself says there are no locks, and the operator owns it.
Evidence
  • The grimoire skill, on one checkout, one live session and one writer at a time

Tool: Busy detection and rebase on push

Coverage
In places
Does
The repos tool reads the live agent sessions and holds every sync and push on a checkout one is working in, and holds everything when it cannot tell. A push onto a branch another session moved replays the commits onto it first and says that their checks ran on the old base, and a dirty checkout holds that push.
Leaves out
It holds syncs and pushes, not edits: two sessions can still write the same files. It cannot see a session that writes no session file, and it works on Linux alone.
Fails
When rebased commits go out without their checks being run again on the new base.
Evidence

Shape: A worktree per effort

Coverage
In places
Does
A worktree gives a session a checkout of its own, so its edits cannot land in the files of another.
Leaves out
A worktree is opt-in, and the default is the main checkout.
Evidence

Private content reaches a public repo

A planning note or a private path lands in a public repo, and a push publishes it at once.

Written: The planning layer stays out

Coverage
Throughout
Does
The written rules keep planning docs outside the repos, keep the contents of a planning layer out of anything public, and keep a doc comment from pointing outside its own repo.
Fails
When an agent adds a helpful cross-reference, completes a path it has seen, or runs a docs sweep that reaches too far.
Evidence
  • The grimoire skill, on the membrane and the accidents it guards against
  • The fuz-stack skill's shared rules, where a planning doc lives outside the repo
  • The path rules for other repos, where a doc comment never points outside its repo

Tool: Checks at the edges

Coverage
In places
Does
gro's check fails in CI on a TODO Markdown file at a repo's root, and the repos tool reads each private repo anonymously on a fetch and reports one it can read as leaked.
Leaves out
No check in the public repos reads a commit for a private path or a secret before it is pushed.
Evidence
  • gro's check task, which refuses a TODO doc at the root in CI
  • The repos tool's docs on fetching, with its visibility check
Listed

Shape: An inert planning layer

Coverage
In places
Does
The written pattern keeps planning in a separate repo of Markdown with no runtime and nothing listening, so a planning note is never a file in a public tree.
Leaves out
It keeps the notes out of a public tree, and does not keep a reference to them out.
Evidence

An unattended session does something irreversible

A session publishes, deploys, rewrites a branch, changes a version or adds a dependency with nobody watching.

Person: The maintainer releases

Coverage
Throughout
Does
Versions, publishing, new dependencies, new packages and deploys stay with the maintainer.
Cost
Work waits on a person at exactly the outward-facing steps.
Evidence

Written: Rules for versions and dependencies

Coverage
Throughout
Does
The written rules keep a version change, a new dependency and a new package with the maintainer.
Fails
When the rule is the only limit and a session does not load it.
Evidence

Tool: Deny rules and dry runs

Coverage
In places
Does
The agent harness denies raw pushes, as the push tool's docs recommend, and the publish and deploy commands, in settings that are not public. A new command in a shipped Rust tool whose effect is hard to undo is a dry run until it is given an explicit flag, a real run of zap executes only a plan it has already previewed, and the release scripts of tsv, pglet and blake3 are dry runs by default.
Leaves out
No gate detects a version change, and a new dependency or package passes nearly every gate: fuz_schema has a test that allows it no runtime dependency, and tsv makes a new crate declare whether it publishes. The deny rules match a command by its prefix, so one spelled another way gets past them. gro's publish and deploy tasks, which the TypeScript libraries release with, run for real unless told otherwise, and so do the release task of fuz_forge, the publish command of fuz and the addon publish script of tsv.
Fails
When a session passes the explicit flag itself.
Evidence
Listed

Shape: A push tool that cannot

Coverage
In places
Does
Agents push through a tool that only fast-forwards the remote branch, replaying a diverged local branch onto it first. It has no way to send a tag or a force.
Leaves out
Only pushing goes through such a tool. Publishing and deploying have none, and git itself is still on the machine, behind a deny rule.
Evidence
Listed