#12 · the charter gate is ready, the author asks

1. 55The engine takes #12ENGINE.CURSOR · propagate

   a wave is settlingengine: working on #12membrane: waiting at #2

   1. #0a listener
   2. #1a doer
   3. #2listener: the chartermembrane
   4. #3doer: the author
   5. #4listener: charter seen
   6. #5listener: blueprint seen
   7. #6doer: the planner
   8. #7listener: assess · charter
   9. #8listener: assess · result
   10. #9doer: the evaluator
   11. #10the charter wanted
   12. #11the blueprint
   13. #12readinessengine · working
   14. #13readiness
   15. ·end of the log

   What	before		after
   pointer — the next record to take	#12	→	#13

   The engine moves on to #12 — the charter gate's readiness, written by the machine itself.

   Where it happens takeNextTuple()Vol. 02 §4.1

   The engine's step: take the record under its pointer and move the pointer on — or stop, if the pointer has reached the end.

   Specification

   Vol. 02 §4.1

   Code

   takeNextTuple() in core/registers/take-next-tuple.ts, line 15: at the end of the log, the engine stops

   Journal

   #12 · ENGINE.CURSOR · propagate · offset: 12 · by engine

   Picture

   pointer — the next record to take: #12 → #13

   1. 1// ENGINE.CURSOR advance (Vol. 02 §4.1) — the machine's instruction pointer:
   2. 2// returns the tuple at the cursor and moves it forward exactly once, or null
   3. 3// at quiescence. Advancing IS the context switch: the ambient wave context
   4. 4// moves to the propagated tuple in the same movement, so every transition
   5. 5// journalled during its propagation is attributed to it — the cube's spine.
   6. 6// The cursor never rewinds.
   7. 7
   8. 8import type { WaveTuple } from "../wave/gate";
   9. 9import type { RegisterFile } from "./register-file";
   10. 10import { recordTransition } from "./record-transition";
   11. 11import { setDriver, setWaveContext } from "./set-wave-context";
   12. 12
   13. 13export function takeNextTuple(file: RegisterFile): WaveTuple | null {
   14. 14 const engine = file.registers.engine;
   15. 15 if (engine.cursor >= engine.base + engine.window.length) return null;↑ at the end of the log, the engine stops
   16. 16 const tuple = engine.window[engine.cursor - engine.base];
   17. 17 engine.cursor += 1;↑ the engine's pointer moves on by one
   18. 18 setWaveContext(file, { offset: tuple.offset, phase: "propagate" });
   19. 19 setDriver(file, "engine");
   20. 20 recordTransition(file, "engine", "ENGINE.CURSOR", "propagate", { offset: tuple.offset });↑ the change is written into the journal
   21. 21 return tuple;
   22. 22}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 6730f58 (2026-09-13)

2. 56The author opens its rendezvousRDV · open-bank

   a wave is settlingengine: working on #12membrane: waiting at #2

   1. #0a listener
   2. #1a doer
   3. #2listener: the chartermembrane
   4. #3doer: the author
   5. #4listener: charter seen
   6. #5listener: blueprint seen
   7. #6doer: the planner
   8. #7listener: assess · charter
   9. #8listener: assess · result
   10. #9doer: the evaluator
   11. #10the charter wanted
   12. #11the blueprint
   13. #12readinessengine · working
   14. #13readiness
   15. ·end of the log

   What	before		after
   rendezvous opened	—	→	admit.note.gate--l1.seeking.charter.author

   The charter's author waits for the charter gate, so this readiness wakes it: it opens its rendezvous, where it gathers what its listeners have said.

   Where it happens ensureRendezvous()Vol. 02 §4.5 · Vol. 06 §4.5

   Opens a doer's rendezvous the first time it is woken, and a lane in it for each new key.

   Specification

   Vol. 02 §4.5 · Vol. 06 §4.5

   Code

   ensureRendezvous() in core/registers/ensure-rendezvous.ts, line 13: a rendezvous for this doer

   Journal

   #12 · RDV · open-bank · bindId: admit.note.gate--l1.seeking.charter.author · by bind:admit.note.gate--l1.seeking.charter.author

   Picture

   rendezvous opened: — → admit.note.gate--l1.seeking.charter.author

   1. 1// RDV lane access (Vol. 02 §4.5): one rendezvous state per key lane, created
   2. 2// lazily on the first readiness that reaches the bind — activated at birth
   3. 3// when the bind declares no `on` (a demands-only bind, Vol. 06 §4.5).
   4. 4// Creation is a transition; an existing lane passes through as a read.
   5. 5
   6. 6import type { BindHandle, RendezvousLane, RendezvousRegisters } from "./topology-registers";
   7. 7import { recordTransition } from "./record-transition";
   8. 8
   9. 9export function ensureRendezvous(bind: BindHandle, key: string | null, activatedAtBirth: boolean): RendezvousLane {
   10. 10 let bank: RendezvousRegisters | undefined = bind.region.rdv.get(bind.bindId);
   11. 11 if (!bank) {
   12. 12 bank = { lanes: new Map(), intentCtr: 0 };
   13. 13 bind.region.rdv.set(bind.bindId, bank);↑ a rendezvous for this doer
   14. 14 // A new bank changes the REGION's RDV register set (Vol. 02 §4.5) — the
   15. 15 // region station journals it, so its document (rdvOrder) folds true
   16. 16 // (the fold oracle, ADR-004 d11).
   17. 17 recordTransition(bind.file, `topology:${bind.region.regionId}`, "RDV", "open-bank", { bindId: bind.bindId });↑ the change is written into the journal
   18. 18 }
   19. 19 let lane = bank.lanes.get(key);
   20. 20 if (!lane) {
   21. 21 lane = { activated: activatedAtBirth, scope: new Map(), projected: false };
   22. 22 bank.lanes.set(key, lane);↑ a lane for this key
   23. 23 recordTransition(bind.file, `topology:${bind.region.regionId}/bind:${bind.bindId}`, "RDV", "open-lane", {↑ the change is written into the journal
   24. 24 key,
   25. 25 activatedAtBirth
   26. 26 });
   27. 27 }
   28. 28 return lane;
   29. 29}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 3530f2c (2026-09-07)

3. 57A lane for this sessionRDV · open-lane

   a wave is settlingengine: working on #12membrane: waiting at #2

   1. #0a listener
   2. #1a doer
   3. #2listener: the chartermembrane
   4. #3doer: the author
   5. #4listener: charter seen
   6. #5listener: blueprint seen
   7. #6doer: the planner
   8. #7listener: assess · charter
   9. #8listener: assess · result
   10. #9doer: the evaluator
   11. #10the charter wanted
   12. #11the blueprint
   13. #12readinessengine · working
   14. #13readiness
   15. ·end of the log

   What	before		after
   lane · this session	—	→	open
   lane · this session · active	—	→	no
   lane · this session · has acted	—	→	no
   intentions named so far	—	→	0

   Inside the rendezvous, a lane for this session's key — not active yet: it becomes active when the listener it acts on is ready.

   Where it happens ensureRendezvous()Vol. 02 §4.5 · Vol. 06 §4.5

   Opens a doer's rendezvous the first time it is woken, and a lane in it for each new key.

   Specification

   Vol. 02 §4.5 · Vol. 06 §4.5

   Code

   ensureRendezvous() in core/registers/ensure-rendezvous.ts, line 13: a rendezvous for this doer

   Journal

   #12 · RDV · open-lane · key: fragment-one-cell, activatedAtBirth: false · by bind:admit.note.gate--l1.seeking.charter.author

   Picture

   lane · this session: — → open

   1. 1// RDV lane access (Vol. 02 §4.5): one rendezvous state per key lane, created
   2. 2// lazily on the first readiness that reaches the bind — activated at birth
   3. 3// when the bind declares no `on` (a demands-only bind, Vol. 06 §4.5).
   4. 4// Creation is a transition; an existing lane passes through as a read.
   5. 5
   6. 6import type { BindHandle, RendezvousLane, RendezvousRegisters } from "./topology-registers";
   7. 7import { recordTransition } from "./record-transition";
   8. 8
   9. 9export function ensureRendezvous(bind: BindHandle, key: string | null, activatedAtBirth: boolean): RendezvousLane {
   10. 10 let bank: RendezvousRegisters | undefined = bind.region.rdv.get(bind.bindId);
   11. 11 if (!bank) {
   12. 12 bank = { lanes: new Map(), intentCtr: 0 };
   13. 13 bind.region.rdv.set(bind.bindId, bank);↑ a rendezvous for this doer
   14. 14 // A new bank changes the REGION's RDV register set (Vol. 02 §4.5) — the
   15. 15 // region station journals it, so its document (rdvOrder) folds true
   16. 16 // (the fold oracle, ADR-004 d11).
   17. 17 recordTransition(bind.file, `topology:${bind.region.regionId}`, "RDV", "open-bank", { bindId: bind.bindId });↑ the change is written into the journal
   18. 18 }
   19. 19 let lane = bank.lanes.get(key);
   20. 20 if (!lane) {
   21. 21 lane = { activated: activatedAtBirth, scope: new Map(), projected: false };
   22. 22 bank.lanes.set(key, lane);↑ a lane for this key
   23. 23 recordTransition(bind.file, `topology:${bind.region.regionId}/bind:${bind.bindId}`, "RDV", "open-lane", {↑ the change is written into the journal
   24. 24 key,
   25. 25 activatedAtBirth
   26. 26 });
   27. 27 }
   28. 28 return lane;
   29. 29}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 3530f2c (2026-09-07)

4. 58What the gate understood is gatheredRDV.ACTIVATED,RDV.SCOPE · latch-scope

   a wave is settlingengine: working on #12membrane: waiting at #2

   1. #0a listener
   2. #1a doer
   3. #2listener: the chartermembrane
   4. #3doer: the author
   5. #4listener: charter seen
   6. #5listener: blueprint seen
   7. #6doer: the planner
   8. #7listener: assess · charter
   9. #8listener: assess · result
   10. #9doer: the evaluator
   11. #10the charter wanted
   12. #11the blueprint
   13. #12readinessengine · working
   14. #13readiness
   15. ·end of the log

   What	before		after
   lane · this session · active	no	→	yes
   lane · this session · gathered wanted	—	→	wanted = {"charter":{"title":"Seeking","purpose":"What are we seeking to understand, and for whom does it matter?","question":"What is a Cell, and why does the machine open one instead of answering in place?","criteria":[{"id":"q1","question":"What is this material about, and what exactly are we seeking to understand in it?","weight":1,"minimum":0.6},{"id":"q2","question":"Whose problem does it address, and why does it exist?","weight":1,"minimum":0.6}]}}

   The readiness activates the lane, and the charter wanted enters the author's scope under the name wanted. That scope is what its request will carry to the world.

   Where it happens latchRendezvousScope()Vol. 02 §4.5 · Vol. 06 §4

   Gathers what a listener understood into the doer's scope — and, from the listener the doer acts on, activates the lane.

   Specification

   Vol. 02 §4.5 · Vol. 06 §4

   Code

   latchRendezvousScope() in core/registers/latch-rendezvous-scope.ts, line 17: the lane is activated

   Journal

   #12 · RDV.ACTIVATED,RDV.SCOPE · latch-scope · key: fragment-one-cell, as: wanted · by bind:admit.note.gate--l1.seeking.charter.author

   Picture

   lane · this session · active: no → yes

   1. 1// RDV scope latch (Vol. 02 §4.5, Vol. 06 §4): a readiness understanding
   2. 2// enters the bound scope under its declared name — a later readiness of the
   3. 3// same demand refreshes its entry until projection (the latching barrier).
   4. 4// Activation readiness additionally opens the lane (ACTIVATED).
   5. 5
   6. 6import type { BindHandle, RendezvousLane } from "./topology-registers";
   7. 7import { recordTransition } from "./record-transition";
   8. 8
   9. 9export function latchRendezvousScope(
   10. 10 bind: BindHandle,
   11. 11 lane: RendezvousLane,
   12. 12 key: string | null,
   13. 13 as: string,
   14. 14 understanding: unknown,
   15. 15 options: { activates: boolean }
   16. 16): void {
   17. 17 if (options.activates) lane.activated = true;↑ the lane is activated
   18. 18 lane.scope.set(as, understanding);↑ the understanding is gathered
   19. 19 recordTransition(↑ the change is written into the journal
   20. 20 bind.file,
   21. 21 `topology:${bind.region.regionId}/bind:${bind.bindId}`,
   22. 22 options.activates ? "RDV.ACTIVATED,RDV.SCOPE" : "RDV.SCOPE",
   23. 23 "latch-scope",
   24. 24 { key, as }
   25. 25 );
   26. 26}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in f36e70d (2026-08-18)

5. 59The author acts — onceRDV.PROJECTED · latch-projection

   a wave is settlingengine: working on #12membrane: waiting at #2

   1. #0a listener
   2. #1a doer
   3. #2listener: the chartermembrane
   4. #3doer: the author
   5. #4listener: charter seen
   6. #5listener: blueprint seen
   7. #6doer: the planner
   8. #7listener: assess · charter
   9. #8listener: assess · result
   10. #9doer: the evaluator
   11. #10the charter wanted
   12. #11the blueprint
   13. #12readinessengine · working
   14. #13readiness
   15. ·end of the log

   What	before		after
   lane · this session · has acted	no	→	yes

   The lane is latched: the author acts now, and never again on this lane — however long the world takes to answer.

   Where it happens latchRendezvousProjection()Vol. 02 §4.5 · Vol. 06 §4.2

   Latches a doer's lane after it acts, so that it never acts on that lane again.

   Specification

   Vol. 02 §4.5 · Vol. 06 §4.2

   Code

   latchRendezvousProjection() in core/registers/latch-rendezvous-projection.ts, line 9: the lane is latched for good

   Journal

   #12 · RDV.PROJECTED · latch-projection · key: fragment-one-cell · by bind:admit.note.gate--l1.seeking.charter.author

   Picture

   lane · this session · has acted: no → yes

   1. 1// RDV.PROJECTED latch (Vol. 02 §4.5, Vol. 06 §4.2): one-shot — once the
   2. 2// scope is judged and the intention projected (or rejected at a gate), the
   3. 3// lane never fires again. The latch never reopens; revision is fresh binds.
   4. 4
   5. 5import type { BindHandle, RendezvousLane } from "./topology-registers";
   6. 6import { recordTransition } from "./record-transition";
   7. 7
   8. 8export function latchRendezvousProjection(bind: BindHandle, lane: RendezvousLane, key: string | null): void {
   9. 9 lane.projected = true;↑ the lane is latched for good
   10. 10 recordTransition(bind.file, `topology:${bind.region.regionId}/bind:${bind.bindId}`, "RDV.PROJECTED", "latch-projection", {↑ the change is written into the journal
   11. 11 key
   12. 12 });
   13. 13}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in f36e70d (2026-08-18)

6. 60The intention gets its nameINTENT.CTR · mint-uid

   a wave is settlingengine: working on #12membrane: waiting at #2

   1. #0a listener
   2. #1a doer
   3. #2listener: the chartermembrane
   4. #3doer: the author
   5. #4listener: charter seen
   6. #5listener: blueprint seen
   7. #6doer: the planner
   8. #7listener: assess · charter
   9. #8listener: assess · result
   10. #9doer: the evaluator
   11. #10the charter wanted
   12. #11the blueprint
   13. #12readinessengine · working
   14. #13readiness
   15. ·end of the log

   What	before		after
   intentions named so far	0	→	1

   What the author is about to ask gets a unique name — its own name with #1 — from a counter that never goes back. The world must return that name with its answer.

   Where it happens nextIntentionUid()Vol. 02 §4.5 · Vol. 02 §4.7

   Gives a doer's next intention its unique name, from a counter that never goes back.

   Specification

   Vol. 02 §4.5 · Vol. 02 §4.7

   Code

   nextIntentionUid() in core/registers/next-intention-uid.ts, line 12: the counter moves on

   Journal

   #12 · INTENT.CTR · mint-uid · uid: admit.note.gate--l1.seeking.charter.author#1 · by bind:admit.note.gate--l1.seeking.charter.author

   Picture

   intentions named so far: 0 → 1

   1. 1// INTENT.CTR advance (Vol. 02 §4.5, §4.7 rule 3): the service-intention uid
   2. 2// sequence, shared across lanes and never reset — uids stay unique per
   3. 3// machine instance, which is exactly why this counter belongs to the durable
   4. 4// stratum and must survive a snapshot/restore (ADR-002 decision 4).
   5. 5
   6. 6import type { BindHandle } from "./topology-registers";
   7. 7import { recordTransition } from "./record-transition";
   8. 8
   9. 9export function nextIntentionUid(bind: BindHandle): string {
   10. 10 const bank = bind.region.rdv.get(bind.bindId);
   11. 11 if (!bank) throw new Error(`Rendezvous bank missing for bind '${bind.bindId}'.`);
   12. 12 bank.intentCtr += 1;↑ the counter moves on
   13. 13 const uid = `${bind.bindId}#${bank.intentCtr}`;↑ the name: the doer's name and the count
   14. 14 recordTransition(bind.file, `topology:${bind.region.regionId}/bind:${bind.bindId}`, "INTENT.CTR", "mint-uid", {↑ the change is written into the journal
   15. 15 uid
   16. 16 });
   17. 17 return uid;
   18. 18}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in f36e70d (2026-08-18)

7. 61The request enters the log as #14LOG · append

   a wave is settlingengine: working on #12membrane: waiting at #2

   1. #0a listener
   2. #1a doer
   3. #2listener: the chartermembrane
   4. #3doer: the author
   5. #4listener: charter seen
   6. #5listener: blueprint seen
   7. #6doer: the planner
   8. #7listener: assess · charter
   9. #8listener: assess · result
   10. #9doer: the evaluator
   11. #10the charter wanted
   12. #11the blueprint
   13. #12readinessengine · working
   14. #13readiness
   15. #14a request: a charternew
   16. ·end of the log

   What	before		after
   records in the log	14	→	15
   #14	—	→	a request: a charter · service.request

   The author has no local action, so to act is to ask: its request — write the charter of the figure to admit — is written as #14, to be answered as charter.proposed.

   Where it happens appendEmissions()Vol. 02 §4.1 · Vol. 03 §1

   The only function that adds records to the log. Each new record gets the next free number, at the end.

   Specification

   Vol. 02 §4.1 · Vol. 03 §1

   Code

   appendEmissions() in core/registers/append-emissions.ts, line 14: the new record gets the next free number

   Journal

   #12 · LOG · append · offset: 14, kind: domain.fact · by engine

   Picture

   records in the log: 14 → 15

   1. 1// The one LOG writer (Vol. 02 §4.1, Vol. 03 §1): emissions become tuples by
   2. 2// receiving the next dense absolute offset — `base + window.length` — and
   3. 3// nothing else ever grows the log. Each append is journalled under the
   4. 4// ambient context, so a batch born of a propagated tuple carries that
   5. 5// tuple's offset as its cause — the cube's provenance line (ADR-002).
   6. 6
   7. 7import type { WaveEmission, WaveTuple } from "../wave/gate";
   8. 8import type { RegisterFile } from "./register-file";
   9. 9import { recordTransition } from "./record-transition";
   10. 10
   11. 11export function appendEmissions(file: RegisterFile, emissions: readonly WaveEmission[]): void {
   12. 12 const engine = file.registers.engine;
   13. 13 for (const emission of emissions) {
   14. 14 const tuple: WaveTuple = { ...emission, offset: engine.base + engine.window.length };↑ the new record gets the next free number
   15. 15 engine.window.push(tuple);↑ it is added at the end of the log
   16. 16 recordTransition(file, "engine", "LOG", "append", {↑ the change is written into the journal
   17. 17 offset: tuple.offset,
   18. 18 kind: tuple.kind
   19. 19 });
   20. 20 }
   21. 21}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in f36e70d (2026-08-18)

when the membrane passed #12

1. 78The membrane passes #12MEMBRANE.CURSOR · sweep

   a wave is settlingengine: at the endmembrane: passing #12

   1. #0a listener
   2. #1a doer
   3. #2listener: the charter
   4. #3doer: the author
   5. #4listener: charter seen
   6. #5listener: blueprint seen
   7. #6doer: the planner
   8. #7listener: assess · charter
   9. #8listener: assess · result
   10. #9doer: the evaluator
   11. #10the charter wanted
   12. #11the blueprint
   13. #12readinessmembrane · passing
   14. #13readiness
   15. #14a request: a charter
   16. ·end of the logengine

   What	before		after
   pointer — the next record to pass	#12	→	#13

   #12 asks nothing of the world, so the membrane's pointer simply moves on.

   Where it happens sweepNextTuple()Vol. 02 §4.6 · Vol. 07 §3

   The membrane's step: pass over the record under its pointer and move the pointer on — exactly once per record.

   Specification

   Vol. 02 §4.6 · Vol. 07 §3

   Code

   sweepNextTuple() in core/registers/sweep-next-tuple.ts, line 16: the membrane's pointer moves on by one

   Journal

   #12 · MEMBRANE.CURSOR · sweep · offset: 12 · by membrane

   Picture

   pointer — the next record to pass: #12 → #13

   1. 1// MEMBRANE.CURSOR advance (Vol. 02 §4.6, Vol. 07 §3): the membrane's own
   2. 2// reading of the one log — the second reception of one publication, never a
   3. 3// second truth. The cursor advances exactly once per offset per machine:
   4. 4// the exactly-once discharge guarantee lives in this movement.
   5. 5
   6. 6import type { WaveTuple } from "../wave/gate";
   7. 7import type { RegisterFile } from "./register-file";
   8. 8import { recordTransition } from "./record-transition";
   9. 9import { setDriver, setWaveContext } from "./set-wave-context";
   10. 10
   11. 11export function sweepNextTuple(file: RegisterFile): WaveTuple | null {
   12. 12 const engine = file.registers.engine;
   13. 13 const membrane = file.registers.membrane;
   14. 14 if (membrane.cursor >= engine.base + engine.window.length) return null;
   15. 15 const tuple = engine.window[membrane.cursor - engine.base];
   16. 16 membrane.cursor += 1;↑ the membrane's pointer moves on by one
   17. 17 setWaveContext(file, { offset: tuple.offset, phase: "sweep" });
   18. 18 setDriver(file, "membrane");
   19. 19 recordTransition(file, "membrane", "MEMBRANE.CURSOR", "sweep", { offset: tuple.offset });↑ the change is written into the journal
   20. 20 return tuple;
   21. 21}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 6730f58 (2026-09-13)