A publish appends a version and moves the active pointer
Publishing writes a new version, compiles its snapshot, and moves the active pointer to that snapshot. The version row is what was published. The pointer names what enforcement reads next. Both are part of the operation, and the operation marks the previously active version superseded and leaves its rules untouched. History grows by addition.
An in-place edit of the previous version is a different act, and it is not a publish. Someone who reads the history is reading the rules as they were written. Adjusting an old row so that a later story fits is how a log becomes a recollection. The design stores the rows. The recollection, if it disagrees with a row, loses.
No product path changes a published version’s rules: the service refuses any edit once a version has left draft. In this POC the database credential the services run with can still rewrite a version’s stored rules, with no chained event, and that grant is still open. Activation refuses a snapshot whose rules differ from the version’s stored rules, so a rewrite made after the snapshot was compiled is stopped at activation. A rewrite made before the compile is carried into the snapshot and passes. So is a rewrite of an older version, which a later rollback compiles from as it then stands.
Rollback selects an older version by moving the pointer
Rollback compiles a fresh snapshot from an older version and moves the active pointer to it, once one account has drafted the rollback and a second account has approved it. That older version has to still be the version that was published, or the selection would be a rewrite wearing the name of a rollback. The version that was active a moment earlier stays in the history too. The new facts are the pointer movement and a snapshot compiled fresh from that version’s rules with the exceptions and packs in force now. The published rules stay as they were, and only each version’s status changes.
An agreement reached in a meeting moves nothing, because only an approved publish or rollback moves the pointer. A hardware token brought to the evaluation is outside this page’s claim, and hardware officer tokens are absent in this POC in any case. An evaluation can open the version row, read the rollback event chained with the move, and read the snapshot the pointer now names and the version it was compiled from.
The snapshot swap is atomic, and a started request finishes on its own snapshot
The pointer names the compiled snapshot enforcement uses. A change replaces that snapshot as a unit. A request which has already begun finishes against the snapshot it began with, so a publish landing in the middle of the request cannot stitch two versions into a single action. The next request is the one that sees the new snapshot.
There is no blended timing between those two. Operators who need the new version wait until the pointer has moved, and they accept that work already underway will complete on the old snapshot. Calling the gap “eventual” would invent a third behaviour in which a live rule changes under a decision. The design has the unit swap and the in-flight snapshot, and it stops there.
Policy rows and audit checkpoints answer different questions
The version rows let a later reader name the basis a verdict had, because the basis was appended rather than overwritten. The pointer says which basis was active. Together they are the account of policy change this POC stores. A verdict’s action can be tied back to a version that still exists as a row.
That account is not the audit-chain checkpoint. A checkpoint is an Ed25519 signature over a record naming the chain head, and the anchoring cadence moves only when an acknowledgement matches that checkpoint’s stored bytes. A policy version can be intact while that cadence is stalled after one checkpoint, which is what happens when the command-line stand-in is not run. A moving cadence can equally sit on an older policy version. Healthy policy history and a healthy checkpoint cadence are two records.
One pointer is what “in force” refers to
Enforcement follows a single active pointer. One version is in force. The other versions are history a rollback can return to. A demonstration that presents two versions as simultaneously current has misread the mechanism. The question “what is in force” has an answer because the pointer is singular.
The console that displays the pointer has its own limit, and the limit stays in the same conversation. The session that opens the pointer is issued after a local password check against a stored hash. Directory single sign-on is not the provider of that session. Opening the pointer after that sign-in shows the pointer. It shows a local session as well. The version machinery can be real while the session provider is still the local one, and an evaluation writes both facts down.
How to read this
| Read it as | Which means | Do not read it as |
|---|---|---|
| Publish | Writes a version and moves the pointer | An edit of the previous version |
| Rollback | Moves the pointer back | A rewrite of history |
| In-flight request | Keeps the snapshot it started with | A live rule that changes mid-decision |