Wave 2 · The opening · record #22sys.knot.defined

#22 · the Cell's inner listener

It is registered in the Cell's own region, not at root, with a trial lane there.

Came fromthe machineThe machine wrote it while the engine took #20: the blueprint became a figure when the Cell opened. step 120

Read as

when the engine took #22

124The engine takes #22ENGINE.CURSOR · propagate
a wave is settlingengine: working on #22membrane: waiting at #20
The log
#0a listener
#1a doer
#2listener: the charter
#3doer: the author
#4listener: charter seen
#5listener: blueprint seen
#6doer: the planner
#7listener: assess · charter
#8listener: assess · result
#9doer: the evaluator
#10the charter wanted
#11the blueprint
#12readiness
#13readiness
#14a request: a charter
#15the charter proposed
#16the charter defined
#17readiness
#18readiness
#19a request: a Cell
#20the seedmembrane
#21the Cell is open
#22inner listenerengine · working
#23inner doer
#24the Cell's context
end of the log
The engine
What before after
pointer — the next record to take #22 #23
The engine moves on to #22 — a listener the machine wrote itself, for the Cell.
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
#22 · ENGINE.CURSOR · propagate · offset: 22 · by engine
Picture
pointer — the next record to take: #22 → #23
core/registers/take-next-tuple.ts · build 043cc8b
// ENGINE.CURSOR advance (Vol. 02 §4.1) — the machine's instruction pointer:
// returns the tuple at the cursor and moves it forward exactly once, or null
// at quiescence. Advancing IS the context switch: the ambient wave context
// moves to the propagated tuple in the same movement, so every transition
// journalled during its propagation is attributed to it — the cube's spine.
// The cursor never rewinds.

import type { WaveTuple } from "../wave/gate";
import type { RegisterFile } from "./register-file";
import { recordTransition } from "./record-transition";
import { setDriver, setWaveContext } from "./set-wave-context";

export function takeNextTuple(file: RegisterFile): WaveTuple | null {
const engine = file.registers.engine;
if (engine.cursor >= engine.base + engine.window.length) return null;↑ at the end of the log, the engine stops
const tuple = engine.window[engine.cursor - engine.base];
engine.cursor += 1;↑ the engine's pointer moves on by one
setWaveContext(file, { offset: tuple.offset, phase: "propagate" });
setDriver(file, "engine");
recordTransition(file, "engine", "ENGINE.CURSOR", "propagate", { offset: tuple.offset });↑ the change is written into the journal
return tuple;
}
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)
125The inner listener is added — in the Cell's regionKNOT.DEFS · register-knot
a wave is settlingengine: working on #22membrane: waiting at #20
The log
#0a listener
#1a doer
#2listener: the charter
#3doer: the author
#4listener: charter seen
#5listener: blueprint seen
#6doer: the planner
#7listener: assess · charter
#8listener: assess · result
#9doer: the evaluator
#10the charter wanted
#11the blueprint
#12readiness
#13readiness
#14a request: a charter
#15the charter proposed
#16the charter defined
#17readiness
#18readiness
#19a request: a Cell
#20the seedmembrane
#21the Cell is open
#22inner listenerengine · working
#23inner doer
#24the Cell's context
end of the log
The figure of cell@20 · appears
What before after
listener cell@20::l1.seeking.gate — hears context.given → slot text; ready when text != null
The machine writes the listener into the Cell's own list of listeners, in the region of cell@20, not at root. Root does not see the Cell's listeners, and they do not see root.
Where it happens registerKnotDefinition()Vol. 02 §4.2 · Vol. 04 §2.1
Stores a listener's description under its name and gives it a bank of lanes with one trial lane.
Specification
Vol. 02 §4.2 · Vol. 04 §2.1
Code
registerKnotDefinition() in core/registers/register-knot-definition.ts, line 21: the description is stored under its name
Journal
#22 · KNOT.DEFS · register-knot · id: cell@20::l1.seeking.gate, strategy: deterministic, replaced: false · by region:cell@20
Picture
listener cell@20::l1.seeking.gate: — → hears context.given → slot text; ready when text != null
core/registers/register-knot-definition.ts · build 043cc8b
// KNOT.DEFS write (Vol. 02 §4.2): the definition payload lands as data, and
// re-registration of an id replaces the definition AND resets its clew bank
// to a fresh null-key probe — accumulated clews of the old definition are
// discarded (the machine's only 'edit'). The probe clew is supplied by the
// resolved executor so invalid configuration has already failed at the
// factory (Vol. 04 §2.1); the stale executor cache entry is dropped here so
// the replacement takes effect for the next tuple.

import type { KnotDefinedPayload } from "../topology/gate";
import type { ClewRegisters, TopologyRegisters } from "./topology-registers";
import type { RegisterFile } from "./register-file";
import { recordTransition } from "./record-transition";

export function registerKnotDefinition(
file: RegisterFile,
region: TopologyRegisters,
payload: KnotDefinedPayload,
probeClew: ClewRegisters
): void {
const replaced = region.knotDefs.has(payload.id);
region.knotDefs.set(payload.id, payload);↑ the description is stored under its name
region.clews.set(payload.id, new Map([[null, probeClew]]));↑ its bank of lanes, with a trial lane
file.ephemeral.knotExecutors.delete(`${region.regionId}/${payload.id}`);
recordTransition(file, `topology:${region.regionId}`, "KNOT.DEFS", "register-knot", {↑ the change is written into the journal
id: payload.id,
strategy: payload.strategy,
replaced
});
// The clew station is born here, with its null-key probe lane — journaled
// on the station itself so fold(journal) holds it before any lane opens
// (the document model's oracle, ADR-004 d10; Vol. 02 §4.5).
recordTransition(file, `topology:${region.regionId}/clew:${payload.id}`, "CLEWS", "open-clew", { key: null, probe: true, replaced }, "registerKnotDefinition");↑ the change is written into the journal
}
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)
A finding for the machine's authors, recorded and left as it is: the journal stamps CLEWS·open-clew → core/registers/ensure-clew.ts for registerKnotDefinition(), which lives in core/registers/register-knot-definition.ts (the op map's file for that register · action).
126It gets a trial laneCLEWS · open-clew
a wave is settlingengine: working on #22membrane: waiting at #20
The log
#0a listener
#1a doer
#2listener: the charter
#3doer: the author
#4listener: charter seen
#5listener: blueprint seen
#6doer: the planner
#7listener: assess · charter
#8listener: assess · result
#9doer: the evaluator
#10the charter wanted
#11the blueprint
#12readiness
#13readiness
#14a request: a charter
#15the charter proposed
#16the charter defined
#17readiness
#18readiness
#19a request: a Cell
#20the seedmembrane
#21the Cell is open
#22inner listenerengine · working
#23inner doer
#24the Cell's context
end of the log
The listener cell@20::l1.seeking.gate · appears
What before after
lane · trial lane (no key) — open
In the Cell's region, the inner listener gets one trial lane with no key. It will hear only the person's words at the level l1.seeking.
Where it happens registerKnotDefinition()Vol. 02 §4.2 · Vol. 04 §2.1
Stores a listener's description under its name and gives it a bank of lanes with one trial lane.
Specification
Vol. 02 §4.2 · Vol. 04 §2.1
Code
registerKnotDefinition() in core/registers/register-knot-definition.ts, line 21: the description is stored under its name
Journal
#22 · CLEWS · open-clew · key: null, probe: true, replaced: false · by region:cell@20
Picture
lane · trial lane (no key): — → open
core/registers/register-knot-definition.ts · build 043cc8b
// KNOT.DEFS write (Vol. 02 §4.2): the definition payload lands as data, and
// re-registration of an id replaces the definition AND resets its clew bank
// to a fresh null-key probe — accumulated clews of the old definition are
// discarded (the machine's only 'edit'). The probe clew is supplied by the
// resolved executor so invalid configuration has already failed at the
// factory (Vol. 04 §2.1); the stale executor cache entry is dropped here so
// the replacement takes effect for the next tuple.

import type { KnotDefinedPayload } from "../topology/gate";
import type { ClewRegisters, TopologyRegisters } from "./topology-registers";
import type { RegisterFile } from "./register-file";
import { recordTransition } from "./record-transition";

export function registerKnotDefinition(
file: RegisterFile,
region: TopologyRegisters,
payload: KnotDefinedPayload,
probeClew: ClewRegisters
): void {
const replaced = region.knotDefs.has(payload.id);
region.knotDefs.set(payload.id, payload);↑ the description is stored under its name
region.clews.set(payload.id, new Map([[null, probeClew]]));↑ its bank of lanes, with a trial lane
file.ephemeral.knotExecutors.delete(`${region.regionId}/${payload.id}`);
recordTransition(file, `topology:${region.regionId}`, "KNOT.DEFS", "register-knot", {↑ the change is written into the journal
id: payload.id,
strategy: payload.strategy,
replaced
});
// The clew station is born here, with its null-key probe lane — journaled
// on the station itself so fold(journal) holds it before any lane opens
// (the document model's oracle, ADR-004 d10; Vol. 02 §4.5).
recordTransition(file, `topology:${region.regionId}/clew:${payload.id}`, "CLEWS", "open-clew", { key: null, probe: true, replaced }, "registerKnotDefinition");↑ the change is written into the journal
}
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)
A finding for the machine's authors, recorded and left as it is: the journal stamps CLEWS·open-clew → core/registers/ensure-clew.ts for registerKnotDefinition(), which lives in core/registers/register-knot-definition.ts (the op map's file for that register · action).

What	before		after
pointer — the next record to take	#22	→	#23

What	before		after
listener cell@20::`l1.seeking.gate`	—	→	hears `context.given` → slot text; ready when text != null

What	before		after
lane · trial lane (no key)	—	→	open

when the membrane passed #22

132The membrane passes #22MEMBRANE.CURSOR · sweep
a wave is settlingengine: at the endmembrane: passing #22
The log
#0a listener
#1a doer
#2listener: the charter
#3doer: the author
#4listener: charter seen
#5listener: blueprint seen
#6doer: the planner
#7listener: assess · charter
#8listener: assess · result
#9doer: the evaluator
#10the charter wanted
#11the blueprint
#12readiness
#13readiness
#14a request: a charter
#15the charter proposed
#16the charter defined
#17readiness
#18readiness
#19a request: a Cell
#20the seed
#21the Cell is open
#22inner listenermembrane · passing
#23inner doer
#24the Cell's context
end of the logengine
The membrane
What before after
pointer — the next record to pass #22 #23
#22 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
#22 · MEMBRANE.CURSOR · sweep · offset: 22 · by membrane
Picture
pointer — the next record to pass: #22 → #23
core/registers/sweep-next-tuple.ts · build 043cc8b
// MEMBRANE.CURSOR advance (Vol. 02 §4.6, Vol. 07 §3): the membrane's own
// reading of the one log — the second reception of one publication, never a
// second truth. The cursor advances exactly once per offset per machine:
// the exactly-once discharge guarantee lives in this movement.

import type { WaveTuple } from "../wave/gate";
import type { RegisterFile } from "./register-file";
import { recordTransition } from "./record-transition";
import { setDriver, setWaveContext } from "./set-wave-context";

export function sweepNextTuple(file: RegisterFile): WaveTuple | null {
const engine = file.registers.engine;
const membrane = file.registers.membrane;
if (membrane.cursor >= engine.base + engine.window.length) return null;
const tuple = engine.window[membrane.cursor - engine.base];
membrane.cursor += 1;↑ the membrane's pointer moves on by one
setWaveContext(file, { offset: tuple.offset, phase: "sweep" });
setDriver(file, "membrane");
recordTransition(file, "membrane", "MEMBRANE.CURSOR", "sweep", { offset: tuple.offset });↑ the change is written into the journal
return tuple;
}
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)

What	before		after
pointer — the next record to pass	#22	→	#23

Choose a step in the stack — or press →.

A listener's definition

Brings a listener into the machine: its name, how it decides it is ready, what it collects into which slot, and the condition that makes it ready. Four sorts are written here: the first fragment's listener, the admission figure's, the Cell's inner one — written by the machine when the Cell opened — and the return listener.

#22sys.knot.defined the machine

envelope
`offset`	`22`Its place in the log — the only address a record has. The engine gives it when the record is added, the next free number, and it never changes.
`kind`	`sys.knot.defined`Which of the four kinds of record the machine knows. The kind decides what the payload holds.
`key`	∅No lane (∅): a definition belongs to the whole machine, not to one lane.
payload
`id`	`cell@20::l1.seeking.gate`The listener's name, unique in the machine. A listener inside a Cell carries the Cell's name before its own: cell@20::…
`strategy`	`deterministic`How it decides it is ready. Deterministic: by a plain condition over its slots — nothing is asked of the world.
payload.config
`condition`	«text != null»When it is ready — a condition over its slots, such as: the slot note holds something.
`meta`	title · gloss · fields ×1Words for people — a title, a gloss, the field a person fills; for what the act sowed, which act and for which slot. The machine's own parts never read them.
payload.config.wind.collect[0]
`as`	`text`The name of the slot the heard value goes into.
`match_type`	`context.given`The type of fact it hears.
`reduce`	`latest`Which value the slot keeps. Latest: the newest replaces the one before.
`field`	`text`Which field of the heard fact goes into the slot.
`where`	×1A narrowing: only facts whose field equals the given value are heard — by the Cell's level, or by the Cell's name.
payload
`emittedBy`	`admit.note.gate--l1.seeking.planner#1`The intention that wrote this definition — the planner's, when the Cell opened. Only what the machine wrote itself carries it.
`home`	cellRef · localIdWhere it lives: the Cell, and its own name inside it. A listener with a home is registered in that Cell's region, not at root.

end · #22

In the specificationVol. 03 §1Vol. 03 §2Vol. 03 §5Vol. 04 §2.1Vol. 05 §3Vol. 05 §4Vol. 12 §4

Names it shares with other records

cell@20::l1.seeking.gate — also on #29 readiness
admit.note.gate--l1.seeking.planner#1 — also on #19 a request: a Cell, #23 inner doer

The record as the machine keeps it

{
 "offset": 22,
 "kind": "sys.knot.defined",
 "key": null,
 "payload": {
  "id": "cell@20::l1.seeking.gate",
  "strategy": "deterministic",
  "config": {
   "meta": {
    "title": "Seeking",
    "gloss": "What are we seeking to understand, and for whom does it matter?",
    "fields": [
     {
      "name": "text",
      "label": "What is this material about, and what exactly are we seeking to understand in it?",
      "kind": "text"
     }
    ]
   },
   "wind": {
    "collect": [
     {
      "as": "text",
      "match_type": "context.given",
      "reduce": "latest",
      "field": "text",
      "where": [
       {
        "field": "level",
        "equals": "l1.seeking"
       }
      ]
     }
    ]
   },
   "condition": "text != null"
  },
  "emittedBy": "admit.note.gate--l1.seeking.planner#1",
  "home": {
   "cellRef": "cell@20",
   "localId": "l1.seeking.gate"
  }
 }
}