Knowledge IR
The eight typed primitives Pathrule compiles human knowledge into, what each one means, which of them are requirements rather than advice, and why the type has to survive delivery.
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.
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 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.