A rule is not a unit of knowledge. It is a **container** for one.

A single paragraph written by a person routinely says several different kinds of thing at once: that something must never happen, that something else has to be verified, and why the whole arrangement exists. Delivered as one blob, those collapse into "here is some text, please bear it in mind". Compiled into the Knowledge IR, they stay three different things with three different weights.

Eight primitives cover it.

## The eight

### CONSTRAINT
**What must not happen.**

The only primitive that can deny an alternative outright. It carries a scope, so it governs the paths it applies to and nothing else. This is the one the runtime can act on rather than merely mention.

### CHECK
**What must be verified.**

A verification that has to happen before the work counts as finished. A check carries an actor: some are for a machine to run, some are for a person to confirm, and they are not the same requirement.

### REMEDY
**What worked when this problem occurred.**

A condition and the corrective action that resolved it, carrying how strongly the source claimed success. Advisory: it tells an agent what has worked, not what it is forbidden to do.

### SELECTION
**What should be preferred under a condition.**

A preferred choice, with the alternatives the source actually named. It states the preference and never denies the alternative, which is why it is delivered as "the preferred choice is" and not as "do not use". Only a CONSTRAINT can say the second thing.

### PROCEDURE
**How something should be done.**

An ordered workflow. The steps stay in source order and in the source's own wording, because a reordered procedure is a different procedure.

### CONTEXT
**What is true and useful here.**

A descriptive fact that changes the right approach without forbidding anything. That the database behind this module is a read-only replica is a context fact, and it is why an agent should reach for the queue instead of an insert.

### RATIONALE
**Why something works this way.**

The reasoning behind a decision. It exists because an agent that knows the rule but not the reason is one helpful refactor away from undoing it.

### PRECEDENCE
**Which valid knowledge wins when knowledge conflicts.**

Two pieces of knowledge can both be correct and both apply. Precedence is the relationship that says which one governs, and it is scope-aware.

## Authority bands

The primitives are not equal, and the representation says so explicitly rather than relying on the order things appear in a prompt.

| Band | Primitives | Meaning |
| --- | --- | --- |
| `constraint` | CONSTRAINT | A hard requirement. Binds. |
| `check` | CHECK | A required verification. Binds. |
| `advisory` | REMEDY, SELECTION, PROCEDURE, RATIONALE | Guidance that improves the work. |
| `context` | CONTEXT | A fact that informs the work. |

Nothing in the delivery path is allowed to present a lower band as able to override a higher one. A remedy is never concatenated with equal weight after a hard rule; it renders into a clearly subordinate section, because a paragraph that reads at the same volume as a constraint is a paragraph that can be followed instead of it.

This is what "authority is encoded, not flattened" means in practice, and it is the difference between a typed representation and a pile of sentences.

## Documents and atoms

Your memories, rules and skills stay exactly what they are: the surface a person writes, edits and argues about. The Knowledge IR is their **compiled representation**, not a replacement for them.

```text
Rule document
    |
    +-- CONSTRAINT atom
    +-- CHECK atom
    +-- RATIONALE atom
```

One document can compile into several atoms of different kinds. That is normal, and it is the reason a container and a unit are not the same thing.

## Conflict

When two atoms that both apply disagree, the conflict is resolved before delivery rather than shipped to the agent to sort out. Where a PRECEDENCE relationship exists, the losing atom is withheld and the winner is delivered, so an agent is not handed two contradictory instructions and left to pick.

Where that resolution would lose something the source said, the [completeness gate](/docs/intelligence/safety) catches it and the delivery falls back to the source knowledge instead. A winner-only delivery of a memory that said "use this instead of that" teaches what to use and not what to avoid, which is exactly the failure worth refusing.