CoAgnes Labthe study spaceresearch preview · build 1ececa2

a wave is settlingengine working on #24membrane waiting at #20

Wave 2 · The opening · record #24domain.factcell.context

#24 · the Cell's context

Nothing in this run hears it, so nothing changes.

Came fromthe machineThe machine wrote it while the engine took #20, after the Cell's records. step 122

Read as

when the engine took #24

  1. 129The engine takes #24ENGINE.CURSOR · propagate

    a wave is settlingengine: working on #24membrane: waiting at #20

    The log
    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. #12readiness
    14. #13readiness
    15. #14a request: a charter
    16. #15the charter proposed
    17. #16the charter defined
    18. #17readiness
    19. #18readiness
    20. #19a request: a Cell
    21. #20the seedmembrane
    22. #21the Cell is open
    23. #22inner listener
    24. #23inner doer
    25. #24the Cell's contextengine · working
    26. end of the log
    The engine
    beforeafter
    pointer — the next record to take#24#25

    The engine moves on to #24, the Cell's context. It is a snapshot: nothing in this run hears it, so nothing changes.

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

when the membrane passed #24

  1. 134The membrane passes #24MEMBRANE.CURSOR · sweep

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

    The log
    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. #12readiness
    14. #13readiness
    15. #14a request: a charter
    16. #15the charter proposed
    17. #16the charter defined
    18. #17readiness
    19. #18readiness
    20. #19a request: a Cell
    21. #20the seed
    22. #21the Cell is open
    23. #22inner listener
    24. #23inner doer
    25. #24the Cell's contextmembrane · passing
    26. end of the logengine
    The membrane
    beforeafter
    pointer — the next record to pass#24#25

    #24 asks nothing of the world. Both pointers reach the end of the log.

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

Choose a step in the stack — or press →.

A fact: the Cell's context

What a Cell is given at birth, once: a snapshot it can never reach behind. Anything it needs later must be presented to it as a new fact.

#24domain.factcell.context the machine

envelope
offset24Its 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.
kinddomain.factWhich of the four kinds of record the machine knows. The kind decides what the payload holds.
keyfragment-one-cellThis session's lane.
payload
factTypecell.contextThe fact type — cell.context.
payload.data
cellRefcell@20The Cell it is given to.
payload.data.context
charterref · digest · valueIts charter.
blueprintversion · topology · result · schemasIts blueprint.

end · #24

In the specificationVol. 03 §1Vol. 03 §5Vol. 12 §5.2

Names it shares with other records

The record as the machine keeps it
{
 "offset": 24,
 "kind": "domain.fact",
 "key": "fragment-one-cell",
 "payload": {
  "factType": "cell.context",
  "data": {
   "cellRef": "cell@20",
   "context": {
    "charter": {
     "ref": "charter@15",
     "digest": "sha256:d697d7f3224e3a44a0888949eb98ee5ecf54aa09b2fc4aba2addca763458ec1b",
     "value": {
      "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
       }
      ]
     }
    },
    "blueprint": {
     "version": 1,
     "topology": {
      "knots": [
       {
        "id": "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"
        }
       }
      ],
      "descriptors": [
       {
        "id": "l1.seeking.release",
        "operator": {
         "on": "l1.seeking.gate",
         "demands": [],
         "service": {
          "instruction": "Release the seat's answer as knowledge.l1.",
          "schema": {
           "type": "object"
          },
          "emit": {
           "writes": "knowledge.l1"
          },
          "action": "release@1"
         }
        }
       }
      ]
     },
     "result": {
      "local_fact_type": "knowledge.l1",
      "producer_bind": "l1.seeking.release",
      "data_field": "result"
     },
     "schemas": {}
    }
   }
  }
 }
}