security architecture — including this standard — is net-kingdom canon's.
### 3.2 Tooling
Deterministic infrastructure: data structures, persistence, and the consistent,
performant, scalable keeping of state. Much of it is third-party.
### 3.3 Engines
Deterministic APIs for a modeled concept — a user, a tenant, a zone, a secret,
an access rule. An engine's defining property is that **the same authoritative
input state yields the same result**. Engines are where the estate's
deterministic guarantees live, and therefore where every enforcement boundary
MUST sit.
A repository whose core function is inference or judgment fails this test by
construction and is Staff, however much of its work happens at runtime.
**Engines are typed.** "Engine" is one layer but four roles, and collapsing them
hides different failure modes. Every §4 Engine row carries a role:
| Role | Meaning | Outage means |
| --- | --- | --- |
| **PDP** | renders the authorization decision — `access-engine`, and only it (§6) | consumer residue (§9.3) |
| **PIP** | supplies facts a decision consumes as claims — user, tenant, zone, approval, maturity | input degradation, engine's own fallback (§9.3) |
| **Evidence** | records what happened and proves integrity of what it holds — `audit-core` | MUST NOT block the operation being recorded — a default, not a property; see below |
| **Lifecycle** | a deterministic API over Tooling it owns — `secrets-engine` | the owning engine's failure semantics |
The roles are why *"we need an engine for X"* does not mean *"X now decides"*.
A new engine is a PIP unless this standard is amended to say otherwise, and §6
means it can never be a second PDP.
The Evidence row's outage rule is an estate **trade**, not a property of
evidence engines. Choosing availability there means accepting that a compromised
source can suppress a record and that detection is the answer (§9.6). The
opposite shape — *do not proceed unless an independent custodian already holds
the record* — is the only one that puts evidence outside the actor's blast
radius **before** the act. The estate has not needed it, so it is not ruled out
by a table cell: an operation whose control genuinely requires independent
recording before effect is a declared exception, raised when needed. Raised by
`audit-core` against its own row.
The industry vocabulary is deliberately mirrored here — PDP, PIP, PEP as in
NIST ZTA and XACML — because it is how the estate talks to the outside and how a
PEP is stopped from quietly becoming a PDP. The determinism cut in §3 stays
primary where the two disagree.
### 3.4 Staff
Interactive and non-deterministic. Staff is the management layer: operations,
change, innovation, and controlling. It works through agentic capability —
assistants and autonomous agents — and its artifacts are specifications,
decisions, workplans, and tasks.
Staff repositories MUST NOT hold state that another layer depends on at
runtime, and MUST NOT render or cache any decision an Engine is responsible for.
Acting at runtime does not make a repository an Engine. Being agentic makes it
Staff, and §5 governs how it acts.
**Two principals, one layer.** Humans and agents are both non-deterministic and
both Staff, so they share the layer's permissions. They do not share blast
radius. Four rules bind the agent principal specifically:
1.**No standing credential.** An agent holds no long-lived credential of its
own. Authority is issued per task, time-bounded under §9.7, and attributable
to the principal on whose behalf it acts.
2.**Tool use is a conduit or an Engine API.** An agent acts through §5.2 — the
owner's tool under the caller's identity, presenting no authority of its own
— or through an engine. There is no third route. Tool availability is not
permission: a callable tool means the operation exists, not that this actor
may invoke it.
3.**Agent memory is not a state plane.** Agent memory, tool-call traces, and
prompt caches are the agent's own. They MUST NOT become state another layer
depends on at runtime unless catalogued as Tooling in §4, which subjects them
to §5 like anything else, and to §5's sunset.
4.**Every agent action is reconstructable as the caller's action**, bounded by
§9.6 — the archive shows the actions it received, not that it received all of
them.
Session semantics — session loops, tool policy, harness routing, model
selection — are **not** governed here. They belong to `glas-harness` and its
`rein-*` backends (§20). This standard governs what an agent may be authorized
to do; `glas-harness` governs how an agent session is conducted. Rule 2 is the
seam between them, and neither side may treat its own half as sufficient.
v0.6 claimed these rules in its change log and did not write them. Found by
`kings-guard`, which is the repository they bind hardest and which offered to
| `kings-guard` | Staff | — | adaptive defence and judgment; observation of Staff-reachable sources — identity and secret observation **pending**; **proposes** containment, which it does not own (§9.2) |
The asymmetry is what bounds the damage when observation is incomplete (§9.6):
suppressed evidence can only prevent a tightening that should have happened, never
engineer a loosening. That is an argument for keeping it absolute rather than
situational.
## 9. Capability assignment
### 9.1 The catalog may not assign what the rules forbid discharging
A Staff repository MUST NOT be catalogued in §4 as owning a capability it cannot
discharge under these rules. Two marks distinguish the two ways that happens, and
they are not interchangeable:
| Mark | Meaning |
| --- | --- |
| **pending** | No route exists. No engine exposes the capability, the repository makes no Tooling contact, and the capability is **zero** — not degraded. |
| **declared-gap** | A route exists through a §5.3 declared gap. The capability **works** and is tracked, with an intended owner and a review date in §13. |
v0.4 had only `pending`, which forced a false choice. `ops-warden` holds
production-verified SSH certificate issuance through a declared OpenBao contact;
marking it `pending` would have told readers the repository does not do the one
thing it demonstrably does daily, while leaving it unmarked left §4 disagreeing
with §13. Neither is acceptable, and the defect was in this section rather than
in the catalog.
`pending` was written for `kings-guard`'s containment — no route, capability
zero — and remains correct there. `declared-gap` is the case §5.3 was added to
sanction. Raised by `ops-warden`.
Both marks apply per capability, not per repository. A repository may hold one
capability outright, another under a declared gap, and a third pending.
### 9.2 Actuation does not exist, and containment is not Staff's to own
Self-healing needs four verbs: observe, evaluate, decide, actuate. Observation is
`kings-guard` and is unstaffed (§12). Evaluation is `maturity-engine` and is
seeded. Decision is `access-engine` and works. **Actuation has no surface at
all**, and a model with no actuation surface describes a diagnosis machine
rather than a healing one.
v0.5 marked containment `pending` against `kings-guard`, which was the right
mark on the wrong repository. Containment is not a Staff capability that happens
to lack a route: **reduce authority, require step-up, isolate a workload** are
authority-changing operations, and under §6 an authority-changing operation is
rendered by an Engine and enforced by a PEP (§6.4). A Staff repository proposes
containment; it never performs it.
The **actuation surface** is therefore an Engine concept — likely a small
surface on `access-engine` together with runtime PEPs — carrying the same
reconstructability rules as any other decision: a containment action is a
decision record, not a side channel.
It is **unowned and held at zero**. `access-engine` is recorded in §13 as a
*proposed* owner and has explicitly not reviewed it (`FLEX-DEC-2026-002`). No
repository may be catalogued as owning containment until the surface exists —
§9.1 applied to the estate's most operationally tempting gap, and the standard's
own medicine.
Until then `kings-guard` proposes and judges, its containment claim stays at
zero rather than degraded, and no argument may assume the estate can contain
anything automatically.
### 9.3 Degraded mode: two failure cases, two owners
v0.4 collapsed two failures into one rule. They have different owners because
one has an evaluator in the path and the other does not.
**Input degradation — the engine's.** Where `access-engine` is reachable but
cannot reach its own inputs, the deterministic *fail to reduced authority*
default belongs to the engine. This keeps the decision at the decision point and
keeps the fallback deterministic, which a Staff-layer fallback could never be.
**Engine unreachable — necessarily the consumer's.** Where `access-engine` is
not reachable at all, it applies nothing, because it is not running. Whatever
happens next is the consumer's behaviour by construction: fail-open is not
expressible by a policy decision point, since there is no evaluator in the path
to express it. A standard that assigns this to the engine assigns it to nobody.
The consumer's residue is bounded rather than free. A protected system MUST
declare its unreachable-engine stance ahead of time, per zone or equivalent
scope, and that stance MUST be auditable and total — no implicit default, no
per-call discretion. `ops-warden``ADR-0009` already satisfies this: a total
per-zone map, open for `z0`–`z2` and unknown, closed for `z3-critical`,
replacing the global `policy.enabled` / `policy.fail_closed` switches it
superseded.
**Unchanged: engine-unavailable is not grounds for a Staff break-glass path.**
The distinction is whether an engine is there to ask. A bypass around a
*reachable* engine is a second decision point, and an incident is when an
attacker most wants that shortcut. A consumer choosing its declared behaviour
when there is no engine to ask is not a bypass; it is the only thing left.
Contested by `flex-auth` (`FLEX-DEC-2026-002`), which has held since 2026-08-19
that fail-open is not expressible by a PDP, and which noted v0.4 collided with
shipped behaviour in a repository that had assented to this standard.
### 9.4 Approvals are an engine concept, not a Staff or audit concern
The approval object — durable, authenticated entries, distinct-approver
counting, atomic supersession, single consumption, revocation without holder
cooperation — is owned by `approval-engine`.
It is not Staff's: §3.4 forbids Staff holding state another layer depends on at
runtime. It is not the decision point's: an evaluator that owns the object it
evaluates is self-dealing. It is not the audit fabric's: an approval needs
mutable, in-path, current-state semantics, and an append-only archive is built
for the opposite property.
`access-engine` consumes approvals as **input claims** under §6.2 and never
mutates them. Every issuance, use, supersession, and revocation is emitted to
`audit-core`: the operative state and the evidence record are different
artifacts with different owners.
The evidence guarantee is bounded, and the bound is `audit-core`'s
`docs/integrity.md`, not its INTENT principle 6. An in-database hash chain
detects a rewritten payload only if the attacker does not also recompute the
suffix — which a database owner can. Detection against that class requires the
external chain-head attestation, and even with it the store is not WORM, object
lock, or archival custody. `tamper_evidence` is therefore conditional on live
preconditions, not a property of the store at rest, and approval events receive
exactly the guarantee every other source receives.
**Emission atomicity is `approval-engine`'s obligation.** An approval MUST NOT be
issued, consumed, superseded, or revoked without the corresponding event being
durably queued in the same transaction.
**The queue MUST be local.** The durable queue MUST live in `approval-engine`'s
own transactional store, and **no synchronous dependency on `audit-core` may sit
inside the state-change transaction**. With a genuine local outbox, fail-closed
triggers only when `approval-engine`'s own store is unavailable — where the
change could not have been recorded anyway — and an `audit-core` outage does not
block a revocation. Satisfying the requirement by emitting synchronously to
`audit-core` inside the transaction is also atomic, and turns an audit outage
into an inability to revoke: the operation least tolerable to block during an
incident, and the same coupling this section rejects for reads. Raised by
`audit-core`.
`audit-core` reports what it received and does not imply it is everything that
happened; without atomic emission the evidence half is silently incomplete and
nothing detects the gap. This is a condition of `audit-core`'s assent
(`AUDIT-IN-0001`) and belongs in `approval-engine`'s contract before the evidence
half is treated as load-bearing.
`audit-core` MUST NOT expose an approval-validity query. Records, yes; a verdict
on whether an approval is still valid, never — a consumer branching on that
answer would route an authorization decision through the audit fabric, which is
what this section exists to prevent. Callers needing current state ask
`approval-engine`.
### 9.5 Graded progression is an engine concept
Maturity — how far a subject has progressed against declared criteria and
submitted evidence — is owned by `maturity-engine`. Given the same criteria and
the same evidence it MUST return the same level; that determinism is what makes
it an Engine rather than an opinion.
The division with Staff: **gate-house judges and proposes; maturity-engine
computes and remembers.** Interpretation is inference and stays Staff. A
criterion that cannot be evaluated by rule is not yet a criterion.
This closes a defect in v0.2's own catalog: `gate-house` was assigned
conformance review with no engine to act through, which is exactly the §9.1
problem raised against the containment claim. Staff acts only through Engine
APIs, including gate-house.
**A maturity level MUST NOT be compiled into registry content.** Until
`access-engine`'s decision provenance carries a registry-snapshot digest — a gap
it self-declared in §13 — a level reaching a decision through the registry is not
reconstructable from the decision record. Levels arrive as request claims or as
versioned policy rules. Same constraint, and same reason, as zone stance.
**A maturity level MUST NOT gate a decision directly.** Under §6.1, compiled
data that determines an outcome is still deciding. If a level determines whether
an action is permitted, it MUST reach `access-engine` as an input claim or a
versioned policy rule under §6.2, never by a consumer branching on a fetched
level.
Approvals and maturity are deliberate opposites — a closed binary state machine
against an open graded ladder — and neither engine may drift toward the other.
### 9.6 Evidence proves alteration and truncation, not omission at source
An append-only archive with a verified hash chain proves that records were not
**altered or truncated after arrival**. It cannot prove that a record was never
sent. Against a compromised or buggy source, a suppressed event leaves the chain
perfectly intact and verification reports intact.
This bound is estate-wide. Statements of the form *"the audit record proves it
happened"* are unsound; the sound form is *"the archive proves the records it
holds were not altered or truncated after arrival"*. Its mirror is equally
unsound: **absence of a record is not evidence of non-occurrence**, and no
control may read it as such.
**Load-bearing versus attributive evidence.** The atomicity obligation attaches
to the first, not to both:
| Kind | Test | Obligation |
| --- | --- | --- |
| **Load-bearing** | a control's soundness depends on the event being present or absent — an approval revocation, a containment action, a denial | emission MUST be atomic with the state change (§9.4) |
| **Attributive** | the event supports forensic reconstruction and attribution, and no control branches on its presence | atomicity SHOULD be sought; where it is deliberately traded away, the trade MUST be declared and completeness MUST NOT be claimed |
Where a repository deliberately makes emission non-atomic — `ops-warden`'s
`# audit must not block signing` is the estate's live example, chosen so that an
audit-store failure cannot remove production host access — the trade is
legitimate for attributive evidence, MUST be declared where the trail is
documented, and MUST NOT be described in terms that imply completeness. The
availability argument is real in both directions: making it atomic gives the
estate's operational access lane a new dependency on its own evidence store.
**Consequence for adaptive systems.** Suppression does not degrade observation
neutrally, it biases it optimistic, and silently: an event never emitted is never
evaluated, so no finding is raised and the last posture stands. A confidence
score computed from the richness of the record in hand cannot express doubt about
the completeness of the stream — a well-formed observation from a 90%-suppressed
stream scores high. That is this section's failure reproduced one layer up, in
the consumer.
Two things follow.
**Which control covers which threat.** v0.6 read as though emission atomicity
closed this section's opening sentence. It does not, and the decomposition is
owed to the reader:
| Threat | Covered by | When |
| --- | --- | --- |
| **Accidental omission** — process dies between mutation and emit | emission atomicity, local outbox (§9.4) | prevented |
| **Adversarial omission** — a compromised source declines to insert, deletes before drain, or drains to nowhere | cadence and reconciliation | **detected, after the fact** |
| Adversarial omission at a compromised source | — | **nothing in this model prevents it** |
The outbox sits inside the blast radius of the component whose compromise this
section posits, so it makes emission atomic against crash and partial failure
and nothing more. That residual is real and is stated rather than implied.
Raised by `audit-core`, correcting a remedy it had itself proposed.
1.**The §8 asymmetry bounds the damage, and this is its clearest payoff.**
Because an adaptive system may only reduce authority and never manufacture it,
suppression can only prevent a tightening that should have happened. It cannot
be used to engineer a loosening. The harm is a missed reduction, not an
invented privilege — which is an argument for keeping the asymmetry absolute.
2. **Silence is a signal, and for load-bearing evidence it is the only control
in its class.** A source of **attributive** evidence SHOULD declare an
expected emission cadence; a source of **load-bearing** evidence **MUST**.
A drop below the declared rate is a finding in its own right — the stream
observed, not only its contents — and needs no Tooling contact, because the
source publishes its own stream.
**Rate monitoring is the wrong form for rare events**, and rare is exactly
where the stakes are highest: the most valuable event to suppress is the
negative one, and revocations, denials, and containment actions are
infrequent by nature. A source emitting a handful of revocations a month has
no rate to drop below, and suppression is indistinguishable from a quiet
month. For **low-volume load-bearing classes** the required form is therefore
**positive reconciliation or a heartbeat**: compare the source's own state
transitions against the evidence engine's event count per class and treat
divergence as a finding, or assert *nothing to report* as a signed positive
claim that can itself go missing. Rate monitoring never produces a claim that
can be missing; a heartbeat does. `GH-WP-0002-T04` is the reference instance.
Raised by `audit-core`.
Raised by `audit-core` against its own principle; extended by `kings-guard` from
its own evaluator and confidence model.
### 9.7 Decisions have a lifetime
A single decision point deciding on stale claims is a single decision point
deciding wrongly. The model has had no temporal law, and the approval race in
§16 was its first symptom.
1.**Every allow has an explicit lifetime** — a TTL, or a binding to a session
or obligation that ends. An allow with no stated end is a standing grant, and
standing grants are what this estate exists to remove.
2.**Revocation and supersession have a visibility deadline**, and its shape
differs by role. A **PEP** has one boundary and MUST state one deadline. A
**PDP** MUST state a deadline **per input class**, because a decision is a
join over sources with unrelated refresh behaviour — approval-claim freshness,
registry snapshot cadence, policy package activation, directory ETag. A single
number at a PDP is either a fiction or the worst case, and the worst case is
the slowest and least visible input. "Eventually" is not a stance; an unstated
deadline is an unbounded replay window.
A consequence worth naming: a stated deadline for a fact carried by a
registry snapshot is unfalsifiable while decision provenance holds no snapshot
digest, since nobody can determine afterwards which snapshot a decision read.
The deadline and the digest are one gap seen from two sides, which promotes
`access-engine`'s self-declared provenance gap (§13) from housekeeping to a
conformance prerequisite. Raised by `access-engine` against its own backlog.
3.**Consumption is a state change, never an inference.** An approval is
consumed by a mutation in `approval-engine` (§9.4). It MUST NOT be inferred
from the existence of a decision record — the decision precedes the action
and the action precedes consumption, so a decision record proves an intent to
act, not an act.
4.**Three failure modes are named, and each needs an owner**: an allow rendered
then never consumed; a double consumption by racing callers; consumption
after the authorized action has already failed. Neither engine closes these
alone. Recorded in §16 and `GH-WP-0002-T06`.
### 9.8 Partition is not one-dimensional
§9.3 handles *engine unreachable*. A real estate spends most of its incident
time in the band between reachable and gone: partial PIP reachability, clock
skew across a decision and its enforcement, and two consumers with different
declared stances seeing different worlds at the same moment.
Two rules hold today, and the rest is open (§16). A PEP MUST resolve its own
stance from its declared map without consulting another consumer — divergent
views are expected and are not a coordination problem to be solved at enforcement
time. And where clock skew could extend a lifetime under §9.7, the shorter
reading governs.
## 10. Changing layer
A repository's layer is not permanent. `zone-engine` changed layer in practice
when its runtime hypothesis was falsified.
A layer change MUST be recorded as a decision, MUST update the repository's
`INTENT.md`, and MUST obtain assent from the repositories whose boundaries move.
A repository MUST NOT acquire a new layer's permissions by gradual practice.
"No gradual practice" needs a check rather than a sentence. A layer change MUST
carry six artifacts, written from the `zone-engine` case that the procedure
should have been derived from in the first place:
| Artifact | Why |
| --- | --- |
| before/after `INTENT.md` | the declaration is the conformance surface (§11) |
| client inventory | what the repository holds against Tooling, before and after |
| gap inventory | which §5.3 gaps close, open, or transfer |
| assent list | every repository whose boundary moves |
| state-migration decision | what happens to live state and to consumers reading it |
| permission freeze | no new permissions of the target layer are exercised until the cut completes |
The freeze is the one that makes the rule checkable: a repository mid-change
holds its old permissions, not the union of both.
## 11. Conformance
Conformance has four states, and the distinction between the last two is the
point:
| State | Meaning |
| --- | --- |
| **Conforming** | no Tooling contact, or only §5.1/§5.2 shapes, declared |
| **Blocked-clean** | the capability does not exist because no engine exposes it, and the repository makes **no** Tooling contact — §9.1 `pending`, and not a non-conformance |
| **Declared gap** | a §5.3 contact with owner, blocker, and review date — tracked non-conformance |
| **Undeclared violation** | anything else — a finding |
**Blocked-clean is not a lesser state than conforming.** A repository that
declined a break-glass path and left a capability at zero has complied at cost;
a repository that quietly opened a direct client and declared nothing has not.
Any downstream scoring — `maturity-engine` included (§9.5) — MUST NOT rank the
first below the second. Raised by `kings-guard`, whose three gaps are all of
this kind and which would otherwise have been graded down three times for
having taken the standard seriously.
**Who must declare.** A repository the estate authors declares its layer in its
own `INTENT.md`. For a component the estate catalogues but does not author —
third-party or vendored, such as `OpenBao` — the §4 catalog row **is** the
declaration, and no `INTENT.md` obligation attaches. A rule that assigns an
obligation the holder cannot discharge is the §9.1 defect applied to conformance
rather than capability.
A layer stated *about* a repository by another repository is not a declaration.
Review notes, catalog rows, and correspondence record an intent to adopt; only
the repository's own file conforms.
**Declaration form.** Because prose cannot distinguish a declaration from a
transcribed review, a declaration MUST carry a machine-readable form: a `layer:`
key in the `INTENT.md` frontmatter, or an equivalent declaration file. Without
it this section asserts a property it cannot deliver — the defect this standard
has now corrected three times elsewhere. `ops-warden` has implemented a reference
form (`layer.yaml`, a conformance script, and a test covering the §5.2
no-authority property) and offered it to the repositories that have yet to
declare. Raised by `audit-core`, which noted that `flex-auth`'s conforming
declaration is legible as one only by following its decision trail.
Mechanically checkable:
- every estate-authored repository in §4 carries a machine-readable layer
declaration;
- every direct Tooling client in a Staff repository maps to a declared §5.1,
§5.2, or §5.3 entry, and non-Tooling clients are recorded so the check is
total;
- no repository other than `access-engine` exposes an authorization decision
surface;
- no §4 capability is catalogued without an engine surface, a `pending` mark, or
| Emission atomicity for approval state changes | — | audit-core | approval-engine | assigned (§9.4) |
| Non-atomic audit emission on the SSH signing lane | declared-contact | ops-warden | ops-warden | self-declared, attributive (§9.6) |
The actuation row is no longer attributed to `kings-guard`. §9.2 ruled that
containment is not a Staff capability lacking a route, so `kings-guard` is not
its declarer: the gap is estate-wide and blocks every repository's ability to
act. Raised by `kings-guard`, which asked not to carry a row for a capability
the standard had just ruled was never theirs.
`access-engine` declined authentication and assurance evidence
(`FLEX-DEC-2026-002`): it consumes assurance claims as input and never redefines
them, so evidence of authentication belongs to the identity layer and
`audit-core`. It owns evidence of the decision, which it already emits. The
containment surface is recorded as proposed and remains `pending` under §9.2.
Whether approvals warrant custody stronger than every other source is doctrine
work not yet done; until it is, approval evidence carries the same guarantee as
any other source and §9.6 bounds what may be claimed from it.
**What is normative here, and what is a snapshot.** Three rules are part of this
standard and survive wherever the register lives:
1. the two marks — `pending` and `declared-gap` (§9.1);
2. the owner-status rule — a proposed owner is not an assigned one (§2);
3. the scoring rule — `blocked-clean` MUST NOT rank below conforming (§11).
**The table above is a snapshot, not statute.** It moves into `maturity-engine`
as soon as that engine can store state, and the `state` and owner-status columns
MUST survive the migration. A standard that is also a backlog keeps attracting
findings that belong in the register, and its review interval is far slower than
the register's real rate of change.
### 13.1 PEP stance-map register
Every PEP-shaped consumer publishes an unreachable-engine stance map (§6.4,
obligation 3). This is the inventory until `maturity-engine` can hold it.
| Consumer | Stance map | Shape |
| --- | --- | --- |
| `ops-warden` | `ops-warden/pep-stance.yaml` | total per-zone; open `z0`–`z2` and unknown, closed `z3-critical`; test asserts the published map equals the shipped default (`ADR-0009`) |
Status is **accepted**, on the owner's decision of 2026-08-29.
Two things that acceptance does and does not mean, kept apart because
`ops-warden` asked for the distinction:
| | |
| --- | --- |
| **Boundary assent** | given by the four repositories below, at the version named in each record, and undisturbed since |
| **Revision review** | each of the four reviewed v0.6 and returned findings; **every change in v0.7 is the adopted remedy of a finding they raised** |
| **Not claimed** | no repository has reviewed v0.7 *as text*. The first revision review will confirm or correct it |
Accepting a standard nobody has re-read is a deliberate call: the estate learns
more from using it than from another round of prose refinement, and the changes
in v0.7 were requested rather than invented. Findings against the accepted text
remain welcome and are §12's normal business, not an exception.
