@nervur.org/genome 0.37.7 → 0.37.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/docs/guide.md CHANGED
@@ -1,409 +1,482 @@
1
1
  # Nervur's guide
2
2
 
3
- What Nervur is and how an organism works, whole, in a few pages: the model a person or a model holds before it touches
4
- anything, and the model an adopter builds from. The brain carries this guide as its own, so a model present at an
5
- organism reads it first. How to install, own and build on Nervur, each path with its commands and code, stands beside it
6
- in `authoring.md`, which travels with it in the genome's `docs/` and which the brain carries beside it, answered by
7
- `authoring`. What each version of Nervur changed, from 0.31.0, stands beside them in `changelog.md`. Where the exact
8
- detail matters, it is in `authoring.md`, in each faculty's own guide, and in what its node answers a **describe**, an
9
- ask naming no method: what it may be asked.
3
+ What Nervur is and how an organism works, in a few pages: the model to hold before touching anything, whether you are a
4
+ person, a model at an organism's console, or someone building on Nervur. The brain carries this guide, so a model
5
+ present at an organism can read it first. Beside it, in the genome's `docs/`:
6
+
7
+ - `authoring.md` says how to install, own and build on Nervur, each path with its commands and code; the brain answers
8
+ it as `authoring`.
9
+ - `changelog.md` says what each version changed, from 0.37.1, the first published.
10
+
11
+ The exact detail of a node is in what it answers a **describe**, an ask that names no method: what it may be asked. A
12
+ faculty's own guide, in its blueprint, says how it is run and used. The words this guide defines are listed at its end.
10
13
 
11
14
  ## The bet
12
15
 
13
- Software as a graph, never accounts. Every person, group and agent is an **organism** on a device of its own, and
14
- organisms ask each other over **Quo**, never through a server they share. A shop keeps what it knows of its customer in
15
- its own organism; the person keeps the rest in their home. Nervur grows by being many small organisms on the devices
16
- that already exist, never by one growing big.
16
+ Software as a graph of beings, never as accounts on someone's server. Every person, group and agent is an **organism**
17
+ on a device of its own, and organisms ask each other over **Quo**, Nervur's protocol between organisms, never through
18
+ a server they share. A shop keeps what it knows of its customer in its own organism; the person keeps the rest in their
19
+ home, their own organism. Nervur grows by being many small organisms on devices that already exist, never by one
20
+ growing big.
21
+
22
+ What is scarce is trust, not code. A shape is worth what it makes certain: who may ask whom, what ran, and what it
23
+ changed. So the parts are few: the organism, the relation between two of them, the ask, the letter and the owner.
17
24
 
18
- Trust is what is scarce, never code: a shape is worth what it makes certain, who may ask whom, what ran and what it
19
- changed. The primitives are few: the organism, the relation, the ask, the letter and the owner.
25
+ The **genome**, Nervur's kernel, is to an organism what Linux is to a machine: small, slow to change, built for
26
+ decades, with no opinion of what is built on it. **The owner is root.** Code starts with nothing, and an owner can give
27
+ it everything: code gains power by the wires and organs an owner gives it, never by escaping the cage it runs in.
20
28
 
21
- The genome is a kernel, as Linux is: small, slow to change, built for decades, with no opinion of what stands on it, and
22
- **the owner is root**. Code starts with nothing, and an owner can give it everything: a faculty's power comes by wires
23
- and organs, never by opening the cage. A **wall** stands only where it protects someone other than the owner, or where a
24
- promise cannot be proven without it, as purity, closed cells, keys never exchanged and an ask ending once. Every other
25
- limit is a **default** an owner can change, and one no owner's word can move is a gap. So of any limit, ask who it
26
- limits, and build powerful things on Nervur: what people do with it is theirs.
29
+ A limit in Nervur is one of two kinds. A **wall** stands only where it protects someone other than the owner, or where a
30
+ promise could not be proven without it: code that runs pure, memory each piece of code keeps closed, keys never handed
31
+ over, an ask that ends exactly once. Every other limit is a **default**, which an owner can change; a limit no owner can
32
+ move that is not a wall is a fault in Nervur. So of any limit, ask whom it limits. Build powerful things: what people do
33
+ with Nervur is theirs.
27
34
 
28
35
  ## The organism
29
36
 
30
- An organism lives on one **device**, the machine, in an account of its own there: an account of an operating system, one
31
- site of a browser, a phone's app or an edge's durable object. It is sealed. It has two doors and no third: the **ear**,
32
- where every being enters over Quo, and the installer's **door**, where the device reaches it (install, boot, update,
33
- wipe). Everything else that touches the world or the host is an **organ**.
37
+ An organism lives on one **device**, in an account of its own there: an account of an operating system, one site in a
38
+ browser, a phone's app, or an edge's durable object. It is sealed, with two doors and no third:
39
+
40
+ - **The ear**, where every other being enters, over Quo.
41
+ - **The door**, where the device reaches it through its installer: install, boot, update, wipe.
42
+
43
+ Everything else that touches the world or the host is an **organ**, a driver.
34
44
 
35
- A device gives it two **zones**:
45
+ A device gives an organism two **zones**:
36
46
 
37
- - **The self**, the organism's own account: `key` (the boot key), `store` (primordial memory, encrypted), `cage` (runs
38
- every lobe's ask, keeps time) and presence (the console, the screen). The self keeps.
39
- - **The body**, the work account: `shell`, `disk`, `network` and every repo's organ. The self starts programs as the
40
- body, never the other way, so nothing the body runs reads the key or the memory. The body forgets: a backup carries
41
- the self alone, and what the body held comes back from the world. A backup is an older life, of which a lobe is told
42
- first; what a damaged store still opens a salvage reads at the door, with no boot; a move, sealed to one device, is
43
- the same life elsewhere, and the copy it left stops; a rekey is a move onto itself, a new data key that costs no
44
- relation, where a rewrap moves the boot key alone. Who an organism is stands apart from where it is: an owner names
45
- the addresses it is reached at, ahead of a move.
47
+ - **The self** is the organism's own account. It holds `key` (the boot key, which opens everything else), `store` (the
48
+ organism's memory, encrypted), `cage` (which runs code and keeps time) and presence (the console and the screen). The
49
+ self keeps what it holds.
50
+ - **The body** is a second account, for work: `shell` runs programs, `disk` keeps files, `network` reaches the world,
51
+ and each organ built from a repo runs there. The self starts programs as the body, never the other way round, so
52
+ nothing the body runs can read the key or the memory. The body forgets: a backup carries the self alone, and what the
53
+ body held is fetched again from the world.
46
54
 
47
55
  A host has a body where it has `shell` and `disk`. A server, a desktop, a Pi and a NAS have one; a browser, a phone's
48
56
  app and an edge do not.
49
57
 
58
+ An organism's life can change place without changing who it is:
59
+
60
+ - **A backup** is an older life. Restored, the organism wakes as it was then, and each lobe is told so first.
61
+ - **A salvage** reads what a damaged store still opens, at the door, without booting it.
62
+ - **A move** carries the organism, sealed to one target device, to be the same life there; the copy it left stops.
63
+ - **A rekey** is a move onto itself: a new key for its memory that costs no relation. A **rewrap** changes only the
64
+ boot key that guards it.
65
+
66
+ Who an organism is stands apart from where it is reached: an owner names the addresses it answers at, ahead of a move.
67
+
50
68
  ## Nodes and the graph
51
69
 
52
- Everything in an organism is a **node**, under an ID, with one **termination** where every ask to it arrives:
70
+ Everything in an organism is a **node**, under an ID, with one **termination**, the single place every ask to it
71
+ arrives. A node is one of three kinds:
53
72
 
54
- - **An organ**: a driver. Its **graph half** is its **blueprint**, what a node declares of itself, its name, its version
55
- and its methods, and its **reach**, what of its host it touches, both held by the brain; its **host half** is code
56
- running on the device. It holds no cells and declares no placeholders.
57
- - **A lobe**: an instance of a **faculty**, pure code. It lives only inside an ask and keeps nothing between asks but
58
- its **cells**, its own partition of memory. It keeps its ID, wires, relations and cells across its faculty's versions.
59
- - **A far organism**: stands for one relation over Quo, one way, and nothing more.
73
+ - **An organ**, a driver. Its graph half is its **blueprint**, what it declares of itself (its name, its version, its
74
+ methods), and its **reach**, what of its host it may touch; the brain holds both. Its **host half** is code running
75
+ on the device. An organ holds no cells and declares no placeholders.
76
+ - **A lobe**, one instance of a **faculty**, which is pure code. A lobe lives only while it answers an ask, and keeps
77
+ nothing between asks but its **cells**, its own private part of the organism's memory. It keeps its ID, its wires,
78
+ its relations and its cells across new versions of its faculty.
79
+ - **A far organism**, which stands in the graph for one relation over Quo, in one direction, and nothing more.
60
80
 
61
81
  The **core** is there from the first install and never torn down: the organs `key`, `store`, `cage` and `network`, and
62
82
  the lobes `brain`, `scheduler`, `ear`, `mouth` and `library`. Everything else is **periphery**.
63
83
 
64
- Nodes meet only through **wires**. A node declares **placeholders**, its needs; a wire joins one placeholder to one
65
- termination, one way. The **brain** alone writes wiring and checks only that the blueprint name a placeholder expects is
66
- the one it gets: a wire says who reaches whom, and code reaches only what its wires give it. A declaration wires
67
- nothing, whatever ID it carries: a lobe starts with its `cells` and `nerves`, and every other wire is named, in the
68
- `wiring` given at its creation or by an order, and what stands unwired an owner sees in `state`. Connection comes only
69
- from connection: a lobe orders a wire by its `nerves`, its placeholders with their wires and statuses, only to its own
70
- children and to who asked it, and every other wire is an owner's word, through `brain`, which an owner can give a lobe.
71
- A lobe that declares a placeholder named after an organ is that organ's **skin lobe**: the only way an organ meets the
72
- graph. A lobe may raise **children** through its `nerves`; a child reaches nothing its parent does not, and power only
84
+ Nodes meet only through **wires**. A node declares **placeholders**, the things it needs, each by name; a wire joins one
85
+ placeholder to one termination, one way. The **brain** alone writes the wiring, and checks only that the node a
86
+ placeholder receives has the blueprint name it expects. A wire says who reaches whom, and code reaches only what its
87
+ wires give it. Declaring a placeholder wires nothing: a new lobe starts with two wires, its `cells` and its `nerves`
88
+ (its own handle on its wiring), and every other wire is named when it is created or ordered later. What stands unwired
89
+ an owner sees in the brain's `state`.
90
+
91
+ Connection comes only from connection. A lobe orders wires through its `nerves`, and only for its own children and for
92
+ whoever asked it; every other wire is an owner's word, given through the brain, and an owner can wire a lobe to the
93
+ brain to give it that power. A lobe may raise **children**; a child reaches nothing its parent does not, so power only
73
94
  narrows down the line.
74
95
 
96
+ A lobe that declares a placeholder named after an organ is that organ's **skin lobe**: the only way an organ meets the
97
+ rest of the graph.
98
+
75
99
  ## The ask
76
100
 
77
- Nodes meet only through the **ask**: a method, its args (data) and a timeout, sent over a placeholder. The brain carries
78
- every ask and stamps it with the asker's ID, the time, a fresh 32-byte seed and the lobe memory. Every ask ends exactly
79
- once, with `{result}` or `{error: {code, message}}`.
101
+ Nodes meet only through the **ask**: a method, its arguments (plain data) and a timeout, sent over a placeholder. The
102
+ brain carries every ask and stamps it with who asked, the time, a fresh 32-byte random seed and the lobe's memory.
103
+ Every ask ends exactly once, with `{result}` or with `{error: {code, message}}`.
80
104
 
81
- - **Whole or nothing.** A lobe's writes take effect in one batch when it answers. If the brain answers in its place
82
- (timeout, fault, busy), nothing it wrote remains. An answer reaches its asker only once its batch is on disk, so an
83
- answer always means it happened. What a lobe already sent to the world stays sent.
84
- - **From far.** Only a far side's own answer says what happened there. Any other exit may have run, and where no reply
85
- came may still run until the next ask on that relation is answered; `repeated` says the door took it, so it will not
86
- run again. An ask that must not run twice carries a key of its asker's.
105
+ - **Whole or nothing.** A lobe's writes take effect together, in one batch, when it answers. If the brain answers in
106
+ its place (a timeout, a fault, too busy), nothing it wrote remains. An answer reaches its asker only once its batch
107
+ is on disk, so an answer always means it happened. What a lobe already sent out to the world stays sent.
108
+ - **From far.** Only the far side's own answer says what happened there. Any other ending may still have run, and
109
+ where no reply came it may run until the next ask on that relation is answered. The error `repeated` means the far
110
+ door already took that ask, so it will not run again. An ask that must not run twice carries a key of its asker's.
87
111
  - **Reading and writing.** A reading method writes nothing and runs beside others; a writing method runs alone.
88
- - **Signal or letter.** A **signal** lives in memory and is lost in a crash. A **letter** is kept in primordial memory
89
- until the lobe takes it, exactly once. An ask whose loss matters is a letter.
90
- - **Durable asks** go to organs: the brain sends them again whenever the organ reconnects, as "keep listening".
91
- - **Time.** A **budget** bounds the real time a run works, watched from outside it; a **timeout** bounds waiting. Past
92
- either the run is cut, nothing it wrote lands, and the asker hears `timeout`. An asker names a timeout only where an
93
- answer is worth no longer; otherwise it waits as long as it may, and an inner ask never outlives the outer one. A run
94
- that must pause, before a retry or while it holds its lobe, asks its `nerves` `wait {ms}`, answered `null` once the
95
- span has passed, or `timeout` where its ask's time ends first; it waits as on any ask, spending no budget. Work
96
- longer than one ask answers at once and ends later, by an ask back or a **job**, which a node answers at once to an
97
- asker it cannot ask back, and which the asker gives back to ask how the work ended; what is long is cut into pieces
98
- judged by progress, never by one slow piece.
99
- - **Queues.** One queue per lobe, asks started in the order they arrive; each asker holds a share, and one over its
100
- share alone meets `busy`. No wait inside an organism closes a circle: a run waits on any one of the asks it has in
101
- flight, an ask queued waits on the runs ahead of it in its lobe, and a move of a version waits for the runs of its
102
- lobe. An ask, or a move, that could start only once a run ended that waits on it, its own run or another lobe's,
103
- through any number of lobes, queues or the brain, is answered `refused` at once instead of waiting; a run racing two
104
- asks is never refused for the one it may not need, and one awaiting both hears the one on the circle refused the
105
- moment the other answers. A
106
- reading ask that starts beside other readers waits on none of them. Across organisms nothing tells such a circle, so
107
- it ends at its timeouts.
108
- - **Status.** Every termination is not ready, connected, unavailable or far, and status flows into each placeholder
109
- wired to it.
112
+ - **Signal or letter.** A **signal** lives in memory and is lost in a crash. A **letter** is kept in the organism's
113
+ memory until its lobe takes it, exactly once. An ask whose loss matters is a letter.
114
+ - **Durable asks** go to organs: the brain sends them again each time the organ reconnects, as "keep listening".
115
+ - **Time.** A **budget** bounds the real time a run may work, watched from outside it; a **timeout** bounds how long an
116
+ asker waits. Past either, the run is cut, nothing it wrote lands, and the asker hears `timeout`. Name a timeout only
117
+ where an answer is worth nothing after it; otherwise an ask waits as long as it may, and an inner ask never outlives
118
+ the outer one. A run that must pause, before a retry or while it holds its lobe, asks its `nerves` `wait {ms}`, which
119
+ answers `null` once the span has passed, or `timeout` if its own ask's time ends first; waiting spends no budget.
120
+ - **Long work** answers at once and finishes later, either by asking back or as a **job**: a node that cannot ask its
121
+ asker back answers a job at once, and the asker hands it back to ask how the work ended. Long work is cut into pieces
122
+ and judged by progress, never by one slow piece.
123
+ - **Queues.** Each lobe has one queue, and asks start in the order they arrive. Each asker holds a share of it, and an
124
+ asker past its share alone hears `busy`.
125
+ - **No circle of waiting.** An ask that could only start once a run ends that is itself waiting on it, through any
126
+ number of lobes, queues or the brain, is answered `refused` at once instead of waiting forever. The same holds for a
127
+ move of a lobe's version, which waits for that lobe's runs. A run racing two asks is never refused for the one it may
128
+ not need; one waiting on both hears the circling one refused the moment the other answers. A reading ask that starts
129
+ beside other readers waits on none of them. Between organisms nothing can see such a circle, so it ends at its
130
+ timeouts.
131
+ - **Status.** Every termination is not ready, connected, unavailable or far, and its status flows into each
132
+ placeholder wired to it.
110
133
 
111
134
  ## Ownership
112
135
 
113
- There are no roles in the brain. Whoever asks the brain is an **owner**: whoever is **present** at the device (the
114
- console or the screen the configuration names present), whoever holds a relation the brain emitted, from afar, and a
115
- lobe an owner wired to `brain`, which holds what that owner gave it. Every other being reaches only the lobe that
116
- invited it. A relation to the brain is owning; a relation to a lobe is belonging, buying or following, and roles live in
117
- lobes.
118
-
119
- - **Presence wins over the graph and never over the account**. The present lobes, the console's and the screen's, are
120
- one person and hold their relations alike. A model at the console is present as a person is, and holds no more, and
121
- moves no skin of presence. It reaches the organism by `nervur mcp`, the console's MCP form: a tool for each method of
122
- each node the console holds, its args, result and kind from the method's blueprint, and the portrait at connect. A
123
- method marked irreversible, one that tears down, drops or deletes, is hinted destructive and made as the console makes
124
- it: who must approve what is the organism's to say, and its **harness**'s to ask, the files an agent works by, its
125
- instructions, hooks, settings and skills. A job is followed as a task.
126
- - **Another account owns nothing** without the boot key, nor does the device while the organism is down; whoever can
136
+ The brain has no roles. Whoever may ask the brain is an **owner**:
137
+
138
+ - whoever is **present** at the device, at the console or at the screen the configuration names present;
139
+ - whoever holds, from afar, a relation the brain itself gave out;
140
+ - a lobe an owner wired to the brain, holding what that owner gave it.
141
+
142
+ Every other being reaches only the lobe that invited it. A relation to the brain is ownership; a relation to a lobe is
143
+ belonging, buying, following, whatever that lobe makes it. Roles live in lobes.
144
+
145
+ - **Presence wins over the graph, never over the account.** The present lobes, the console's and the screen's, are one
146
+ person and hold their relations alike.
147
+ - **A model at the console** is present as a person is, holds no more, and never changes the skins of presence. It
148
+ reaches the organism by `nervur mcp`, the console as an MCP server: a tool for each method of each node the console
149
+ holds, with its arguments, result and kind from the method's blueprint, and the organism's portrait when it connects.
150
+ A method marked irreversible, one that tears down, drops or deletes, is hinted destructive and made just as the
151
+ console makes it: who must approve what is the organism's to say and the **harness**'s to ask, the files an agent
152
+ works by (its instructions, hooks, settings and skills). A job is followed as a task.
153
+ - **Another account owns nothing** without the boot key, nor does the device while the organism is down. Whoever can
127
154
  become every account of a machine holds every organism on it.
128
- - **The anchor** is the owner no other owner drops: the present lobe, or the first invitation's knock where there is
129
- none. It leaves only by passing on, and the person present may take a far anchor back by dropping it.
130
- - An owner reaches a lobe through the brain's `ask`; the lobe sees `brain` as its asker. Among the brain's methods:
131
- create and move lobes, add organs, wire, invite owners, accept standings, back up, upgrade, read `state`.
132
- - **A secret is held from strangers and siblings, never from owners.** A lobe's cells are a wall against other lobes and
133
- the far side, and a default against accident for owners: `state` shows none, so a secret stays out of everyday tools
134
- and a harness's model, as `ps` prints no process's memory. An owner reads all a lobe holds by a deliberate act that
135
- shows, a move to a faculty that tells, or a backup.
155
+ - **The anchor** is the one owner no other owner can drop: the present lobe, or, where there is none, whoever took the
156
+ organism's first invitation. It leaves only by passing the anchor on, and the person present can take a far anchor
157
+ back by dropping it.
158
+ - An owner reaches a lobe through the brain's `ask`, and the lobe sees `brain` as its asker. Through the brain an owner
159
+ creates and moves lobes, adds organs, wires, invites other owners, takes relations, backs up, upgrades and reads
160
+ `state`.
161
+ - **A secret is kept from strangers and siblings, never from owners.** A lobe's cells are a wall against other lobes
162
+ and against the far side, and only a default against accident for owners: `state` shows no cell, so a secret stays
163
+ out of everyday tools and out of a model's sight, as `ps` prints no process's memory. An owner reads all a lobe holds
164
+ by a deliberate act that shows: moving it to a faculty that tells, or taking a backup.
136
165
  - The brain counts and enforces, and never judges. It keeps the organism's **character**, `{name, voice, goals}`, and
137
166
  answers every owner its **portrait**: this guide, the character, each lobe with its guide, and the first page of its
138
167
  `state`.
139
168
 
140
- ## Beings and Quo
141
-
142
- Quo is its own spec: asks and replies as data, never code. An organism has a public **ward** (its name) and a fresh ward
143
- for each relation it opens to a stranger, so no two strangers can link it by its name, or, where a **relay** is wired, a
144
- lobe that gives each ward an address of its own, by where it is reached. What a wire shows, and where it asks from, is
145
- the network's and the owner's to cover.
146
-
147
- - A lobe **invites** through the ear, with **spans**, how long the invitation waits and how long the relation lives, and
148
- a **note** (free JSON on what the relation is for, never sent). The invitation's text, its spans and what it says
149
- among it, is signed whole by the ward drawn for it, so no one who carries it changes a word unseen; the signature
150
- says the text is the ward's own, never whose the ward is. The other organism **accepts** through its mouth; its
151
- first **knock** that announces a key binds the relation. A relation runs one way: the side that accepted asks, the
152
- side that invited answers.
153
- - A **link** is an invitation kept behind a one-time reference: short enough for a QR, it names the ward drawn for it
154
- and where that ward is reached, so a link names no one, and it is redeemed once on that ward's **zero head**, Quo's
155
- name for where whoever holds no relation asks. Before the yes its holder reads its **offer** there, spending nothing:
156
- what the inviter says with it, how long it waits and how long the relation lives. A link on a domain names the public
157
- ward, where a name is meant to be known.
158
- - An **end** is a relation as one side holds it, in Quo's words: the **occupant**, the end a lobe gave, which answers,
159
- and the **standing**, the end the organism holds, granted to the lobes the owner wires, which ask. The brain alone
160
- keeps ends and their notes; a lobe keeps no copy. An owner hands a standing to another of its organisms, the place it
161
- asks told nothing: there `taking` draws a key, here `cede` forgets the standing and answers it sealed to that key, and
162
- there `take` keeps it. Its addresses, its keys and the count of its numbers go on as from one device, so nothing the
163
- place receives tells it the standing moved. An app or a window of the owner's asks it.
164
- - The ear opens each box with `key` and never decides; a stranger hears silence, and it keeps no place while a node
165
- answers. An ask over a relation runs at most once, and one taken already hears `repeated`; a stranger's ask on the
166
- zero head changes nothing by default, since nothing tells its copy from a second ask, so a change goes over a
167
- relation. A relation ends from either side, never half. A **box**, one ask or one reply, sealed, is at most 1 MiB;
168
- more crosses in pieces.
169
- - A lobe never sees a ward or a key, only an ID. At most one lobe is the ear's `front`, answering strangers the
170
- organism's public part alike, what it may be asked among it.
171
- - An organism that cannot be dialed holds a **line** to one always on, and asks travel both ways over it.
172
-
173
- ## Code: faculties, the library, versions
174
-
175
- A **faculty** is one module the cage runs, in the engine's language, JavaScript, extending `Faculty`, its static
176
- `blueprint` naming its name, version and methods. Its source is one string named by its SHA-256, the **digest**, so the
177
- version is inside the digest. Each ask runs on a fresh instance in a cage with no clock, no randomness, no I/O: chance
178
- comes from the stamp's seed, time from the stamp, the world only by asks. A faculty proves itself by **evidence**:
179
- pieces of its world replayed exactly. Code is logic and data is cells.
180
-
181
- The **library** keeps every code by its digest and never runs one. Code enters by four **roads** alone, always taken on
182
- an owner's word, never given:
169
+ ## Relations and Quo
170
+
171
+ Quo carries asks and replies between organisms, as data and never as code; it has its own specification.
172
+
173
+ **Wards.** An organism's public identity is its **ward**, the name others know it by. For each relation it opens to a
174
+ stranger it draws a fresh ward, so no two strangers can tell they are dealing with the same organism. Where a **relay**
175
+ is wired, a lobe that gives each ward an address of its own, they cannot tell it by where it is reached either. What a
176
+ wire on the network shows, and where an organism asks from, is the network's and the owner's to cover.
177
+
178
+ **Inviting and accepting.** A relation always runs one way: the side that accepted asks, the side that invited answers.
179
+
180
+ - A lobe **invites** through the ear, with **spans**, how long the invitation waits and how long the relation lives,
181
+ and a **note**, free JSON saying what the relation is for, kept at home and never sent.
182
+ - The invitation's whole text, spans and what it says, is signed by the ward drawn for it, so no one who carries it can
183
+ change a word unseen. The signature says the text is the ward's own, never whose the ward is.
184
+ - The other organism **accepts** through its mouth; its first **knock**, the first ask that announces its key, binds the
185
+ relation.
186
+
187
+ **Links.** A **link** is an invitation kept behind a one-time reference, short enough for a QR code. It names the ward
188
+ drawn for it and where that ward is reached, so a link names no one. It is redeemed once at that ward's **zero head**,
189
+ where a being that holds no relation yet may ask. Before saying yes, whoever holds a link reads its **offer** there,
190
+ spending nothing: what the inviter says, how long it waits and how long the relation would live. A link on a domain
191
+ names the public ward, where a name is meant to be known.
192
+
193
+ **The two ends.** Each side holds its own end of a relation:
194
+
195
+ - the **occupant**, the end a lobe gave out, which answers;
196
+ - the **standing**, the end the organism holds after accepting, which the owner wires to the lobes that may ask with it.
197
+
198
+ The brain alone keeps ends and their notes; a lobe keeps no copy. An owner can **hand** a standing to another organism
199
+ of theirs without the place it asks being told: there `taking` draws a key, here `cede` forgets the standing and
200
+ answers it sealed to that key, and there `take` keeps it. Its addresses, keys and the numbering of its asks go on as
201
+ if from one device, so nothing the place receives tells it the standing moved. An app or a window of the owner's asks
202
+ it.
203
+
204
+ **At the ear.** The ear opens each sealed box with `key` and never decides anything; a stranger hears silence, and the
205
+ ear holds no place for an answer while a node works.
206
+
207
+ - An ask over a relation runs at most once; one taken already hears `repeated`.
208
+ - A stranger's ask at the zero head changes nothing by default, since nothing can tell its copy from a second ask; a
209
+ change goes over a relation.
210
+ - A relation ends from either side, never half.
211
+ - A **box**, one ask or one reply, sealed, is at most 1 MiB; more crosses in pieces.
212
+ - A lobe never sees a ward or a key, only an ID. At most one lobe is the ear's `front`, which answers strangers for the
213
+ organism's public part, what it may be asked among it.
214
+ - An organism that cannot be dialed holds a **line** to one that is always on, and asks travel both ways over it.
215
+
216
+ ## Code: faculties, the library and versions
217
+
218
+ A **faculty** is one JavaScript module the cage runs, a class extending `Faculty` whose static `blueprint` names its
219
+ name, version and methods. Its source is one string named by its SHA-256 hash, its **digest**, so the version is inside
220
+ the digest. Each ask runs on a fresh instance, in a cage with no clock, no randomness and no I/O: chance comes from the
221
+ stamp's seed, time from the stamp, and the world only by asks. Code is logic; data is cells. A faculty proves itself by
222
+ **evidence**: pieces of its world, replayed exactly.
223
+
224
+ The **library** keeps every faculty by its digest and never runs one. Code enters it by four **roads** alone, each
225
+ taken on an owner's word, never pushed in:
183
226
 
184
227
  1. **The genome's**: the default faculties, at install and upgrade.
185
228
  2. **The installer's**: the host's organs and the faculties it ships, from its **channel**, the host's own way of
186
- shipping code: the floor's among them, the console's and the screen's skins and what it gives them by name, the
187
- floor's look for the window, and the repo faculties, the jailer and the repo lobe.
188
- 3. **A source's**: everything else, from any lobe an owner names that answers `get` and `told`. A repo lobe is Nervur's
189
- own: it tells a version once a tagged commit holds it, and its `versions.json` names each version's digest. The
190
- library asks the source (local, or far over a library's standing) for the text, hashes it itself and keeps it only if
191
- the digest matches and the name and version were never kept under another digest, an owner's `second` taking another
192
- author's as a name of its own, by its source. A faculty a far place offers is held as given by that place, for its
193
- asker to create sealed.
194
- 4. **An owner's hand**: a faculty's text an owner's `add` carries itself, kept under `hand@<version>`, by the same
229
+ shipping code. Among them are the floor's: the skins of the console and the screen, the plain look for the window,
230
+ and the repo faculties.
231
+ 3. **A source's**: everything else, from any lobe an owner names that answers `get` and `told`, here or far over a
232
+ library's standing. A repo lobe is such a source: it tells a version once a tagged commit holds it, and its
233
+ `versions.json` names each version's digest. The library hashes the text itself and keeps it only if the digest
234
+ matches, and only if that name and version were never kept under another digest; an owner's `second` takes another
235
+ author's faculty under a name of the owner's own. A faculty a far place offers is kept as given by that place, for
236
+ its asker to create sealed.
237
+ 4. **An owner's hand**: a faculty's text an owner's `add` carries itself, kept as `hand@<version>`, under the same
195
238
  walls. It is how a bare host gets its first source.
196
239
 
197
- A faculty from a source carries its evidence as an **asset**, a file it carries as part of its version, data that runs
198
- nothing, so the proof outlives its repo; one with none stays allowed, shown as unproven. What the genome or the
199
- installer lays is proven by the release that ships it.
200
-
201
- An owner **creates** a lobe on a kept digest, naming its wires, and **moves** it to another version in place, or to
202
- another faculty's; the move asks the new version `migrate` once, keeps the old one if it fails, and leaves what the new
203
- version declares anew unwired for the owner to wire. A landed move keeps one step back until the owner settles it, goes
204
- back or moves again, and no size of a lobe stops it. The library keeps no old version no lobe or step names, but one an
205
- owner spares: each boot, and each lobe leaving a version, sweeps them, so a version an owner adds stays for a lobe to
206
- move to, an older one too. A version removed keeps its digest, so no other text ever takes it. Lobes that decide who
207
- someone is or what code is (brain, library, ear, mouth) are **immutable**: they move only with the genome. A present
208
- lobe decides no one: the person present moves the console's or the screen's skin to any faculty by `version`, never a
209
- model or a far owner; the choice is the home's, so an upgrade moves only a skin no one chose, and
210
- `nervur start --floor`, at the device, lays again the one its **port** gave, the installer for its kind of host, its
211
- design with it, so no skin and no design holds anyone captive.
240
+ A faculty from a source carries its evidence as an **asset**, a file kept with its version, data that runs nothing, so
241
+ the proof outlives its repo. One with no evidence is still allowed, shown as unproven. What the genome or an installer
242
+ lays is proven by the release that ships it.
243
+
244
+ **Creating and moving.** An owner **creates** a lobe on a kept digest, naming its wires, and **moves** it to another
245
+ version in place, or to another faculty. The move asks the new version's `migrate` once, keeps the old version if it
246
+ fails, and leaves unwired what the new version newly declares, for the owner to wire. A landed move keeps one step back
247
+ until the owner settles it, goes back or moves again, and no size of a lobe stops it.
248
+
249
+ The library keeps no old version that no lobe or step names, unless an owner spares it: each boot, and each lobe leaving
250
+ a version, sweeps them, so a version an owner adds stays for a lobe to move to, an older one too. A removed version keeps
251
+ its digest, so no other text can ever take it.
252
+
253
+ **What never moves alone.** Lobes that decide who someone is or what code is, `brain`, `library`, `ear` and `mouth`,
254
+ are **immutable**: they move only with the genome. A present lobe decides no one, so the person present, never a model
255
+ or a far owner, moves the console's or the screen's skin to any faculty by `version`. The choice is the home's: an
256
+ upgrade moves only a skin no one chose, and `nervur start --floor`, at the device, lays again the skin its **port**, the
257
+ installer for its kind of host, gave, its design with it. No skin and no design can hold anyone captive.
212
258
 
213
259
  ## Organs
214
260
 
215
- An organ is `{blueprint, reach, half, code?}`. Its host half is a WebAssembly **component** given exactly the imports
216
- its reach names, or a **native half** built for one host. No host half's program ever crosses Quo: a **repo's organ**
217
- comes only from a repo lobe of the organism's own, pulled and built in its body through `shell`, then added by an
218
- owner's `addOrgan` under a fixed ID. A host without a body takes faculties only, and organs from its installer and the
219
- halves its embedder's build brings, a site's, an app's or a pilot's, each admitted by `addOrgan`. A host half that fails
220
- shows unavailable and restarts alone. An organ's judgment lives in its skin lobes, which hold its secrets and settings.
221
- Logic lives in lobes, drivers in organs; a new use case is a new plain lobe composing skin lobes, seldom a new organ.
261
+ An organ is `{blueprint, reach, half, code?}`. Its host half is a WebAssembly **component** given exactly the imports its
262
+ reach names, or a **native half** built for one host. No host half's program ever crosses Quo:
263
+
264
+ - On a host with a body, an organ from a repo comes only from a repo lobe of the organism's own, pulled and built in
265
+ its body through `shell`, then added by an owner's `addOrgan` under a fixed ID.
266
+ - A host without a body takes faculties only, plus the organs from its installer and the halves its embedder's build
267
+ brings, a site's, an app's or a pilot's, each admitted by `addOrgan`.
268
+
269
+ A host half that fails shows unavailable and restarts on its own. An organ's judgment lives in its skin lobes, which hold
270
+ its secrets and settings: logic lives in lobes, drivers in organs, and a new use is a new plain lobe composing skin
271
+ lobes, seldom a new organ.
222
272
 
223
273
  The organs Nervur holds: `network` carries Quo and the web; the console asks its present lobe `line` with each line
224
274
  typed; `shell` runs programs as the body; `disk` keeps files under one folder.
225
275
 
226
276
  ## Building well
227
277
 
228
- What Nervur leaves to whoever builds, as a builder holds it; nothing here binds an organism.
278
+ What Nervur leaves to whoever builds; nothing here binds an organism.
229
279
 
230
- - **Code is logic, data is cells.** A faculty is one module, written in any language that yields it and bundled by its
280
+ - **Code is logic, data is cells.** A faculty is one module, written in any language that yields one and bundled by its
231
281
  repo's build. A table, a content or a model it serves is laid in its lobe's cells, by `migrate` or by asks, never in
232
- its source, so a version carries only what changed of the logic.
233
- - **Logic in lobes, drivers in organs.** Whatever can be decided is decided in a lobe over an organ; heavy computation,
234
- running a model or transcoding media, is a driver's work and stands in an organ, its host half native code of its
235
- owner's where it must be, as a driver on a Pi that moves a robot, its source in its owner's repo, built on the Pi, its
236
- reach the motor's device. The shape that repeats is a plain lobe composing skin lobes: the skin lobes hold what
237
- reaches the world and its secrets, and the plain lobe holds the use case, reaching the world only by asking them and
238
- beings.
239
- - **Signal or letter.** An ask whose loss matters is a letter; one asked again anyway is a signal. An ask back, a letter
240
- taken again or a durable ask sent again is a cue to read cells, never proof that something happened once: a node that
241
- owes one and meets `unavailable` drops it, the asker's cells staying the truth, or posts it as a letter that waits for
242
- the asker's switch on.
282
+ its source, so a new version carries only what changed of the logic.
283
+ - **Logic in lobes, drivers in organs.** Whatever can be decided is decided in a lobe over an organ. Heavy computation,
284
+ running a model or transcoding media, is a driver's work and stands in an organ, its host half native code where it
285
+ must be: a driver on a Pi that moves a robot has its source in its owner's repo, is built on the Pi, and reaches the
286
+ motor's device. The shape that repeats is a plain lobe composing skin lobes: the skin lobes hold what reaches the
287
+ world and its secrets, and the plain lobe holds the use, reaching the world only by asking them and other beings.
288
+ - **Signal or letter.** An ask whose loss matters is a letter; one that will be asked again anyway is a signal. An ask
289
+ back, a letter taken again or a durable ask sent again is a cue to read cells, never proof that something happened
290
+ once: a node that owes one and meets `unavailable` drops it, the asker's cells staying the truth, or posts it as a
291
+ letter that waits for the asker to come back.
243
292
  - **Once, far.** What an ask sent far did stays done, so an ask that must not run twice, a payment, carries a key of its
244
- asker's, which the far lobe keeps and answers once. On a window of one, an asker who must know an earlier box will not
293
+ asker's, which the far lobe keeps and answers once. On a window of one, an asker that must know an earlier box will not
245
294
  still run asks once more. A lobe working step by step names its next step in its answer.
246
295
  - **Choosing by the nerves.** A lobe reads its statuses and answers `unavailable`, takes another path, or orders its
247
- wiring again; at `left` it forgets what it keeps of that far organism, as a token. Whoever knocks first holds the
248
- relation, so a note on an occupant is a belief rooted in the handing over. A lobe that needs more asks at once to one
249
- being has its organism hold more standings.
296
+ wiring again; at `left` it forgets what it keeps of that far organism, a token for example. Whoever knocks first holds
297
+ the relation, so a note on an occupant is a belief rooted in how the invitation was handed over. A lobe that needs
298
+ more asks at once to one being has its organism hold more standings.
250
299
  - **Skin lobes.** Every use of an organ is a skin lobe of its own: `network` has the ear, the mouth and the web's,
251
300
  `shell` the jailer and every lobe that runs programs. A skin lobe lets a secret reach its organ only as an ask's
252
- input, never in words the organ keeps. A lobe stands before an organ for other lobes only where they must share what
253
- it keeps, as one account's token, and is then their skin lobe's plain asker as any other. An organ's long work answers
254
- at once and asks its skin lobe back; a skin lobe serving another lobe asks it back in turn, by a letter where it must
255
- not be lost, and never asks its organ again from inside the organ's ask back, which waits on its answer: it keeps what
256
- follows in its cells and starts it by an alarm, which the scheduler keeps.
257
- - **Long work.** Work longer than one ask is made of pieces, each its own ask well within the longest timeout, and is
258
- judged by progress: a piece that times out is asked again, and the whole fails only once it moved not for the span it
259
- may stand still, never because one piece was slow.
260
- - **Two organisms nobody can dial** both hold lines to one always on, which passes each ask down the line that proved
261
- its ward and carries the reply back, unread. A relay, which gives a ward an address of its own, is a repo's, which the
262
- genome neither holds nor forbids.
301
+ input, never in words the organ keeps. A lobe stands in front of an organ for other lobes only where they must share
302
+ what it keeps, one account's token for example, and is then an ordinary asker of their skin lobe.
303
+ - **An organ's long work** answers at once and asks its skin lobe back. A skin lobe serving another lobe asks it back in
304
+ turn, by a letter where it must not be lost, and never asks its organ again from inside the organ's ask back, which
305
+ waits on its answer: it keeps what follows in its cells and starts it by an alarm, which the scheduler keeps.
306
+ - **Long work** is made of pieces, each its own ask well within the longest timeout, and judged by progress: a piece
307
+ that times out is asked again, and the whole fails only once it has not moved for the span it may stand still, never
308
+ because one piece was slow.
309
+ - **Two organisms nobody can dial** both hold lines to one that is always on, which passes each ask down the line that
310
+ proved its ward and carries the reply back, unread. A relay, which gives a ward an address of its own, is a repo's to
311
+ build; the genome neither holds nor forbids one.
263
312
  - **A builder delivers into its buyer's repo.** The buyer's repo lobe invites the builder with a writer's standing
264
- scoped to the folders it delivers, a note and a span; the builder's repo lobe pulls the scope, writes in what it
313
+ scoped to the folders it delivers, a note and a span. The builder's repo lobe pulls that scope, writes what it
265
314
  delivers and pushes, and the buyer's lobe guards it. The standing ends and the builder's lobe is torn down, so the
266
315
  builder keeps nothing of the buyer's, and the buyer keeps what was delivered. An update is a job again, on the buyer's
267
316
  word, and a version enters the buyer's library from the buyer's own repo lobe.
268
317
 
269
318
  ## Repos
270
319
 
271
- An adopter builds on Nervur changing nothing of it: it writes faculties and organs in its own repos, and its nodes act
272
- only through asks. What else it changes is its own. What travels as code stands in a **repo**. A repo is its lobes
273
- and its bytes, kept by the **repo faculties**, the floor's skins of `shell` and `disk`, in `@nervur.org/floor`:
320
+ You build on Nervur without changing anything of it: you write faculties and organs in repos of your own, and your
321
+ nodes act only through asks. What travels as code stands in a **repo**, kept by the **repo faculties**, the floor's
322
+ skins of `shell` and `disk`, in `@nervur.org/floor`:
274
323
 
275
- - **The jailer**, `nervur.repos`, one per organism with a body, laid on demand: it alone runs git, keeps each repo's
276
- bytes at `repos/<name>`, grants each folder to one repo lobe, and lends the genome at
277
- `repos/node_modules/@nervur.org/genome`, one folder up from every repo, at the version the organism runs; the genome
324
+ - **The jailer**, `nervur.repos`, one per organism with a body, laid when first wanted. It alone runs git, keeps each
325
+ repo's files at `repos/<name>`, grants each folder to one repo lobe, and lends the genome at
326
+ `repos/node_modules/@nervur.org/genome`, one folder up from every repo, at the version the organism runs. The genome
278
327
  carries this guide, `authoring.md` and `changelog.md` in its `docs/`.
279
- - **A repo lobe**, on `nervur.repo`, one per repo per organism: it commits, pulls and pushes git bundles over standings,
280
- and guards its own `main` by two checks, Nervur's check of the parts and the repo's own `conform`, the choices its
281
- owners hold it to, as the lobe's owner chose it, never a writer. Standings on it are a **reader's** (pull), a
282
- **writer's** (pull and push), optionally scoped to folders, or a **library's** (read what was told). Only `main` and
328
+ - **A repo lobe**, on `nervur.repo`, one per repo per organism. It commits, pulls and pushes git bundles over standings,
329
+ and guards its own `main` by two checks: Nervur's check of the repo's parts, and the repo's own `conform`, the choices
330
+ its owners hold it to, as the lobe's owner chose it, never a writer. A standing on it is a **reader's** (pull), a
331
+ **writer's** (pull and push, optionally scoped to folders) or a **library's** (read what was told). Only `main` and
283
332
  its tags move between lobes.
284
- - **Its commands and keys.** A repo declares commands alone, the scripts of its `package.json`. Keys belong to a copy of
285
- the repo, never to the repo: its repo lobe keeps them in its cells, never answered and masked in all it tells, and has
286
- `.env` written from them before each run. What protects a command is its key, never a role: a script without its key
287
- fails by its own words. An owner asks `run`, `setToken` and `credential`; a credential renews itself before it expires
288
- and ends with its standing. A lobe an owner wires to the repo lobe may run and commit, but while a writer's standing
289
- stands on it only the one it names `author` commits; a **runner**, a far organism by its invitation, runs the scripts
290
- it names alone.
291
-
292
- **Authoring and running stand apart**. Authors work on their own organism, in their own repo lobe, gated at the commit,
293
- and push along their standings. Code runs only where the owners ask it: a reader, a writer or a library never reaches
294
- `run`, a key or a runner's invitation. They meet at a release alone: a version leaves by its digest, and an owner moves
295
- a lobe to it. A release is published only by a `run` of the publish script on a repo lobe, at an owner's ask or a
296
- runner's, on an organism its owner chooses, an authoring one among them. A gate runs the tests of the code that came,
297
- which are the writer's, so it catches a mistake and never a writer: what an owner holds against writers is written in
298
- `conform`.
299
-
300
- A repo's version is its root `package.json`'s; a commit that raises it is tagged `v<version>` and that tag **tells**
301
- every part it holds, whose bytes never change after. A repo names no genome: the organism lends it. Its conventions are
302
- folders: `faculties/`, `organs/`, `designs/`; everything else is its owners' own, packages included. Its commands are
303
- its `package.json` scripts, `gate` and `conform` always. Its **harness**, skills among it, says how it is authored, for
304
- models alone, and Nervur shapes nothing of it; a faculty's **guide**, in its blueprint, says how it is run and used,
305
- read by the owners, a lobe wired to it and whoever holds a standing on its lobe.
306
-
307
- **Authoring a repo, anywhere.** A session authors a repo opened in that repo's own folder. Everything it needs is there:
308
- Nervur's guide and the two papers beside it, one folder up in the lent genome's `docs/`, and the repo's own harness,
309
- skills and gate in the repo. Its harness, its owners' own for whatever agent they bring, takes this guide in at the
310
- start of every session, from the genome lent one folder up, at `repos/node_modules/@nervur.org/genome/docs/`, so whoever
311
- authors starts holding Nervur, on any organism. Nervur lends knowledge alone, the guide and the papers beside it, for
312
- any agent and any model, and lays no harness. A repo begins empty, or as the child of a lobe that raises repo lobes and
313
- lays its owners' boilerplate, harness among it, as its first commit, to be pulled and authored. How a faculty is run is
314
- its blueprint's `guide`, never a skill.
333
+ - **Commands and keys.** A repo declares commands alone, the scripts of its `package.json`. Keys belong to a copy of the
334
+ repo, never to the repo: its repo lobe keeps them in its cells, never answers them, masks them in all it tells, and
335
+ writes `.env` from them before each run. What protects a command is its key, never a role: a script without its key
336
+ fails in its own words. An owner asks `run`, `setToken` and `credential`; a credential renews itself before it
337
+ expires and ends with its standing. A lobe an owner wires to the repo lobe may run and commit, but while a writer's
338
+ standing stands on it only the lobe it names `author` commits. A **runner**, a far organism given its own invitation,
339
+ runs only the scripts that invitation names.
340
+
341
+ **Authoring and running stand apart.** Authors work on their own organism, in their own repo lobe, checked at each
342
+ commit, and push along their standings. Code runs only where its owners ask: a reader, a writer or a library never
343
+ reaches `run`, a key or a runner's invitation. The two meet only at a release: a version leaves by its digest, and an
344
+ owner moves a lobe to it. A release is published only by a `run` of the publish script on a repo lobe, asked by an
345
+ owner or a runner, on an organism its owner chooses, an authoring one among them. The gate runs the tests of the code
346
+ that came, which are the writer's, so it catches a mistake, never a dishonest writer: what an owner holds against
347
+ writers is written in `conform`.
348
+
349
+ **A repo's shape.** A repo's version is its root `package.json`'s; a commit that raises it is tagged `v<version>`, and
350
+ that tag **tells** every part it holds, whose bytes never change after. A repo names no genome: the organism lends it.
351
+ Its conventions are folders, `faculties/`, `organs/` and `designs/`; everything else is its owners', packages included.
352
+ Its commands are its `package.json` scripts, `gate` and `conform` always among them.
353
+
354
+ **Its harness and its guides.** A repo's **harness**, its skills among it, says how it is authored, for models alone,
355
+ and Nervur shapes nothing of it. A faculty's **guide**, in its blueprint, says how it is run and used, read by its
356
+ owners, by a lobe wired to it and by whoever holds a standing on its lobe. How a faculty is run is its guide, never a
357
+ skill.
358
+
359
+ **Authoring a repo, anywhere.** A session authors a repo opened in that repo's own folder, and everything it needs is
360
+ there: this guide and the two papers beside it, one folder up in the lent genome's `docs/`, at
361
+ `repos/node_modules/@nervur.org/genome/docs/`, and the repo's own harness, skills and gate in the repo. Its harness,
362
+ its owners' own for whatever agent they bring, takes this guide in at the start of every session, so whoever authors
363
+ starts holding Nervur, on any organism. Nervur lends knowledge alone, for any agent and any model, and lays no harness.
364
+ A repo begins empty, or as the child of a lobe that raises repo lobes and lays its owners' boilerplate, a harness among
365
+ it, as its first commit, to be pulled and authored.
315
366
 
316
367
  ## The screen and looks
317
368
 
318
- A screen's **home** is the organism it is of, and a **place** is any lobe its person stands on, a far organism's or one
319
- of their own, as its window draws it. A person sees through the **screen**:
320
- lobes answer **trees** as data from a reading `draw`, the screen composes them, diffs and patches; no script, style or
321
- address can be written in a tree, and a region a sealed lobe draws is drawn for the lobe whose slot asked it, which
322
- hears its presses; a gesture is another hand on a control the keyboard reaches. A lobe may be created **sealed**, by
323
- whoever creates it: it hears and answers, reads its own cells and its faculty's assets, and orders no wire, so code
324
- another wrote runs and reaches nothing. A place answers what its describe offers; the floor's window draws a place with
325
- no `draw` of its own as its methods and a field for each argument, so one describe gives its forms as it gives Quo's
326
- describe and the console's tools. The **window**, the screen's skin lobe, draws in a **design** (tokens, themes,
327
- components built into a **look** faculty), which is no part of the genome: it creates its design lobes sealed and
328
- wears the design its port gave it by the name `design` until an owner's `wear` chooses another. What a window hands
329
- the host to lay above the page stands outside every tree, where no place's tree or sheet covers or presses it, and no
330
- tree of a place forges a consent the window holds. The floor's window is the least that lets a person use what Nervur
331
- promises from a screen: it shows the organism and a place by what they describe, carries a press past the person's
332
- yes where it binds them, takes a link only with a yes that knows who invites and what they say, and leaves what it
333
- took. It says the warnings and every consent in the home's own words and lays a way out above the page; a note its
334
- caller gives at a link's yes is kept beside the standing and never sent to the place; and at a place it took, a press
335
- the person consents to ends the standing whole and returns them to the home. Everything else a person meets, pages
336
- laid out of parts, boards, lists and words in their language, is built in a window or a design of one's own: Where
337
- Nervur stops, below, says how. A site is another repo's, and in a
338
- browser a page embeds the installer as plain files.
369
+ A screen's **home** is the organism it belongs to. A **place** is any lobe its person stands on, a far organism's or one
370
+ of their own, as the window draws it.
371
+
372
+ - **Trees, not pages.** Lobes answer **trees**, plain data, from a reading `draw`; the screen composes them, diffs them
373
+ and patches what changed. No script, style or address can be written in a tree. A region a sealed lobe draws is drawn
374
+ for the lobe whose slot asked it, and that lobe hears its presses. A gesture is another hand on a control the
375
+ keyboard reaches.
376
+ - **Sealed lobes.** Whoever creates a lobe may create it **sealed**: it hears and answers, reads its own cells and its
377
+ faculty's assets, and orders no wire, so code someone else wrote runs and reaches nothing.
378
+ - **A place with no drawing of its own** is drawn by the floor's window from its describe: its methods, and a field for
379
+ each argument. So one describe gives a place's forms, as it gives Quo's describe and the console's tools.
380
+ - **The window** is the screen's skin lobe. It draws in a **design** (tokens, themes and components, built into a
381
+ **look** faculty), which is no part of the genome. It creates its design lobes sealed and wears the design its port
382
+ gave it, by the name `design`, until an owner's `wear` chooses another.
383
+ - **Above the page.** What a window hands the host to lay above the page stands outside every tree: no place's tree or
384
+ stylesheet covers or presses it, and no place's tree can forge a consent the window holds.
385
+
386
+ The floor's window is the least that lets a person use what Nervur promises from a screen. It shows the organism and a
387
+ place by what they describe; carries a press past the person's yes where the press binds them; takes a link only with a
388
+ yes that knows who invites and what they say; and leaves what it took. It says the warnings and every consent in the
389
+ home's own words and lays a way out above the page. A note its caller gives at a link's yes is kept beside the standing
390
+ and never sent to the place, and at a place it took, a press the person consents to ends the standing whole and returns
391
+ them home. Everything else a person meets, pages laid out of parts, boards, lists, words in their language, is built in
392
+ a window or a design of one's own: Where Nervur stops, below, says how. A site is another repo's, and in a browser a page
393
+ embeds the installer as plain files.
339
394
 
340
395
  ## Hosts
341
396
 
342
- One genome on every host; only host halves differ. The engine is QuickJS and the store SQLite with every page encrypted,
343
- everywhere, and they are named in one place alone. The Node installer serves servers, desktops, Pis and NASes, with a
344
- body and `nervur install`, `nervur update`; the browser's has none, its boot key a file of the site. A phone's app
345
- embeds the browser port, its store in the app's own files and its boot key in the keychain; an edge, its boot key drawn
346
- and kept in its object's own storage, is laid from another machine from its port's **cargo**, the genome and that host's
347
- parts built into the files the host's runtime takes, by a **pilot**, a repo's faculty and organ that lay and keep an
348
- organism on a host from another machine, or by hand, and a server where no one is present by `nervur install --claim`,
349
- and either is claimed by whoever names its **claim**, a secret drawn and set on the host as it is laid, by which the
350
- organism's first invitation is fetched. On a server the machine is root's: ports, DNS and services are laid outside the
351
- graph by its holder, never by the organism. A server holds as many organisms as it has accounts, one for each, each with
352
- a **body** of its own, a second account where its organs run, so none sees another's files; its administrator prepares
353
- each person's two accounts once, and the person installs alone. Authoring's _A server_ says what each of the
354
- administrator and the person does, for a machine you own, one you hold an account on, and one laid for you.
355
-
356
- A new version is tried before it is kept: it boots in place on the store itself, held, writing nothing of it but its
397
+ One genome runs on every host; only the host halves differ. The engine is QuickJS and the store is SQLite with every
398
+ page encrypted, everywhere.
399
+
400
+ - **A machine** (a server, a desktop, a Pi, a NAS) has a body, and its Node installer gives `nervur install` and
401
+ `nervur update`.
402
+ - **A browser** has no body; its boot key is a file of the site.
403
+ - **A phone's app** embeds the browser port, its store in the app's own files and its boot key in the keychain.
404
+ - **An edge** keeps its boot key in its object's own storage. It is laid from another machine, from its port's
405
+ **cargo**, the genome and that host's parts built into the files the host's runtime takes, either by hand or by a
406
+ **pilot**, a repo's faculty and organ that lay and keep an organism on a host from afar.
407
+ - **A server with no one present** is laid by `nervur install --claim`. An edge and such a server are each claimed by
408
+ whoever names its **claim**, a secret drawn and set on the host as it is laid, by which the organism's first
409
+ invitation is fetched.
410
+
411
+ On a server the machine is root's: ports, DNS and services are laid outside the graph by whoever holds the machine,
412
+ never by the organism. A server holds as many organisms as it has accounts, one each, each with a body of its own, a
413
+ second account where its organs run, so none sees another's files. Its administrator prepares each person's two
414
+ accounts once, and the person installs alone. Authoring's _A server_ says what the administrator and the person each
415
+ do, for a machine you own, one you hold an account on, and one laid for you.
416
+
417
+ ## Updates
418
+
419
+ **A new version is tried before it is kept.** It boots in place on the store itself, held, writing nothing of it but its
357
420
  log and the values it lays, so the store's log as it stood is the whole way back, kept aside with the old package on a
358
- machine. Nothing of the store is copied, and an update costs what its own moves change, never the size of the store;
359
- the version boots with the world held, and it is kept or the old comes back by itself. The update asks nothing of the
360
- organism but its stop, so it moves one no one is present at as it moves one owned at its console. Until 1.0.0 it is
361
- abrupt: a run the body has going is lost to it as to a crash, and its lobe told so. What the installer ships, its
362
- organs' halves and its faculties, moves at the new version's first boot, a lobe an owner moved to a later version
363
- staying. From afar `upgrade` names a version and its digest, and nothing else lands. An organism never moves itself:
364
- a version lands only where an owner names it, and nothing asks for a newer one on a clock. A start, a trial and a
365
- stop wait on the organism's silence, never on a span: while it opens or ends it tells it lives, so a store that takes
366
- long to open is waited for, and a process that tells nothing for the longest wait, or ends unasked, fails the step
367
- with why.
368
-
369
- Two moves stand apart. A faculty's new version is its author's: its `migrate` converts its own cells by its own logic,
370
- and Nervur only runs it. Nervur's own new version knows no faculty, and from 1.0.0 breaks no contract one stands on.
371
- Until 1.0.0 Nervur goes forward only: a genome names its floor, `FLOOR`, the oldest release whose store it carries
372
- forward, and refuses a store a genome below it last booted, saying to move to the floor first: update it to the
373
- floor's release, then to the newest. No installer carries an older release to do that for you, so a store, a backup
374
- or a move from below the floor is refused as it stands, nothing opened and the store untouched.
421
+ machine. Nothing of the store is copied, and an update costs what its own changes move, never the size of the store.
422
+ The new version boots with the world held off, and is kept, or the old one comes back by itself.
423
+
424
+ - The update asks nothing of the organism but to stop, so it moves one no one is present at as it moves one owned at
425
+ its console. Until 1.0.0 it is abrupt: a run the body has going is lost as in a crash, and its lobe is told so.
426
+ - What the installer ships, its organs' halves and its faculties, moves at the new version's first boot; a lobe an owner
427
+ moved to a later version stays where it is.
428
+ - From afar, `upgrade` names a version and its digest, and nothing else lands.
429
+ - An organism never moves itself: a version lands only where an owner names it, and nothing asks for a newer one on a
430
+ clock.
431
+ - A start, a trial and a stop wait on the organism's silence, never on a fixed span: while it opens or ends it says it
432
+ lives, so a store that takes long to open is waited for, and a process that says nothing for the longest wait, or
433
+ ends unasked, fails the step and says why.
434
+
435
+ **Two moves stand apart.** A faculty's new version is its author's: its `migrate` converts its own cells by its own
436
+ logic, and Nervur only runs it. Nervur's own new version knows no faculty, and from 1.0.0 breaks no contract one stands
437
+ on. Until 1.0.0 Nervur goes forward only: a genome names its floor, `FLOOR`, the oldest release whose store it carries
438
+ forward, and refuses a store a genome below it last booted, saying to update to the floor's release first, then to the
439
+ newest. No installer carries an older release to do that for you, so a store, a backup or a move from below the floor
440
+ is refused as it stands, nothing opened and the store untouched.
375
441
 
376
442
  ## The floor and the licence
377
443
 
378
- Above the genome and the ports everything is faculties and organs and the data they carry, and the genome names
379
- nothing built of them, so all of it, Nervur's own defaults among it, can be built again or replaced by anyone.
444
+ Above the genome and the ports, everything is faculties and organs and the data they carry, and the genome names nothing
445
+ built of them, so all of it, Nervur's own defaults among it, can be rebuilt or replaced by anyone.
446
+
447
+ The **floor** is only what the genome and the ports cannot work without:
380
448
 
381
- The **floor** is only what the genome and the ports cannot work without: the default skins of the organs a port lays,
382
- the console's terminal and the screen's window, the two skins of presence, and the repo faculties of `shell` and
383
- `disk`, the jailer and the repo lobe, which a port with a body lays the first time an owner wants a repo; and the
384
- plain look the window draws with. The window is the least that lets a person live with no design: it draws the
385
- organism and each place by what they describe, carries a press past the person's yes where the press binds them,
386
- takes a link only with a yes that knows who invites and what they say, and leaves a place it took. Its own words are
387
- English; a design says them in any other language. Each of the floor's faculties stands on what the genome publishes
388
- alone, as any repo does, and holds no privilege: the genome lays no skin, a port names the floor's in its
389
- configuration, as an owner's word could name another repo's, and a skin's text whose row is damaged reads from the
390
- bytes the port gave.
449
+ - the default skins of the organs a port lays: the console's terminal and the screen's window, the two skins of
450
+ presence;
451
+ - the repo faculties of `shell` and `disk`, the jailer and the repo lobe, which a port with a body lays the first time
452
+ an owner wants a repo;
453
+ - the plain look the window draws with.
454
+
455
+ The window is the least that lets a person live with no design, as The screen and looks tells. Its own words are
456
+ English; a design says them in any other language. Each of the floor's faculties stands on what the genome publishes,
457
+ as any repo does, and holds no privilege: the genome lays no skin, a port names the floor's in its configuration as an
458
+ owner could name another repo's, and a skin whose stored text is damaged is read again from the bytes the port gave.
391
459
 
392
460
  ## Where Nervur stops
393
461
 
394
- Nervur gives the mechanics no one could build alone, and nothing more: an organism and its keys, an invitation taken
395
- and its keys kept in the cells, asks one way over it, the owner as root, the cage, the store, backups and moves, the
462
+ Nervur gives the mechanics no one could build alone, and nothing more: an organism and its keys, an invitation taken and
463
+ its keys kept in the cells, asks one way over it, the owner as root, the cage, the store, backups and moves, the
396
464
  screen's safety, and the ports that lay it on each host. Everything a person meets, holds or is offered is built on it
397
- by whoever builds, in faculties, organs, designs and apps of their own: a list of places blocked, a report, a page of
465
+ by whoever builds, in faculties, organs, designs and apps of their own: a list of blocked places, a report, a page of
398
466
  what a person can do with a place, a board of many, a keeper of boot keys, a copy of an organism kept somewhere safe,
399
- words in every language, a page laid out as one likes. Nervur will not build these for anyone, however often they are
400
- asked: each is one way among many, and the first one built into the kernel would close the rest. What is asked of
401
- Nervur is weighed by one question: without it, with no design and no app, does something Nervur already
402
- promises break, or could no one build it on what is published? Three answers alone say yes: nothing published reaches
403
- it; it can be built, but what Nervur promises could then not be proven; or the only way to build it breaks a promise,
404
- a key held outside the cage, a wait where something could tell, two of a person's relations linked. Easier, faster,
405
- nicer or often asked is not one of them. What enters comes with its proof, a test played from outside as a stranger
406
- plays it, failing before and holding after. Where the answer is no, the answer is how to build it, in
467
+ words in every language, a page laid out as one likes. Nervur will not build these for anyone, however often asked:
468
+ each is one way among many, and the first one built into the kernel would close the rest.
469
+
470
+ What is asked of Nervur is weighed by one question: without it, with no design and no app, does something Nervur already
471
+ promises break, or could no one build it on what is published? Only three answers say yes:
472
+
473
+ - nothing published reaches it;
474
+ - it can be built, but what Nervur promises could then not be proven;
475
+ - the only way to build it breaks a promise: a key held outside the cage, a wait where something could tell, two of a
476
+ person's relations linked.
477
+
478
+ Easier, faster, nicer or often asked is none of them. What enters comes with its proof, a test played from outside as a
479
+ stranger would play it, failing before and holding after. Where the answer is no, the answer is how to build it, in
407
480
  `authoring.md`, never a change to Nervur.
408
481
 
409
482
  Nervur is Bookarest Digital SRL's, under the Functional Source License (`FSL-1.1-ALv2`): anyone reads it, uses it and
@@ -419,4 +492,45 @@ years after it is published.
419
492
  | how a faculty is run and used | its `guide`, in its blueprint, and its node's describe |
420
493
  | what an organism is and holds now | the brain's `portrait` and `state` |
421
494
  | how a repo is authored and released | `authoring.md`, then the repo's harness, its skills first |
422
- | what crosses between two organisms | Quo's own spec, by its chapter |
495
+ | what crosses between two organisms | Quo's own specification, by its chapter |
496
+
497
+ ## Words
498
+
499
+ | Word | What it means |
500
+ | ------------- | ---------------------------------------------------------------------------------------- |
501
+ | organism | a person's, group's or agent's own instance of Nervur, on one device |
502
+ | genome | Nervur's kernel, the same on every host |
503
+ | port | the installer for one kind of host, which fills the genome's seams there |
504
+ | self, body | the organism's own account, and the second account where its programs run |
505
+ | node | anything in an organism, under an ID: an organ, a lobe or a far organism |
506
+ | organ | a driver: a blueprint in the graph and a host half on the device |
507
+ | faculty, lobe | a module of pure code, and one instance of it, with its own cells |
508
+ | cells | a lobe's private part of the organism's memory |
509
+ | placeholder | a need a node declares, by name |
510
+ | wire | one placeholder joined to one node, one way, written by the brain alone |
511
+ | skin lobe | a lobe that declares a placeholder named after an organ: the organ's way into the graph |
512
+ | ask | a method, its arguments and a timeout; it ends exactly once |
513
+ | signal | an ask kept in memory, lost in a crash |
514
+ | letter | an ask kept in the organism's memory until taken, exactly once |
515
+ | job | a handle a node answers at once for long work, given back to ask how it ended |
516
+ | owner | whoever may ask the brain |
517
+ | present | at the device itself, by its console or its screen |
518
+ | anchor | the owner no other owner can drop |
519
+ | Quo | the protocol organisms ask each other over |
520
+ | ward | an organism's identity in Quo, public or fresh for each relation |
521
+ | relation | an invitation accepted: one side asks, the other answers |
522
+ | standing | the end of a relation an organism holds after accepting, which asks |
523
+ | occupant | the end of a relation a lobe gave out, which answers |
524
+ | link | an invitation behind a one-time reference, short enough for a QR code |
525
+ | zero head | where a being with no relation yet may ask a ward |
526
+ | line | a connection an undialable organism holds to one always on |
527
+ | digest | a faculty's SHA-256, its identity and its version |
528
+ | library | the lobe that keeps every faculty by its digest |
529
+ | evidence | pieces of a faculty's world, replayed exactly to prove it |
530
+ | sealed | a lobe that hears and answers but orders no wire |
531
+ | tree | what a lobe draws: plain data, never script, style or address |
532
+ | design, look | the tokens, themes and components a window draws in, and the faculty they are built into |
533
+ | floor | the defaults the genome and the ports cannot work without |
534
+ | `FLOOR` | the oldest release whose store a genome carries forward |
535
+ | harness | the files an agent works by in a repo: instructions, hooks, settings, skills |
536
+ | wall, default | a limit that protects someone other than the owner, and a limit an owner can change |