MOLECULAR CODINGspec 4.0 · ± PROD · every clock in tune

There is no synchronous spine here. No master clock. No shared state that flips all at once. Each cell keeps its own beat. Each layer lands when it lands, not the instant you ask.

Every other law quietly leans on this one. R1 to R9 only work in a world where nothing waits. Calling it R0 drags that hidden assumption into the light.

The body grows from the bottom up and gets steered from the top down. Every floor carries out what the floor above wants and reports back to the floor below. SELF boils engine memory down into long-term keepsakes, throws out what stopped helping, then feeds those lessons back into DNA. All seven floors live inside a single user. An eighth axis stands beside the stack: the GENESIS LOOP + PER-USER CHAIN + META LAYER (§1c–§1e · spec 3.2). It builds the whole body fresh on every boot, writes it down as a block that cannot be changed, and guards it with the meta check that shuts bad actors out.

WHICH WAY THINGS MOVE

• Downhill (orders): DNA → cells → organs. A commander rewrites an order, the helpers switch how they act, the fleet clears its queue.
• Uphill (reports): cells → organs → emotions → memory → kernels → SELF. Work floats upward, hormones turn the dials, memory settles, kernels squeeze it into seeds for the next boot, and SELF picks what gets to live on.
• Loop-back (growing up): SELF → edits to DNA → cells specialize. The body learns by rewriting its own orders from whatever made it into the vault.

SELF began life as poetry ("the integrated being") and got cut from spec 3.0, because nobody can turn "consciousness" into a lint check. Spec 3.1 brings it back with one clear job you can enforce: SELF chooses what graduates from session memory into the permanent vault, and what gets shredded for good.

// Example: SELF archive policy
function archiveRule(artifact) {
  // keep things that crossed quorum, were verified, or carry rare event_types
  return artifact.completeness >= 0.85
      || artifact.contributing_fleets.length >= 3
      || RARE_EVENT_TYPES.has(artifact.event_type);
}

// Example: SELF prune policy
function pruneRule(item, now) {
  const ageMs    = now - item.last_used_ts;
  const isStale  = ageMs > 30 * DAY_MS;
  const isUnused = item.times_recalled === 0;
  return isStale && isUnused && !item.archived;
}

// SELF scheduled tick
function selfTick() {
  const now = Date.now();
  ENGINES.artifacts.forEach(a => {
    if (archiveRule(a))     return BE(() => archiveItem(a),  'SELF_ARCHIVE');
    if (pruneRule(a, now)) return BE(() => pruneItem(a),    'SELF_PRUNE');
  });
}

WHERE BIOLOGY DOES IT

• Sleep sorts the day's memories (Stickgold, Walker): deep NREM sleep sweeps through memory traces, then REM locks in the keepers.
• Trimming the wiring (Huttenlocher 1979): kids and teens lose the links they never use.
• The forgetting curve (Ebbinghaus 1885): facts nobody touches fade on a schedule you can predict.
• Hebb's "use it or lose it": links that keep firing together are the ones that stay.

WHERE COMPUTING DOES IT

• Garbage collection by generation (Lieberman/Hewitt 1983): new objects get swept hard, the ones that last move up a tier.
• LRU cache eviction (Belady 1966): whatever sat untouched longest leaves first.
• Storage tiers (hot → warm → cold → frozen): how today's data lakes already run.
• TF-IDF weighting for deciding what to keep in search systems.

WHY BRINGING IT BACK IS FAIR

Spec 3.0 cut SELF because nobody could enforce "the integrated being". Spec 3.1 lets it back in because vault + shred boils down to two real functions with written policies. A checkable job is a different animal from poetic "consciousness", and the checkable job is the only part that earned a seat again.

The seven floors of the stack live inside a single user. Axis eight is the loop that builds that user's instance from scratch each time it starts. Everyone runs the same code blueprint (the PUBLIC SEED), yet your instance only comes alive once your PRIVATE SEED sparks it. Until you've booted yourself into being, there's simply nothing for anyone to log in against.

// every boot is a fresh genesis · the bootstrap IS the auth event
async function boot(privateSeed) {
  const publicSeed  = await fetchPublicSeed(SEED_CID);    // same for all users
  const deltas      = await loadLocalDeltas();           // today's changes from local store
  const instance   = GENESIS(publicSeed, privateSeed, deltas);
  const block      = commitBlock(instance);              // next block in your chain
  const validated = await META.verifySignal(block);     // gate at the protocol edge
  if (!validated)  return BE(rollback,            'META_REJECTED');
  return           BE(() => activate(instance), 'INSTANCE_LIVE');
}

// instance termination ≡ auth gate closes
function terminate(instance) {
  instance.freeze();
  META.revoke(instance.id);
  return BE(closeAuthGate, 'INSTANCE_TERMINATED');
}

HOW THIS DIFFERS FROM zk-ROLLUPS

• Rollups run one big state machine for everyone, and users prove facts about their secret inputs to it.
• The genesis loop keeps no shared state machine at all. Every user runs a program that is theirs alone. Starting it up is the login. Skip that start-up and there's no target to hit.
• Nobody can pose "as you" when the software that could fake you isn't sitting on their machine, and their own private seed can't produce it.

ONE LOGIN PER LIFE AREA, KEPT APART

Each area grows its own private seed from your master seed. If someone cracks your social instance, they still can't pass as your bank one. Banking uses its own derivation path, its own META gate and its own chain.

EXTRA LOCKS STACK ON TOP

Passkeys, MFA, fingerprints: none of them go away. They layer onto the instance after it's alive. Genesis answers "does this instance exist?" Passkeys answer "is it still you driving?" Together they shrink the attack surface; on its own, neither one is the whole design.

YOUR DEVICE IS YOUR LOGIN

WebAuthn and passkeys already ship a slice of this: "your device proves it's you, since only it holds the private key." The long version goes further: your device paints a brand-new OS from your seed every time it boots. The OS is the login. "Device as login" is just the handy zipped-up form.

Each GENESIS adds one block to that user's own chain. Blocks can't be edited after the fact, the same way a blockchain works. Every block points at the hash of the one before it. You won't find one big chain everybody shares; you get a separate chain for every user instance. Anybody can confirm the chain hasn't been tampered with. Only its owner can read what the blocks point at.

// block schema · one chain per user · append-only
const block_n = {
  n:           N,                                // boot count · monotonic from genesis
  version:     instance.seedVersion(),            // version derived from seed
  ts:          Date.now(),                          // when this boot happened
  prev_hash:   chain[N-1].hash,                  // links to previous block
  instance_h:  sha256(canonicalize(instance)),  // this boot's instance hash
  delta_h:     sha256(canonicalize(deltas)),    // today's deltas applied
  meta_sig:    META.sign(this),                 // META layer signs the validation
  hash:        'sha256:0x...'                    // self-hash · seals the block
};

BEST vs NEWEST · each area picks its own meaning

SPOT IT, THEN ROLL BACK

Weird-behavior checks run on every block. If META or an outside watcher marks block N as fishy, the system steps back to block N-1 (or earlier) and carries on from there. Proof of the bad block is kept on the chain, nobody erases it, but it's stamped invalid and never used as a starting point again.

// detection → rollback discipline (R9)
function detectAnomaly(block) {
  if (META.scoreSuspect(block) > SUSPECT_THRESHOLD) {
    block.flag = 'SUSPECT';
    return BE(() => rollbackTo(block.n - 1), 'ROLLBACK_TRIGGERED');
  }
  return BE(acceptBlock, 'BLOCK_ACCEPTED');
}

function rollbackTo(n) {
  const good = chain[n];
  CURRENT_INSTANCE = GENESIS_FROM_BLOCK(good);
  META.log({ event: 'ROLLBACK', target_block: n, reason: 'anomaly' });
  return BE(resumeFromInstance, 'ROLLBACK_COMPLETE');
}

WHY AI MODELS LOVE THIS

• Repeatable: same (seed, deltas) in, same instance out · replay from whichever block you like.
• Checkable: every boot leaves a block · you can diff exactly how this user's program changed over time.
• Walled off: one user per chain · nothing shared for one user to break for the rest · a rotten chain can't infect its neighbors.
• Safe to undo: bad block → step back · the rest of the system is untouched · the trail stays on-chain as proof.
• Size-capped: SELF's vault-and-shred runs inside the chain, so memory never balloons.

META stands on the protocol border between a user's INSTANCE and the LEDGER (their per-user chain, plus any shared coordination on top). Its task: check the signal on each block before anyone treats it as official. Bad actors get stopped one floor beneath login instead of one floor above it. Login comes from the instance existing (R6); META rules on whether the next block may even join onto the chain. Spec 3.2 gave META a name and parked it as a work in progress. Spec 5.0 writes the rules down: an exact signal format, a quorum of peer witnesses, a threshold that moves with posture, and failure in steps. Two fresh laws (R12 · R13) and two fresh moves (WITNESS · QUARANTINE) come with it.

§1e-1 · THE SIGNAL · byte by byte

The §1d block layout already has a meta_sig slot. Spec 5.0 pins down what goes in it:

// META signal · 136 bytes packed · what every witness checks
const meta_signal = {
  instance_pubkey: u8[32],   // ed25519 · derived from (public, private) seed at genesis
  block_hash:      u8[32],   // sha256(canonicalize(block)) · the thing being attested
  sig:             u8[64],   // ed25519 sign(block_hash) under the instance key
  freshness:       u8[8],    // boot counter n (monotonic) ++ wall-clock ms · kills replay
};

Each witness looks at exactly three things: (1) does the signature match the pubkey it claims, (2) is that pubkey the same one that has grown this chain since genesis, and (3) is the freshness counter higher than the last block that got in. Faking a block takes the private seed; replaying one means outrunning a counter that only goes up; swapping identities needs a chain fork the witnesses have already seen. Without the seed, an attacker gets none of those.

§1e-2 · WHERE META LIVES · a crowd of peer witnesses, never a lone oracle

// R12 · a block is provisional until K-of-N witnesses co-sign
async function metaVerify(block, posture) {
  const { K, freshness_ms } = metaThreshold(posture);   // R13 · posture-gated
  const witnesses = await gatherWitnesses(block.meta_signal);
  const attest = witnesses.filter(w =>
    w.verifySig(block) && w.freshWithin(block, freshness_ms)
  );
  if (attest.length >= K) return BE(() => accept(block),        'WITNESS_QUORUM_MET');
  if (attest.length > 0)  return BE(() => quarantine(block),    'WITNESS_INSUFFICIENT');
  return                    BE(() => rollback(block.n - 1), 'WITNESS_NONE_R9');
}

Witnesses are other instances (the peer-witness pattern) or an area's validator crew: an instance never vouches for itself, and no single trusted server gets the final word. A bank area runs a strict validator crew; a social area might be fine with casual peer vouching. How witnesses find each other and pass a block around is left open on purpose. The horizon note below explains why.

§1e-3 · STACKING · three gates, lowest first

Genesis is the ground floor (no instance → no login to attempt). META guards the chain (no witness quorum → the block doesn't count). Passkeys are the roof (no fresh proof → no risky action). Each one locks a different door; pull any of them and a hole opens. META is no stand-in for passkeys, and passkeys are no stand-in for genesis.

§1e-4 · A GATE THAT MOVES WITH MOOD · R13 · the Oracle sets how strict it is

// R13 · META strictness IS hormonal · cortisol/adrenaline tighten the gate
function metaThreshold(h) {                          // h = HORMONES readout (§4.1)
  const alert = clamp(h.cortisol * 0.6 + h.adrenaline * 0.4, 0, 1);
  return {
    K:            1 + Math.round(alert * 4),          // calm → 1 witness · alarmed → 5
    freshness_ms: 60000 - alert * 55000,            // calm → 60s window · alarmed → 5s
  };
}

The very posture that clamps routing gates and speeds up rhythms also clamps the META gate. When the body reads high cortisol (errors climbing, queues packed) it wants more witnesses and newer proofs before believing the next block. When it's calm, it eases off. META thresholds frozen into the code break R13. That's why META belongs to the body instead of being strapped on from outside. It breathes in time with the Oracle.

§1e-5 · WHEN IT FAILS · in steps, and always out loud

Spec 5.0 needed QUARANTINE because a block can look suspicious without being evil: maybe its witnesses haven't shown up yet, maybe the network is crawling. Parking it buys time. You neither trust the block nor toss the user's work. Rollback only fires for blocks with zero witnesses or a proven fake. When the same pattern keeps showing up across instances, the Oracle turns it into an area-wide posture shift.

Sticky note to future me: META graduated from a spec 3.2 work-in-progress to a spec 5.0 rulebook as soon as an exact signal, a quorum law and a posture gate could each be written as a function you can enforce. The same hurdle SELF cleared in spec 3.1 and GENESIS in spec 3.2. Hold off on building the witness network until the rules have sat in the manual long enough for people to try breaking them. Name it → write the rules → toughen it → ship it, in that exact order.

Every action in the body sits somewhere on one slider: fission (pull it apart) ↔ fusion (put it together). That slider is a design law. It pins each function to a spot and makes the function say where it stands.

WHY IT IS A LAW

• Ask it in code review: "does this function split or merge, and does its name admit it?"
• Where it goes: heavy splitting near the input edge, heavy merging near the output edge. SELF works both ends: pruning splits (toss it), archiving merges (keep it).
• Keep the balance: split too much and you get static. Merge too much and you agree too early. A healthy body keeps the mix right for whatever load it's under.

Who did it first: MapReduce (Dean/Ghemawat 2004) splits, then merges. Neuroscience's binding problem (Treisman 1980s) is still stuck on turning scraps into one picture. Fission-fusion societies (Aureli et al, primate studies) are groups that break up and rejoin.

Laws a linter or a reviewer can actually check. They're what give Molecular Coding its silhouette.

const SCOUT_NEWS = {
  id: 'NEWS-RSS',
  cell_type: 'APC',            // antigen-presenting cell · surfaces signal
  source: 'Google News',
  trust: 0.70,
  cadence_ms: 6500,
};

const SCOUT_CMD = {
  id: 'SCOUT-COMMANDER',
  cell_type: 'HELPER_T',
  dna_version: 3,
  directive: 'widen news intake · prioritize EDGAR-confirmed sources',
  last_transcribed_ms: Date.now(),
};

function evaluate(packet) {
  if (packet.confidence > 0.75) {
    promote(packet);
    return BE(scheduleNext, 'PROMOTED');
  }
  if (packet.confidence > 0.40) {
    addToReview(packet);
    return BE(notifyManager, 'QUEUED');
  }
  return BE(log, 'LOGGED');
}

if (artifactCompleteness(merged) >= 0.65) {
  registerArtifact(merged);
  emit('graduation', { co: merged.co });
  return BE(notifyMemoryEngine, 'ARTIFACT_BORN');
}

const ENGINE_POLICY = {
  archiveRule: a => a.completeness >= 0.85 || a.contributing_fleets.length >= 3,
  pruneRule:   (a, now) => (now - a.last_used_ts) > 30 * DAY_MS && a.times_recalled === 0,
  schedule_ms: 3600 * 1000,                // hourly self-tick
};

// R6 in code · no entry point without genesis
if (!CURRENT_INSTANCE) {
  return BE(promptForPrivateSeed, 'NO_INSTANCE_NO_AUTH');
}

// R7 in code · every session begins with a full genesis
window.addEventListener('load', () =>
  BE(() => boot(readPrivateSeed()), 'SESSION_GENESIS')
);

// R8 in code · genesis without commit is illegal
function activate(instance) {
  const block = commitBlock(instance);          // MUST happen
  if (!block) throw new Error('R8 · activate without commit');
  return BE(() => runInstance(instance), 'INSTANCE_ACTIVE');
}

// R9 in code · rollback is a first-class operation
function onSuspectBlock(b) {
  if (META.scoreSuspect(b) > SUSPECT_THRESHOLD) {
    return BE(() => rollbackTo(lastTrustedBlock()), 'R9_ROLLBACK');
  }
  return BE(acceptBlock, 'ACCEPTED');
}

// R10 in code · slot IDs are uint8 · names are display-only
const SYNAPSE_SEROTONIN = 0;     // not 'SEROTONIN' · the byte IS the identity
const SYNAPSE_DOPAMINE  = 1;
function applyDrugToSynapse(slot_id, drug_load) {
  SYNAPSE_REGISTRY[slot_id].drug = drug_load;
  return BE(null, 'R10_SLOT_TARGETED');
}

// R11 in code · five scales · single readout
function synapseReadout(syn) {
  return syn.synaptic_conc * effectiveDensity(syn) * syn.receptor_sensitivity;
  // NOT: syn.synaptic_conc * syn.receptor_density · that's R11 violation (v3.2 only)
}

// linter detects R11 violations
function lintR11(fn_source) {
  const hasSingleDensity = /receptor_density/.test(fn_source);
  const hasLegacyTag    = /v3\.2-legacy/.test(fn_source);
  if (hasSingleDensity && !hasLegacyTag) {
    return BE(flagR11, 'R11_VIOLATION_NO_COHERENCY');
  }
}

// R12 in code · a block is provisional until witnessed
async function activateWhenWitnessed(block, posture) {
  const v = await metaVerify(block, posture);   // §1e · K-of-N peer quorum
  if (v.status !== 'WITNESS_QUORUM_MET') {
    return BE(() => quarantine(block, v), 'R12_NOT_WITNESSED');
  }
  return BE(() => activate(block.instance), 'R12_WITNESSED');
}

// R13 in code · the gate breathes with the body
function lintR13(fn_source) {
  const hardcodedK    = /K\s*[=:]\s*\d+/.test(fn_source);
  const usesThreshold = /metaThreshold/.test(fn_source);
  if (hardcodedK && !usesThreshold) {
    return BE(flagR13, 'R13_STATIC_META_THRESHOLD');
  }
}

// R14 in code · every cell tick commits its attestation
function cellTick(cell) {
  cell.work();
  const attest = {
    cell_id:    cell.id,
    code_hash:  sha256(cell.canonicalize()),
    state_hash: sha256(cell.state),
    ts:         Date.now(),
  };
  CURRENT_BLOCK.attestations.push(attest);
  if (priorAttestation(cell.id) && attest.code_hash !== priorAttestation(cell.id).code_hash) {
    return BE(() => quarantine(cell, 'MHC_DRIFT'), 'R14_COMPROMISED');
  }
  return BE(null, 'R14_ATTESTED');
}

// R15 in code · antibodies are append-only
function updateAntibody(old_slot, new_signature) {
  ANTIBODY_REGISTRY[old_slot].status = 'SUPERSEDED';
  const new_slot = ANTIBODY_REGISTRY.claimNextSlot();
  ANTIBODY_REGISTRY[new_slot] = {
    signature:  new_signature,
    status:     'ACTIVE',
    supersedes: old_slot,
  };
  return BE(commitBlock, 'R15_ANTIBODY_VERSIONED');
}

// R16 in code · promotion is gated by tolerance
function promoteAntibody(candidate) {
  const fp_rate = testAgainstKnownGoodPanel(candidate);
  if (fp_rate > 0.05) {
    pruneBcell(candidate.parent_b_cell);
    return BE(log, 'R16_REJECTED_AUTOIMMUNE');
  }
  ANTIBODY_REGISTRY[candidate.slot] = candidate;
  return BE(commitBlock, 'R16_PROMOTED');
}

// R17 in code · sensors transduce first · APCs present second
function handleRawInput(raw, sensor_id) {
  const sensor = SENSORY_REGISTRY[sensor_id];
  const typed  = sensor.transduce(raw);                  // SENSE / TRANSDUCE
  if (!typed.modality) throw new Error('R17 · untyped percept');
  return BE(() => APC.present(typed), 'R17_SENSED_THEN_PRESENTED');
}

// R18 in code · attention is the gain knob · acetylcholine is the master
function effectiveSensitivity(sensor) {
  return sensor.base_sensitivity
       * HORMONES.acetylcholine
       * (1 - HORMONES.leptin)
       * (1 - HORMONES.ghrelin * 0.5);
}

// linter detects R18 violations
function lintR18(fn_source) {
  const hasHardcodedSens = /sensor\.sensitivity\s*[=:]\s*[\d.]+/.test(fn_source);
  const usesAttentionGain = /attentionGain|effectiveSensitivity/.test(fn_source);
  if (hasHardcodedSens && !usesAttentionGain) {
    return BE(flagR18, 'R18_HARDCODED_SENSITIVITY');
  }
}

// R19 in code · cross-modal binding before presentation
function multiModalEvent(percepts) {
  if (percepts.length === 1) return APC.present(percepts[0]);    // uni-modal · ok
  const bound = crossModalBind(percepts);                       // route through slot 128-199
  if (!bound.bound_at) throw new Error('R19 · multimodal not bound');
  return BE(() => APC.present(bound), 'R19_BOUND_THEN_PRESENTED');
}

These two steer design decisions, yet no parser can enforce them. Think of Rust's "fearless concurrency". It is a stance, and no linter checks it. Spec 3.2 patch note 3 writes E1 out completely: 15 hormone reads sorted onto 5 axes, feeding a 13-mood marker table with a sorter that checks in priority order.

const HORMONES = {
  cortisol:   0.32,  // stress · ↑ when errors rise → gates tighten
  serotonin:  0.78,  // mood · ↑ when verify scores up → spawn rate rises
  adrenaline: 0.41,  // urgency · ↑ during high-priority → cadences accelerate
  oxytocin:   0.65,  // trust · ↑ when quorum aligns → cross-fleet bonuses
  // ... 11 more · see §4.1 below for the canonical fifteen
};

§4.1 · E1 · HORMONES · 15 HORMONE READS · BEFORE WE START

Each number in HORMONES is measured from what the system is doing right now, recalculated on every regulateHormones() tick, never a saved guess, never a mystery constant.

// inputs (real, simulated stream) → readouts (regulator) → somatic marker (oracle)
//
//   signal sources ──┬─ STATE.trends · STATE.wire · STATE.artifacts · STATE.errors
//                    ├─ EVENT.looks (heroes) · seasonPhase (wall-clock) · velocity
//                    └─ verify-quorum · completeness · focus-spread · gate-rate

On each tick (3000 ms) the regulator works out a target and slides every hormone 35% of the way there: no jumps, no wobble. BE(null, 'HORMONES_REGULATED') finishes the round.

§4.1a · THE FIRST 11 · the textbook hormone + brain-chemical set

§4.1b · EXPANSION PACK +4 · craft / efficiency / tempo / inflammation

The first 11 handled risk, want and rhythm, but nothing read the making-things side of a creative studio: craft history, how well work converts, how fast it ships, and the heat of public backlash. Four more hormones plug that hole.

§4.1c · BRAIN MESSENGERS +5 · arousal · attention · bonding · flow

Fifteen hormones covered the textbook set plus studio craft, but skipped the neurotransmitter band: the quick brain signals that decide arousal, attention and flow. Patch note 4 brings in five of them and rounds the panel out at 20 reads.

New opposite pair: gaba ⇄ glutamate: the main brake-versus-gas axis. A brain only stays alive because those two keep pulling against each other in balance, and the simulation lives by the same deal.

§4.1d · EXPANSION PACK 3 · +10 · growth · balance · receptivity · protection · mobilize · venting · friction · health · gate · forge · spec 3.2 patch note 7

The a4 panel of 20 had textbook hormones, craft and brain messengers, yet ten reads a studio really needs were still missing: fleet growth, load balance, how open the audience is, protecting the canon, spending reserves, venting overload, pipeline friction, long-run health, intake gating and good stress. Patch note 7 adds all ten and fills the panel to 30 reads. Seven of them move into existing §4.7 bays that level up from SCAFFOLDED → ACTIVE; three take brand-new bays from the spare 245-254 zone.

Fresh opposite pairs: insulin ⇄ glucagon (saving vs spending) · adiponectin ⇄ resistin (long-run health vs friction) · gh ⇄ somatostatin (grow vs brake: somatostatin still only framed out in bay #56, lined up to level up in patch note 8).

§4.2 · E2 · THE MOOD TABLE · 47 moods · checked in priority order · spec 4.0 a2

The Oracle takes all 31 reads (30 hormones plus coherency), along with immune and sense activity, and returns exactly one mood: the same {state, cls, phrase} bundle everywhere it shows up (watermark, Oracle window, drop-window). The order is the whole trick; the most urgent, most precise checks go first. Patch note 4 slipped in 5 brain-messenger moods (AGITATED · FLOW · BONDED · ATTENTIVE · SEDATED) beside their nearest relatives; patch note 7 slipped in 12 more (STRAINED · VENTING · CLOSED · SPENDING · ACTIVATED · FORGED · HEALTHY · RECEPTIVE · BALANCED · GROWING · GUARDED · INHIBITED). Spec 4.0 added 3 coherency moods (DISCORDANT · TRANSITIONING · SETTLED · §4.8g), 4.0 a1 the 8 immune moods (§11.8), 4.0 a2 the 6 sense moods (§12.7): 47 in all, and not one was just tacked on at the end; each sits exactly where its precision puts it.

The first match takes it. When a loose mood (ACTIVATED · INHIBITED) overlaps a sharper sibling (AGITATED · SEDATED), the sharper one wins simply because it ranks higher. That's how the table keeps growing: every new mood adds precision without breaking a single old check.

§4.3 · THE FIVE BIG AXES · how 30 reads map the whole molecular board · spec 3.2 patch note 7

All 30 reads fit under five big axes. The name in brackets is the small axis: the exact part that hormone plays inside its big one. Patch note 4 (brain messengers) and patch note 7 (+10) widened the map, and still the same five big axes hold without sprouting new ones.

• RISK big axis: cortisol · prostaglandin · adrenaline · anp (VENTING) · resistin (FRICTION) · hepcidin (GATEKEEPING) · progesterone (PROTECTIVE)
• STABILITY big axis: serotonin · oxytocin · insulin · prolactin · adiponectin (HEALTH) · aldosterone (BALANCE) · estrogen (RECEPTIVITY) · gaba (INHIBITION) · vasopressin (TERRITORY) · anandamide (FLOW)
• DRIVE big axis: dopamine · testosterone · ghrelin · thyroxine · growth_hormone (GROWTH) · glucagon (MOBILIZE) · glutamate (EXCITATION)
• REGULATION big axis: melatonin · leptin · norepinephrine · acetylcholine (ATTENTION)
• REWARD big axis: endorphin · fgf21 (STRESS-FORGE)

Opposite pairs (when one runs high, it mutes the other's marker):

• ghrelin ⇄ leptin: starving vs stuffed
• adrenaline ⇄ melatonin: hurry vs rest
• serotonin ⇄ cortisol: steady vs danger · both hold the key to ELATED
• prostaglandin ⇄ insulin: inflamed vs efficient · wellness vs alarm
• gaba ⇄ glutamate: the main brake vs gas · a brain only survives while they keep pulling · a4
• insulin ⇄ glucagon: save vs spend · the body's energy budget · a7
• adiponectin ⇄ resistin: long-run wellness vs a grinding pipeline · a7
• growth_hormone ⇄ somatostatin: grow vs brake (somatostatin still only SCAFFOLDED in bay #56 · lined up to level up in a8)

§4.4 · LIMITS · what this is not

• cortisol high ≠ "danger in the market": it tells you this run has piled up enough errors and crowding that the mood marker should give you a heads-up
• insulin high ≠ "your collection is a sure seller": it means the pool of checked trends feels sure of itself AND isn't all piled into one area
• prostaglandin high ≠ "you're about to get cancelled": it means GATE events went off on the wire lately, so audits ought to get stricter

Each input leads back to a state variable that was measured (in simulation). Zero baked-in guesses. Even [ stub ] feeds give truthful hormone numbers, since the numbers describe the simulation and never claim to describe the real world.

§4.5 · SYNAPSE MECHANICS · the gears under HORMONES · spec 3.2 patch note 5

The 20 hormone numbers up top are measurements. To model mind-altering medicine truthfully, SSRI · MAOI · SNRI · atypicals, the simulation has to go one floor down: the machinery inside the synaptic gap that produces those numbers. That gap is where monoamines really hang out, where reuptake pumps and breakdown enzymes set the level, and where the receiving receptors rise, fall and react across days and weeks. The real clock those drugs run on is receptor density.

§4.5a · WHAT A SYNAPSE TRACKS · 6 numbers for each monoamine

// every monoamine synapse tracks 6 dynamic variables · seed once, regulate every tick
const SYNAPSE_SCHEMA = {
  release_rate:         0.50,  // APC vesicle dump per tick · driven by presynaptic firing rate
  synaptic_conc:        0.30,  // current concentration in the cleft · 0..1.4 (can briefly overshoot)
  reuptake_rate:        0.70,  // KILLER_T transporter activity · fraction cleared per tick
  breakdown_rate:       0.20,  // TREG enzyme activity · MAO/COMT/AChE degradation per tick
  receptor_density:     1.00,  // MEMORY_T count · adapts SLOWLY to chronic exposure (days)
  receptor_sensitivity: 1.00,  // MEMORY_T per-receptor gain · adapts even slower (weeks)
};

// readout · what feeds the HORMONES layer above (§4.1)
// signal = how much postsynaptic activation actually occurs
function synapseReadout(syn) {
  return syn.synaptic_conc * syn.receptor_density * syn.receptor_sensitivity;
}

§4.5b · ONE SYNAPSE TICK · 5 steps · every 3000ms

// runs every 3000ms alongside regulateHormones() · drugLoad defaults to zero
function synapseTick(syn, drugLoad = ZERO_DRUG) {
  // 1 · RELEASE — APC dumps vesicle into the cleft
  syn.synaptic_conc += syn.release_rate * 0.10;

  // 2 · REUPTAKE — KILLER_T pulls neurotransmitter back · DRUG-MODULATED
  const reuptake = syn.reuptake_rate * (1 - drugLoad.reuptake_block);
  syn.synaptic_conc -= reuptake * syn.synaptic_conc * 0.40;

  // 3 · BREAKDOWN — TREG enzyme degrades · DRUG-MODULATED (MAOIs)
  const breakdown = syn.breakdown_rate * (1 - drugLoad.mao_inhibit);
  syn.synaptic_conc -= breakdown * syn.synaptic_conc * 0.15;

  // 4 · CLAMP — concentration stays in physiological range (can briefly exceed baseline)
  syn.synaptic_conc = clamp(syn.synaptic_conc, 0, 1.4);

  // 5 · RECEPTOR ADAPTATION — MEMORY_T density tracks exposure · VERY SLOW
  const exposure       = syn.synaptic_conc;
  const target_density = 1 - (exposure - 0.40) * 0.70;     // chronic high → downregulate
  syn.receptor_density += (target_density - syn.receptor_density) * 0.0012;  // ~5 weeks to half-adapt
  syn.receptor_density  = clamp(syn.receptor_density, 0.30, 1.40);

  return BE(null, 'SYNAPSE_TICKED');
}

§4.5c · THE FIVE MONOAMINE SYNAPSES · standard hookup

§4.5d · WHY RECEPTOR DENSITY IS THE BIG DEAL · the time axis

This one number is what keeps the simulation truthful about mind-altering drugs:

• Right away (minutes to hours): the drug lifts synaptic_conc → the read jumps up at once → better mood · side effects · jitters · a rush.
• Settling in (1 to 6 weeks): synaptic_conc stays high → target_density sinks → MEMORY_T turns itself down → the read drifts back toward normal even though the drug is still around. That's why SSRIs need weeks before depression lifts.
• Tolerance: a receptor_density < 1.0 that sticks around means the same dose gives a weaker signal as time goes on. The synapse really does remember what it's been exposed to.
• Stopping: the drug ends → pumps and enzymes spring back → synaptic_conc drops quickly, yet receptor_density is still turned down → the read sinks under normal for weeks, until receptors climb back. SSRI discontinuation syndrome shows up in the model all by itself: nobody had to code it in.
• Sensitization: synaptic_conc stays low → target_density > 1.0 → receptors turn up · the synapse reacts harder to tiny signals. That covers antidepressant rebound, kindling, and the extra sensitivity after quitting stimulants.

§4.5e · WHO PLAYS WHICH PART · synapse jobs line up with the seven-stage pipeline

§4.6 · MEDICINE FROM OUTSIDE · the APPLY move · spec 3.2 patch note 5

A drug isn't a mystery number slapped onto a hormone. A drug turns one exact synapse job up or down, at an exact strength, with an exact half-life. Its blood level climbs to a plateau over days and slides away on a curve once you stop. It never reaches the read directly. It reaches the rates that make the read. Receptor density handles everything after that.

§4.6a · DRUG SHEETS · the four families worth modelling

// SSRI · selective serotonin reuptake inhibition · blocks SERT only
const SSRI = {
  fluoxetine:   { target: 'SERT', mechanism: 'block', potency: 0.78, halflife_h: 100 },
  sertraline:   { target: 'SERT', mechanism: 'block', potency: 0.82, halflife_h: 26  },
  escitalopram: { target: 'SERT', mechanism: 'block', potency: 0.85, halflife_h: 30  },
  paroxetine:   { target: 'SERT', mechanism: 'block', potency: 0.80, halflife_h: 21  },
};

// MAOI · monoamine oxidase inhibition · raises ALL three monoamines
const MAOI = {
  phenelzine:   { target: 'MAO-A+B', mechanism: 'irreversible_inhibit', potency: 0.95, halflife_h: 11 },
  selegiline:   { target: 'MAO-B',   mechanism: 'inhibit',                potency: 0.80, halflife_h: 10 },
  moclobemide:  { target: 'MAO-A',   mechanism: 'reversible_inhibit',    potency: 0.75, halflife_h: 2  },
  tranylcypromine:{ target: 'MAO-A+B', mechanism: 'irreversible_inhibit', potency: 0.92, halflife_h: 2 },
};

// SNRI · serotonin AND norepinephrine reuptake · blocks SERT + NET
const SNRI = {
  venlafaxine:  { targets: ['SERT', 'NET'], potency: [0.75, 0.60], halflife_h: 5  },
  duloxetine:   { targets: ['SERT', 'NET'], potency: [0.80, 0.70], halflife_h: 12 },
};

// ATYPICALS · receptor agonist/antagonist or unusual mechanism
const ATYPICAL = {
  bupropion:    { targets: ['NET', 'DAT'],    potency: [0.55, 0.40], halflife_h: 21 },        // NDRI
  mirtazapine:  { targets: ['5-HT2A', 'α2'],  mechanism: 'antagonist',     potency: [0.85, 0.70] },  // removes NE brake
  trazodone:    { targets: ['5-HT2A', 'SERT'], mechanism: 'mixed',         potency: [0.80, 0.45] },
  vortioxetine: { targets: ['SERT', '5-HT1A'], mechanism: 'mixed',        potency: [0.75, 0.65] },  // multimodal
};

§4.6b · APPLY · the function that does the pushing

// every tick · plasma_conc tracks rising/falling drug level · 0..1
function APPLY(drug, plasma_conc, synapses) {

  // reuptake inhibitors (SSRI · SNRI · NDRI) — modulate KILLER_T per target
  if (drug.target === 'SERT' || drug.targets?.includes('SERT')) {
    synapses.serotonin.drug.reuptake_block = drug.potency * plasma_conc;
  }
  if (drug.target === 'NET' || drug.targets?.includes('NET')) {
    synapses.norepinephrine.drug.reuptake_block = drug.potency * plasma_conc;
  }
  if (drug.target === 'DAT' || drug.targets?.includes('DAT')) {
    synapses.dopamine.drug.reuptake_block = drug.potency * plasma_conc;
  }

  // MAO inhibitors — modulate TREG · MAO-A hits 5-HT + NE · MAO-B hits DA
  if (drug.target?.includes('MAO-A')) {
    synapses.serotonin.drug.mao_inhibit      = drug.potency * plasma_conc;
    synapses.norepinephrine.drug.mao_inhibit = drug.potency * plasma_conc;
  }
  if (drug.target?.includes('MAO-B')) {
    synapses.dopamine.drug.mao_inhibit = drug.potency * plasma_conc;
  }

  // receptor antagonists — modulate MEMORY_T effective sensitivity OR remove autoreceptor brakes
  if (drug.mechanism === 'antagonist') {
    // example · mirtazapine α2-antagonist removes the NE presynaptic brake → more release
    synapses.norepinephrine.release_rate *= (1 + drug.potency * plasma_conc * 0.5);
  }

  return BE(null, 'DRUG_APPLIED');
}

// plasma concentration kinetics · approach steady state on dose · exponential decay on stop
function plasmaTick(drug_state, isDosing) {
  const k  = Math.LN2 / (drug_state.halflife_h * 3600 * 1000);  // per ms
  const dt = 3000;                                            // tick interval
  if (isDosing) {
    drug_state.plasma_conc += (1.0 - drug_state.plasma_conc) * k * dt * 8;  // approach 1.0
  } else {
    drug_state.plasma_conc *= Math.exp(-k * dt);                            // exponential decay
  }
  return drug_state.plasma_conc;
}

§4.6c · REPLAY TAPE · how a pretend SSRI run plays out

A made-up example trace · 90 days taking it, then 90 days off · sertraline at a treatment dose:

The read doesn't follow the drug alone. It follows the drug and the receptors' memory of it. So the line never jumps like a staircase. So SSRIs do help, just slowly. And so quitting cold turkey stings.

§4.6d · LIMITS · what this layer is not

• Do not use this to prescribe anything. It can't tell whether fluoxetine will work for you.
• The strengths are tuned so the simulation moves in the right general way, not to match blood tests.
• Here, receptor change is one straight delay · in a real body at least five clocks tangle together.
• Drugs clashing with other drugs · CYP450 processing · taking it with food · protein binding in the blood · genetic differences: none of it is covered · each would arrive as another commander nudging the rate numbers.
• Any screen that shows these mechanics must carry the [ sim ] tag, never pass this off as medical advice.

§4.7 · THE SYNAPSE REGISTRY · 255 bays · one uint8 each · spec 3.2 patch note 6

The 5 monoamines back in §4.5c are the tutorial level: the synapses any drug model has to deal with. They're nowhere near the edge of the map. Human brain chemistry runs on roughly 150–200 named messengers, peptides, gases and lipids · this section lays out the whole map as a registry of 255 bays indexed by a uint8. Five bays are ACTIVE; the others are SCAFFOLDED (named, sorted, and ready to level up) · RESERVED (free for future official picks) · or META (the lost-and-found for signals nobody has mapped yet).

§4.7a · WHY 255 (and not 5, and not endless)

• Lines up with bytes: a uint8 ID · lives in one register · a 256-row lookup table sits inside the L1 cache.
• Lines up with the ledger: each tick's synapse changes = at most 255 (bay, Δsignal) pairs · they pack into a single block append (§1d).
• Roomy enough: human brain chemistry adds up to about 150–200 home-grown messengers, neuropeptides, gases and lipids · 255 leaves space for about 50 new, lab-made or outside-substance binding sheets.
• Not a wall: §4.7f spells out how to step up from uint8 to uint16. One schema migration unlocks 65,535 bays when the day comes (signalling at full gene-expression scale, modelling several organisms, strange chemistry).
• Upfront about the framing: today only 5 bays run real math. The other 250 carry names and classes, so levelling one up to ACTIVE is a small fixed job · no rebuild required.

§4.7b · REGISTRY LAYOUT · what one bay looks like

// every slot is the same shape · 5 actives just have populated kinetics
const SYNAPSE_SLOT_SCHEMA = {
  id:            0,                // uint8 · 0..255
  name:          'SEROTONIN',      // canonical SHOUT_CASE name
  aliases:       ['5-HT'],          // shorthand · clinical · trade
  class:         'monoamine',      // taxonomy bucket · drives default rate priors
  transporter:   'SERT',           // KILLER_T cell name · null if diffusion-only
  degrader:      ['MAO-A'],         // TREG enzymes · array · null for non-degraded
  receptors:     ['5-HT1A', '5-HT2A', '5-HT2C', '5-HT3', '5-HT7'],
  kinetics:      SYNAPSE_SCHEMA,    // the 6-var state from §4.5a · null when SCAFFOLDED
  feeds_hormone: 'serotonin',      // which §4.1 readout this synapse drives · null if standalone
  status:        'ACTIVE',         // ACTIVE · SCAFFOLDED · RESERVED · META
  axis:          'STABILITY',      // §4.3 axis assignment
};

// the registry itself · indexed access by slot ID
const SYNAPSE_REGISTRY = new Array(256);
// 0..254 = canonical synapses (5 ACTIVE · ~200 SCAFFOLDED · ~50 RESERVED)
// 255    = META · unmapped signal catch-all

§4.7c · THE FLOOR PLAN · 10 zones

§4.7d · THE ROSTER · official bay assignments

Columns: SHOUT_CASE name · class · pump · breakdown enzyme · status. ACTIVE = hooked into synapseTick() · SCAFFOLDED = signed up, sorted, ready to level up · RESERVED = still free · META = lost-and-found.

0–4 · MONOAMINES · ACTIVE (the official five · see §4.5c)

 0  SEROTONIN          monoamine     · SERT  · MAO-A         · 5-HT1A..5-HT7              · ACTIVE
 1  DOPAMINE           monoamine     · DAT   · MAO-B · COMT  · D1..D5                     · ACTIVE
 2  NOREPINEPHRINE     monoamine     · NET   · MAO-A · COMT  · α1 · α2 · β1 · β2 · β3      · ACTIVE
 3  HISTAMINE          monoamine     · —     · HNMT · DAO    · H1..H4                     · ACTIVE
 4  ACETYLCHOLINE      cholinergic   · CHT1  · AChE          · M1..M5 · nAChR α/β         · ACTIVE

5–9 · AMINO ACID TRANSMITTERS (fast signalling · what the cortex really runs on)

 5  GLUTAMATE          amino_acid    · EAAT1-5  · gln synthase  · NMDA · AMPA · kainate · mGluR1-8
 6  GABA               amino_acid    · GAT1-3   · GABA-T        · GABA-A · GABA-B · GABA-C
 7  GLYCINE            amino_acid    · GlyT1-2  · —             · GlyR · NMDA co-agonist
 8  ASPARTATE          amino_acid    · EAAT     · —             · NMDA agonist
 9  D-SERINE           amino_acid    · ASCT1    · D-AAO         · NMDA co-agonist

10–19 · TRACE AMINES + CATECHOL NEIGHBOURS

10  PEA                trace_amine   · —       · MAO-B         · TAAR1
11  TYRAMINE           trace_amine   · —       · MAO-A/B       · TAAR1 · α-adrenergic indirect
12  TRYPTAMINE         trace_amine   · —       · MAO-A/B       · TAAR1
13  OCTOPAMINE         trace_amine   · —       · MAO-B         · TAAR1 · α-adrenergic
14  AGMATINE           polyamine     · —       · DAO · AGMAT   · imidazoline · α2 · NMDA mod
15  EPINEPHRINE        monoamine     · NET     · MAO-A · COMT  · α/β adrenergic (split from NE for adrenal-source)
16  MELATONIN_BRAIN    indoleamine   · —       · CYP1A2        · MT1 · MT2 (neural slot · distinct from §4.1 hormone)
17  N-METHYL-PEA       trace_amine   · —       · MAO-B         · TAAR1
18  SYNEPHRINE         trace_amine   · —       · MAO            · β-adrenergic
19  3-IODOTHYRONAMINE  thyronamine   · —       · —             · TAAR1 (thyroid-trace bridge)

20–49 · OPIOID PEPTIDES

20  BETA_ENDORPHIN     opioid · POMC-derived   · NEP · ACE  · μ-opioid · δ-opioid
21  ALPHA_ENDORPHIN    opioid · POMC-derived   · NEP        · μ-opioid
22  GAMMA_ENDORPHIN    opioid · POMC-derived   · NEP        · μ-opioid
23  MET_ENKEPHALIN     opioid · proenkephalin  · NEP · APN  · δ-opioid > μ-opioid
24  LEU_ENKEPHALIN     opioid · proenkephalin  · NEP        · δ-opioid > μ-opioid
25  DYNORPHIN_A        opioid · prodynorphin   · DYN-conv   · κ-opioid (dysphoria axis)
26  DYNORPHIN_B        opioid · prodynorphin   · DYN-conv   · κ-opioid
27  ALPHA_NEOENDORPHIN opioid · prodynorphin   · —          · κ-opioid
28  BETA_NEOENDORPHIN  opioid · prodynorphin   · —          · κ-opioid
29  NOCICEPTIN         opioid · pronociceptin  · NEP        · NOP receptor (pain modulation)
30  ENDOMORPHIN_1      opioid · synthesis TBD  · DPP-IV     · μ-opioid (high selectivity)
31  ENDOMORPHIN_2      opioid · synthesis TBD  · DPP-IV     · μ-opioid
32  BIG_DYNORPHIN      opioid · prodynorphin   · DYN-conv   · κ-opioid (long form)
33  RIMORPHIN          opioid · prodynorphin   · —          · κ-opioid
34  LEUMORPHIN         opioid · prodynorphin   · —          · κ-opioid
35  DELTORPHIN         opioid · amphibian-like · —          · δ-opioid (rare endogenous)
36  PROENKEPHALIN      opioid · precursor      · cleaved    · pre-stage marker
37  PRODYNORPHIN       opioid · precursor      · cleaved    · pre-stage marker
38  POMC               precursor · pituitary   · cleaved    · feeds β-endorphin · MSH · ACTH
39  ACTH               peptide · pituitary     · NEP        · MC2R (cortisol release driver)
40-49  RESERVED · opioid family · open for novel endogenous ligands

50–89 · HYPOTHALAMUS + PITUITARY PEPTIDES

50  OXYTOCIN           nonapeptide · OXT       · oxytocinase  · OXTR · vasopressin V1a cross
51  VASOPRESSIN        nonapeptide · AVP       · vasopressinase · V1a · V1b · V2 (ADH)
52  CRH                peptide · paraventricular · CRH-BP   · CRHR1 · CRHR2 (stress axis upstream)
53  TRH                tripeptide · paraventricular · PAP   · TRHR1 (thyroid axis upstream)
54  GnRH               decapeptide · arcuate    · MMP-9    · GnRHR (reproductive axis upstream)
55  GHRH               peptide · arcuate        · DPP-IV   · GHRHR (growth axis upstream)
56  SOMATOSTATIN       peptide · paraventricular · NEP     · SSTR1-5 (inhibitor · brakes GH/TSH/insulin)
57  KISSPEPTIN         peptide · arcuate        · MMP-9    · KISS1R (deep upstream · puberty + GnRH)
58  OREXIN_A           peptide · lateral hypothalamic · — · OX1R · OX2R (wakefulness)
59  OREXIN_B           peptide · lateral hypothalamic · — · OX2R (wakefulness)
60  MCH                peptide · lateral hypothalamic · — · MCHR1 · MCHR2 (appetite + REM sleep)
61  ALPHA_MSH          peptide · POMC-derived   · NEP      · MC3R · MC4R (appetite suppression)
62  BETA_MSH           peptide · POMC-derived   · NEP      · MC4R
63  GAMMA_MSH          peptide · POMC-derived   · NEP      · MC3R · MC5R
64  ANP_NEURAL         peptide · atrial-brain   · NEP      · NPR-A (natriuretic · neural slot)
65  BNP                peptide · brain          · NEP      · NPR-A (cardiac stress)
66  CNP                peptide · endothelium    · NEP      · NPR-B
67  ADRENOMEDULLIN     peptide · adrenal/neural · NEP      · CRLR + RAMP2/3
68  NEUROTENSIN        peptide · diffuse        · NEP      · NTSR1-3
69  NEUROMEDIN_N       peptide · diffuse        · NEP      · NTSR2
70  NEUROMEDIN_B       peptide · diffuse        · NEP      · BB1 (smooth muscle + CNS)
71  NEUROMEDIN_U       peptide · diffuse        · —        · NMUR1 · NMUR2
72  RELAXIN_3          peptide · nucleus incertus · —      · RXFP3 (arousal · feeding · stress)
73  PROLACTIN_NEURAL   protein · pituitary slot · —        · PRLR (neural form · §4.1 has body form)
74  GH_NEURAL          protein · pituitary slot · IDE      · GHR (neural form)
75  LH                 glycoprotein · pituitary · —        · LHCGR (gonadal trigger)
76  FSH                glycoprotein · pituitary · —        · FSHR (gonadal trigger)
77  TSH                glycoprotein · pituitary · —        · TSHR (thyroid trigger)
78  PRL_BINDING_PEPT   modulator    · pituitary · —        · prolactin regulator
79  GALANIN_LIKE_PEPT  peptide · arcuate        · —        · GALR1 · GALR2 (feeding · GnRH)
80-89  RESERVED · hypothalamic/pituitary headroom

90–129 · TACHYKININS + HUNGER + GUT-TO-BRAIN PEPTIDES

90  SUBSTANCE_P        tachykinin · TAC1     · NEP · ACE   · NK1R (pain + emotion)
91  NEUROKININ_A       tachykinin · TAC1     · NEP         · NK2R
92  NEUROKININ_B       tachykinin · TAC3     · NEP         · NK3R
93  NEUROPEPTIDE_K     tachykinin · TAC1     · NEP         · NK2R
94  NEUROPEPTIDE_GAMMA tachykinin · TAC1     · NEP         · NK2R
95  HEMOKININ_1        tachykinin · TAC4     · NEP         · NK1R (peripheral immune)
96  ELEDOISIN          tachykinin · external · —           · NK2R (homolog · scaffolded for completeness)
97  NPY                peptide · arcuate     · DPP-IV      · Y1 · Y2 · Y4 · Y5 (appetite · anxiolysis)
98  PYY                peptide · L-cells     · DPP-IV      · Y2 (fullness)
99  PP                 peptide · pancreas    · DPP-IV      · Y4 (pancreatic polypeptide · satiety)
100 CCK                peptide · I-cells     · TACE        · CCK1R · CCK2R (satiety · gut-brain)
101 GLP_1              peptide · L-cells     · DPP-IV      · GLP1R (satiety + insulin)
102 GLP_2              peptide · L-cells     · DPP-IV      · GLP2R (gut growth)
103 GIP                peptide · K-cells     · DPP-IV      · GIPR (insulin trigger)
104 GASTRIN            peptide · G-cells     · —           · CCK2R (acid secretion)
105 SECRETIN           peptide · S-cells     · —           · SCTR (bicarbonate)
106 MOTILIN            peptide · M-cells     · —           · MLNR (gut motility)
107 GHRELIN_NEURAL     peptide · arcuate     · —           · GHSR (hunger · neural slot)
108 OBESTATIN          peptide · stomach     · —           · GPR39 (anti-ghrelin)
109 LEPTIN_NEURAL      protein · adipose-brain · —         · LEPR (satiety · neural slot)
110 ADIPONECTIN        protein · adipose     · —           · AdipoR1 · AdipoR2 (efficiency)
111 AMYLIN             peptide · β-cells     · —           · AMY1-3 (slow glucose)
112 GALANIN            peptide · diffuse     · —           · GALR1 · GALR2 · GALR3 (calming)
113 CART               peptide · arcuate     · —           · GPR160 (reward · satiety)
114 AgRP               peptide · arcuate     · —           · MC3R/MC4R antagonist (hunger)
115 POMC_NEURAL        precursor · arcuate   · cleaved     · feeds α-MSH · β-endorphin (satiety neural)
116 CGRP               peptide · trigeminal  · —           · CALCRL + RAMP1 (migraine · vasodilation)
117 CALCITONIN_NEURAL  peptide · C-cells     · —           · CTR (calcium · neural slot)
118 ADRENOMEDULLIN_2   peptide · brain       · —           · CRLR + RAMP1/2/3
119 INTERMEDIN         peptide · brain       · —           · CRLR (cardiovascular regulation)
120 VIP                peptide · suprachiasm · —           · VPAC1 · VPAC2 (circadian · vasodilation)
121 PACAP              peptide · diffuse     · —           · PAC1 · VPAC1/2 (stress + neuroprotection)
122 GLUCAGON_NEURAL    peptide · α-cells     · DPP-IV      · GCGR (energy mobilize · neural slot)
123 SECRETIN_FAMILY    peptide group         · —           · multi-receptor (umbrella slot)
124 RFRP_3             peptide · DMH         · —           · NPFFR1 (GnRH brake)
125 QRFP_26RFa         peptide · LH/VMH      · —           · QRFPR (appetite stimulant)
126 KISSPEPTIN_RELATED peptide family        · —           · KISS1R variants
127 COCAINE_AMPH_REG   CART variant         · —           · GPR160 (CART-3 form)
128 BRS_3_LIGAND       peptide · orphan      · —           · BRS3 (bombesin receptor 3 · metabolic)
129 NESFATIN_1         peptide · NUCB2-derived · —         · unknown receptor (satiety · anxiety)

130–159 · GASES · PURINES · ENDOCANNABINOIDS · LIPID MESSENGERS

130 NITRIC_OXIDE       gas         · NOS1/2/3 · spontaneous   · sGC + diffusion (retrograde signal)
131 CARBON_MONOXIDE    gas         · HO-1/2   · spontaneous   · sGC (heme-derived signaling)
132 HYDROGEN_SULFIDE   gas         · CBS · CSE · spontaneous · K-ATP channels (slow signaling)
133 AMMONIA            gas         · multiple · GS            · pH + NMDA modulation
134 ATP                purine      · vesicular · ectonucleotidases · P2X · P2Y
135 ADP                purine      · ATP-derived · ENTPDs    · P2Y12
136 AMP                purine      · derived  · NT5E         · adenosine precursor
137 ADENOSINE          purine      · ENT1/2   · ADA          · A1 · A2A · A2B · A3 (caffeine antagonist target)
138 GUANOSINE          purine      · ENT      · PNP          · GPR (orphan · neuroprotection)
139 GTP                purine      · vesicular · NTPDase     · P2Y
140 cAMP_EXTRA         second-msg  · PDEs     · degraded     · extracellular adenosine source
141 cGMP_EXTRA         second-msg  · PDEs     · degraded     · extracellular guanosine source
142 ANANDAMIDE         endocannab  · — (on-demand) · FAAH    · CB1 · CB2 · TRPV1
143 AG_2               endocannab  · — (on-demand) · MAGL    · CB1 · CB2 (most abundant)
144 NOLADIN_ETHER      endocannab  · trace    · FAAH         · CB1
145 VIRODHAMINE        endocannab  · trace    · FAAH         · CB1 antagonist · CB2 agonist
146 NADA               endocannab  · trace    · FAAH         · CB1 · TRPV1 (N-arachidonoyl dopamine)
147 PEA_ETHANOLAMIDE   endocannab-like · —    · FAAH         · PPAR-α (palmitoylethanolamide)
148 OLEAMIDE           lipid       · —        · FAAH         · CB1 (sleep-induction)
149 OEA                lipid       · —        · FAAH         · PPAR-α (satiety · oleoylethanolamide)
150 LPA                lipid       · ATX      · LPP          · LPA1-6 (neurite growth)
151 S1P                lipid       · SK1/2    · S1P-lyase    · S1PR1-5 (neural differentiation)
152 PGE2               eicosanoid  · COX-1/2  · 15-PGDH      · EP1-4 (fever · inflammation)
153 PGD2               eicosanoid  · COX-1/2  · 15-PGDH      · DP1 · DP2 (sleep · allergy)
154 PGF2_ALPHA         eicosanoid  · COX-1/2  · 15-PGDH      · FP (smooth muscle)
155 LTB4               eicosanoid  · LOX-5    · —            · BLT1 · BLT2 (chemotaxis)
156 LTC4_D4_E4         eicosanoid  · LOX-5    · —            · CysLT1 · CysLT2 (bronchoconstriction)
157 THROMBOXANE_A2     eicosanoid  · COX/TXAS · —            · TP (vasoconstriction)
158 RESOLVIN_E1        resolvin    · LOX-5/15 · —            · ChemR23 (inflammation resolution)
159 PROTECTIN_D1       protectin   · LOX-15   · —            · resolution mediator

160–189 · NEUROSTEROIDS · CYTOKINES · NEUROTROPHINS

160 ALLOPREGNANOLONE   neurosteroid · 3α-HSD/5α-red · —    · GABA-A PAM (anxiolytic · sedative)
161 PREGNENOLONE       neurosteroid · CYP11A1     · —      · sigma-1 · GABA-A modulator
162 PREGNENOLONE_S     neurosteroid · sulfotrans  · —      · NMDA positive · GABA-A negative
163 DHEA_NEURAL        neurosteroid · CYP17       · —      · sigma-1 · NMDA · GABA-A neg
164 DHEA_S             neurosteroid · sulfotrans  · steroid sulfatase · sigma-1
165 ESTRADIOL_NEURAL   neurosteroid · aromatase   · CYP    · ERα · ERβ · GPER (neuroprotection)
166 ESTRONE            neurosteroid · 17β-HSD     · CYP    · ERα · ERβ
167 ESTRIOL            neurosteroid · placental   · CYP    · ERα · ERβ (pregnancy)
168 TESTOSTERONE_NRL   neurosteroid · CYP17       · CYP    · AR · aromatized to estradiol
169 DHT                neurosteroid · 5α-reductase · CYP   · AR (high affinity)
170 PROGESTERONE_NRL   neurosteroid · 3β-HSD      · —      · PR · GABA-A via metabolite
171 CORTISOL_NEURAL    neurosteroid · 11β-HSD1    · 11β-HSD2 · GR · MR (neural slot · §4.1 has systemic)
172 CORTICOSTERONE     neurosteroid · CYP11B1     · —      · GR · MR
173 ALDOSTERONE        neurosteroid · CYP11B2     · —      · MR (fluid axis)
174 IL_1_BETA          cytokine    · processed by caspase-1 · IL-1R1 (fever · sickness behavior)
175 IL_6               cytokine    · multi-source · —      · IL-6R + gp130 (acute-phase)
176 IL_10              cytokine    · Treg · M2    · —      · IL-10R (anti-inflammatory)
177 IL_18              cytokine    · processed by caspase-1 · IL-18R (IFN-γ inducer)
178 TNF_ALPHA          cytokine    · macrophage  · sTNF-R  · TNFR1 · TNFR2 (apoptosis · inflammation)
179 IFN_GAMMA          cytokine    · NK · Th1    · —       · IFNGR1/2 (antiviral)
180 IFN_ALPHA          cytokine    · pDC         · —       · IFNAR1/2 (antiviral · type I)
181 BDNF               neurotrophin · multiple   · MMP-9   · TrkB · p75NTR (LTP · plasticity)
182 NGF                neurotrophin · multiple   · —       · TrkA · p75NTR (sympathetic + sensory)
183 GDNF               neurotrophin · glia       · —       · GFRα1 + RET (dopaminergic)
184 CNTF               neurotrophin · glia       · —       · CNTFR (motor neurons)
185 NT_3               neurotrophin · multiple   · —       · TrkC
186 NT_4_5             neurotrophin · multiple   · —       · TrkB
187 FGF_2              growth-fact · multiple   · —       · FGFR1-4 (neurogenesis)
188 IGF_1              growth-fact · liver-brain · —      · IGF1R (growth · repair)
189 EPO_BRAIN          cytokine    · kidney-brain · —     · EPOR (neuroprotection)

190–209 · RARE HOME-GROWN + TRACE

190 D_ASPARTATE        amino_acid  · ASCT2     · D-AAO       · NMDA agonist (developmental)
191 NAAG               dipeptide   · NAALADase · NAALADase  · mGluR3 agonist · NMDA modulator
192 KYNURENIC_ACID     tryptophan-deriv · KAT  · —          · NMDA antagonist · α7 nAChR antagonist
193 QUINOLINIC_ACID    tryptophan-deriv · KMO  · —          · NMDA agonist (excitotoxic)
194 HOMOCYSTEIC_ACID   amino_acid  · trace     · —           · NMDA agonist (rare)
195 TAURINE            amino_acid  · TauT      · —           · GABA-A · glycine receptor
196 BETA_ALANINE       amino_acid  · TauT      · —           · GlyR weak · GABA-A modulator
197 GHB_ENDOGENOUS     SCFA        · GHB synthase · GHB-DH   · GHB-R · GABA-B (sleep regulation)
198 DMT_TRACE          indoleamine · INMT · trace · MAO-A   · 5-HT2A · sigma-1 (endogenous trace)
199 FIVE_MEO_DMT_TRACE indoleamine · INMT · trace · MAO-A   · 5-HT1A > 5-HT2A
200 BUFOTENIN          indoleamine · INMT · trace · MAO-A   · 5-HT2A · 5-HT1A (endogenous trace)
201 HORDENINE          trace_amine · —        · MAO         · TAAR1 (very trace)
202 SALSOLINOL         TIQ alkaloid · dopamine-aldehyde · — · μ-opioid + D-receptor
203 TETRAHYDRO_IQ      TIQ alkaloid · catechol + aldehyde · — · trace · alcohol metabolism
204 PINOLINE           β-carboline · trace    · MAO         · 5-HT2A · MAO inhibitor
205 HARMAN             β-carboline · trace    · MAO         · MAO-A inhibitor (very trace)
206 ADRENOCHROME       oxidized epi · trace   · —           · debated · trace marker
207 AGMATINE_2         polyamine   · trace    · DAO         · imidazoline (overlap w/ slot 14)
208 CARNOSINE          dipeptide   · carnosine synthase · — · weak · pH buffer
209 ANSERINE           dipeptide   · trace    · —           · weak · related to carnosine

210–244 · OUTSIDE-SUBSTANCE BINDING SHEETS (not made by the body. Each bay stores a drug→receptor sheet for §4.6 APPLY)

210 LSD                psychedelic · — · — · 5-HT2A partial agonist · 5-HT2C · 5-HT1A · D2
211 PSILOCIN           psychedelic · — · — · 5-HT2A agonist · 5-HT2C · 5-HT1A
212 DMT_EXOGENOUS      psychedelic · — · MAO-A (rapid) · 5-HT2A · sigma-1
213 MESCALINE          psychedelic · — · MAO · 5-HT2A · 5-HT2C
214 MDMA               entactogen  · SERT release + reuptake · MAO substrate · 5-HT2A · oxytocin release
215 MDA                entactogen  · SERT release · MAO · 5-HT2A · slightly more psychedelic than MDMA
216 KETAMINE           dissociative · — · CYP2B6/3A4 · NMDA antagonist · κ-opioid weak · BDNF↑
217 ESKETAMINE         dissociative · — · CYP · NMDA antagonist (higher affinity than ketamine)
218 PCP                dissociative · — · CYP · NMDA antagonist · sigma · D2
219 DXM                dissociative · — · CYP2D6 · NMDA antagonist · sigma · SERT
220 NITROUS_OXIDE      dissociative · diffusion · exhaled · NMDA antagonist · κ-opioid
221 THC                cannabinoid · — · CYP2C9/3A4 · CB1 partial agonist · CB2
222 CBD                cannabinoid · — · CYP3A4/2C19 · CB1 NAM · 5-HT1A · TRPV1 · GPR55
223 NICOTINE           stimulant   · — · CYP2A6 · nAChR α4β2 + α7 agonist (acute) → desensitize (chronic)
224 CAFFEINE           stimulant   · — · CYP1A2 · A1 + A2A adenosine antagonist · weak PDE inhibitor
225 THEOPHYLLINE       stimulant   · — · CYP1A2 · adenosine antagonist · PDE inhibitor
226 ALCOHOL            depressant  · — · ADH/ALDH · GABA-A PAM · NMDA antagonist · 5-HT3 · glycine
227 GHB_EXOGENOUS      depressant  · — · GHB-DH · GHB-R · GABA-B agonist
228 BENZODIAZEPINE     depressant  · — · CYP3A4 · GABA-A α1/2/3/5 PAM at BZ site
229 BARBITURATE        depressant  · — · CYP · GABA-A PAM (different site) · direct opener at high dose
230 Z_DRUG             depressant  · — · CYP3A4 · GABA-A α1 PAM (zolpidem · zopiclone class)
231 OPIOID_MU          opioid agonist · — · CYP · μ-opioid full agonist (morphine · oxycodone · fentanyl)
232 OPIOID_KAPPA       opioid agonist · — · — · κ-opioid agonist (salvinorin A · dynorphin mimics)
233 OPIOID_DELTA       opioid agonist · — · — · δ-opioid agonist (analgesia · less euphoric)
234 BUPRENORPHINE      opioid mixed · — · CYP3A4 · μ partial agonist · κ antagonist (treatment)
235 NALOXONE           opioid antag · — · — · μ · κ · δ antagonist (reversal)
236 NALTREXONE         opioid antag · — · — · μ > κ antagonist (treatment · sustained)
237 AMPHETAMINE        stimulant · DAT/NET REVERSE-TRANSPORT release · MAO inhibitor · TAAR1
238 METHAMPHETAMINE    stimulant · DAT/NET reverse-transport · 5-HT release · higher CNS penetration
239 COCAINE            stimulant · DAT/SERT/NET reuptake inhibitor · Na-channel local anesthetic
240 MODAFINIL          eugeroic   · DAT weak inhibitor · orexin · histamine release
241 METHYLPHENIDATE    stimulant · DAT/NET inhibitor (Ritalin)
242 AMPHETAMINE_MIXED  stimulant · DAT/NET release (Adderall · d+l isomers)
243 IBOGAINE           complex · NMDA · κ-opioid · SERT · α3β4 nAChR · 5-HT2A (anti-addiction)
244 SCOPOLAMINE        anticholinergic · — · CYP · muscarinic M1 antagonist (rapid antidepressant probe)

245–254 · RESERVED (free bays · new · not yet discovered · per-user custom signals · a7 took 3 of them)

245 RESISTIN           adipokine   · adipose tissue · —      · CAP1 · TLR4 (pipeline friction · §4.1d) · a7
246 HEPCIDIN           peptide     · liver          · —      · ferroportin (gatekeeping intake · §4.1d) · a7
247 FGF21              growth-fact · liver-brain    · —      · FGFR1c + β-Klotho (stress-forge · §4.1d · companion to FGF_2 at #187) · a7
248-254  RESERVED · open · contributors may register · class TBD · status RESERVED

255 · META · UNMAPPED_SIGNAL (lost-and-found · hands off to the §1e META layer)

255 UNMAPPED_SIGNAL    meta · any signal whose ID is not yet classified · routes to META verify pipeline

§4.7e · HOW A BAY LEVELS UP · SCAFFOLDED → ACTIVE

A framed-out bay goes live once all three boxes are ticked:

• Its kinetics are filled in: the bay's kinetics object carries every one of the 6 §4.5a numbers, none left null.
• It powers something: feeds_hormone links to a §4.1 read, or axis adds a new direction that §4.3 has written down.
• Its honesty homework is done: every rate number says where it came from (a paper, a worked-out rule of thumb, or a plain [ stub ] tag).

// promotion is a single function call · idempotent · auditable
function promoteSlot(slot_id, kinetics, feed) {
  const slot = SYNAPSE_REGISTRY[slot_id];
  if (slot.status !== 'SCAFFOLDED') return BE(log, 'PROMOTION_REJECTED');
  slot.kinetics      = kinetics;
  slot.feeds_hormone = feed;
  slot.status        = 'ACTIVE';
  slot.promoted_at   = Date.now();
  return BE(() => commitBlock({ event: 'SLOT_PROMOTED', slot_id }), 'SLOT_ACTIVE');
}

§4.7f · ROOM TO GROW · uint8 → uint16 (only when it's needed)

255 covers human brain chemistry with room left over. Only three situations call for a bigger register:

• Custom signals per user: once instances start adding their own area-specific synapses (think made-up brand-mood messengers for a studio), 250 spare bays run out quickly.
• Modelling many bodies: if the META layer rolls data up across users or areas, each instance may hold its own block of 255 and the combined network needs uint16.
• A registry split by receptor: right now each bay holds one messenger; giving every messenger × receptor pair its own bay takes 2000+ rows → uint16.

Moving over is routine: grow SYNAPSE_REGISTRY from Array(256) to Array(65536), let bay 65535 take over the META role, and leave bays 0–254 exactly as they are. The layout's id field gets wider. Blocks pick up one byte that records registry width, so older blocks still read fine. And if the move goes sideways, R9 detect-and-rollback still has your back.

§4.7g · LIMITS · what the registry is not

• Bay numbers never move after they ship: renumbering a bay later would wreck LEDGER replay (R9). Holding, retiring and migrating all use fresh bay IDs and never write over an old one.
• The class labels are a working sort, not the final word. Some messengers wear several hats (estradiol is a neurosteroid, a hormone and a receptor ligand all at once): a bay's main class is whichever job dominates in brain signalling.
• The receptor lists are examples; for most peptides, science still hasn't fully mapped their receptors. The simulation tracks whether a receptor family exists, not its full breakdown into subtypes.
• The outside-substance sheets (210–244) aren't the body's own chemistry. They're drug→receptor maps that let APPLY aim at the same bay system the body's own signals use. The drug in bay 210 (LSD) nudges bay 0's receptors (serotonin) by binding 5-HT2A.
• Levelling all 255 bays up to ACTIVE isn't on the roadmap. The promise is only that each bay is ready and waiting if a future study, dataset or in-game system wants it.

§4.8 · COHERENCY · receptors that adapt on five clocks · the spec 4.0 headliner

Back in §4.5b, receptor change was just one straight delay (one variable · one rate · 0.0012 each tick). That shortcut came from spec 3.2, and §4.6d already confessed that "in a real body at least five clocks tangle together." Spec 4.0 unpacks the shortcut. The lone receptor_density number splits into five variables stacked in a cascade, each on its own biological clock, each gating the one after it. The simulation picks up a new measured state too. Coherency tells you how well those five clocks agree at any instant.

§4.8a · THE ONE-DELAY FIB · where spec 3.2 a5 cut corners

Here's what the spec 3.2 a5 synapse tick (step 5 of §4.5b) did:

// v3.2 a5 · single-lag receptor adaptation · accurate in shape, wrong in tempo
const target_density = 1 - (exposure - 0.40) * 0.70;
syn.receptor_density += (target_density - syn.receptor_density) * 0.0012;

A single rate, a single variable. It shows "receptors dial down when exposure stays high", yet it completely misses:

• Quick desensitizing · a GPCR lets go of its G-protein within seconds (way quicker than any lone 0.0012-per-tick delay can show).
• Receptors pulled inside · β-arrestin drags tagged receptors off the surface within minutes · still there, just out of sight.
• Destroy it or send it back · across hours to days, the cell decides whether a pulled-in receptor gets recycled to the surface or broken down.
• Gene-level change · shifts in gene expression alter how fast brand-new receptors get built, over days to weeks.
• Rewiring · the synapse itself reshapes · dendritic spines grow and shrink · the circuits downstream reweight themselves across weeks to months.

Every one of those is its own variable with its own rate. They talk to each other · each clock feeds the next, slower one. Spec 4.0 gives that cascade a name.

§4.8b · THE FIVE CLOCKS

The delay is counted per 3000ms simulation tick. Time to settle ≈ 4 / lag ticks · times 3 seconds for real time. Clock 1 settles in roughly 4 simulated minutes · clock 5 in roughly 7 simulated days. What makes the cascade feel biological is the gap between clocks (10× at every step).

§4.8c · THE CASCADE · every clock gates the next

// v4.0 · five-timescale receptor adaptation · replaces single-lag in §4.5b step 5
function adaptReceptors(syn) {
  const exposure = syn.synaptic_conc;

  // SCALE 1 · COUPLING — fastest · driven directly by exposure (seconds-minutes)
  const coupling_target = 1 - (exposure - 0.40) * 0.80;
  syn.coupling += (coupling_target - syn.coupling) * 0.0500;

  // SCALE 2 · SURFACE_COUNT — gated by coupling · β-arrestin response (minutes-hours)
  const surface_target = clamp(syn.coupling * 1.05, 0.30, 1.10);
  syn.surface_count += (surface_target - syn.surface_count) * 0.0050;

  // SCALE 3 · TOTAL_COUNT — gated by surface_count · degrade-or-recycle (hours-days)
  const total_target = clamp(syn.surface_count * 1.02, 0.30, 1.20);
  syn.total_count += (total_target - syn.total_count) * 0.0005;

  // SCALE 4 · SYNTH_RATE — gated by total_count · gene expression (days-weeks)
  const synth_target = clamp(syn.total_count * 1.00, 0.40, 1.20);
  syn.synth_rate += (synth_target - syn.synth_rate) * 0.00005;

  // SCALE 5 · CIRCUIT_WEIGHT — gated by synth_rate · structural plasticity (weeks-months)
  const circuit_target = clamp(syn.synth_rate * 1.00, 0.50, 1.10);
  syn.circuit_weight += (circuit_target - syn.circuit_weight) * 0.000005;

  return BE(null, 'RECEPTORS_ADAPTED');
}

Every clock is held in check by the one above it. No slow clock wanders off solo. Over their own settle time, the slow clocks carry a memory of the fast ones. That is where coherency comes from: when things are settled, all five variables land on the same number, because each one is aiming at the next.

§4.8d · EFFECTIVE RECEPTOR DENSITY · all five multiplied

// the readout that synapseReadout() now uses · replaces syn.receptor_density
function effectiveDensity(syn) {
  const surface_ratio = syn.surface_count / Math.max(syn.total_count, 0.01);
  return syn.coupling
       * surface_ratio
       * syn.total_count
       * syn.synth_rate
       * syn.circuit_weight;
}

// synapseReadout from §4.5a · now multiplied by full cascade
function synapseReadout(syn) {
  return syn.synaptic_conc * effectiveDensity(syn) * syn.receptor_sensitivity;
}

Five numbers get multiplied together. Let one crash and the signal crashes with it. Keep all five lined up and the signal is simply whatever the gap concentration delivers. That's the molecular root of tolerance (the slow numbers sink), withdrawal (the fast numbers are back but the slow ones aren't yet), and recovery (the slow numbers finally catch up).

§4.8e · THE COHERENCY SCORE · how far the clocks disagree

// coherency · how aligned the 5 scales are · the v4 anchor reading
function coherency(syn) {
  const scales = [
    syn.coupling,
    syn.surface_count,
    syn.total_count,
    syn.synth_rate,
    syn.circuit_weight,
  ];
  const mean = scales.reduce((a, b) => a + b, 0) / scales.length;
  const variance = scales.reduce((sum, x) => sum + (x - mean) ** 2, 0) / scales.length;
  return clamp(1 - variance * 4, 0, 1);  // 1 = aligned · 0 = scattered
}

// system-wide coherency · average across all ACTIVE synapses
function systemCoherency() {
  const active = SYNAPSE_REGISTRY.filter(s => s?.status === 'ACTIVE');
  return active.reduce((sum, s) => sum + coherency(s.kinetics), 0) / active.length;
}

§4.8f · COHERENCY as HORMONE read number 21

Coherency for the whole system joins HORMONES (§4.1) as a measured read. Number 21 (next to the first 11, the craft pack of 4 and the brain-messenger band of 5).

const HORMONES = {
  // ... 20 readouts from a3 + a4 ...
  coherency: 0.78,   // system stability across timescales · 1 = settled · 0 = discordant
};

// regulateHormones() adds the coherency readout each tick
function regulateCoherencyReadout() {
  HORMONES.coherency += (systemCoherency() - HORMONES.coherency) * 0.35;
}

Coherency gets its own fresh axis · the §4.3 COHERENCY axis (number 9, next to the eight already there). No other axis has just one read in it, because coherency is how well everything else lines up.

§4.8g · THREE FRESH MOODS · powered by coherency

Slotted into the §4.2 priority table between INFLAMED and STRESSED:

DISCORDANT and TRANSITIONING outrank STRESSED because a body that's changing tells you more than a body that's simply busy. SETTLED sits down near ELATED in rank, yet it's the one mood that demands coherency held over time, which makes it the loudest "you can believe this signal" light the system has.

§4.8h · REPLAY TAPE · an SSRI run with all five clocks

Spot the lopsidedness: starting the drug gives a short DISCORDANT blip (one hour) and then weeks of TRANSITIONING. Stopping it gives a far longer DISCORDANT stretch, because the slow clocks (synth, circuit) are still tuned for the drug while the quick clock (coupling) has already bounced back. That is SSRI discontinuation syndrome at the molecular level. The coherency model produces it without a single line of special-case code.

§4.8i · LIMITS · what COHERENCY is not

• The tick rates (0.05, 0.005, 0.0005, 0.00005, 0.000005) are for show · picked so the cascade unfolds at a believable pace, not pulled from receptor lab studies.
• For now each clock's "gate" is a plain multiplier (* 1.05, * 1.02, and so on) · real chatter runs through second messengers (cAMP, Ca²⁺) and gene switches (CREB, ΔFosB) this manual never names.
• Taking the variance of 5 numbers between 0 and 1 is a rough stand-in for "is the system lined up?" Sharper scores (mutual information between clocks, phase coherence) are saved for spec 5.0.
• Receptor variety gets ignored · every 5-HT2A receptor in bay 0 counts as one crowd. Inside a real body, a single cluster holds a huge range of receptor states.
• The [ sim ] tag still sticks · none of this is medical. Spec 4.0 makes the outline more truthful, not the size.

Each function in the codebase ought to fit one of these moves. If it won't fit, either it's filed under the wrong label or it's doing two jobs and needs splitting in half.

APPLY is the lone move that starts outside the body. Every other move is the system steering itself; APPLY is the push from outside. §4.6 uses it to model mind-altering drugs by shifting the reuptake (KILLER_T) and breakdown (TREG) rates. It never pokes the hormone read directly.

FUNCTIONS · move + cell_type / move + tier

expressScoutCell(sub, emission)            // cell EXPRESS-es its DNA
gateMnpiSignal(packet)                     // KILLER_T GATEs MNPI
transcribeIntakeDirective(cmd, dna_new)   // commander TRANSCRIBEs
rememberQuorumArtifact(artifact)          // MEMORY_T REMEMBERs
distillSessionEngine(engine)              // engine DISTILLs to kernel
wakeKernel(kernel_name)                    // kernel WAKEs at boot
archiveQualifiedArtifact(a)               // SELF ARCHIVEs the survivor
pruneStaleArtifact(a, now)                 // SELF PRUNEs the unused

STATE VARIABLES · tier + idea

• cellPopulationByType: how many of each cell type are alive right now
• dnaVersionByCommander: the map of today's dna_version numbers
• hormonalLevels, where the Oracle's dials sit right now
• somaticMarker: the mood phrase showing right now
• artifactRegistry: the engine's memory shelf
• kernelSeeds: seeds that survive to the next boot
• selfArchive: the long-term vault (what DEEP STORE produces)
• prunedAt: a time-stamped log of recent shreds (open to audit)

CONSTANTS · SHOUT_CASE + tier

• STEM_POOL_SIZE: how much the unity mesh can hold
• CORTISOL_GATE_THRESHOLD: how stress moves a gate
• CELL_TYPES: the full list of cell kinds
• DNA_LIFETIME_MS: how long an order lasts before it's written again
• KERNEL_TTL_MS: how far into the future a kernel sticks around
• SELF_ARCHIVE_THRESHOLD: the completeness a thing needs to enter the vault
• SELF_PRUNE_AGE_MS: how long something can sit unused before it's shredded

Telling the truth is part of the deal with whoever's watching. The usual industry "production-ready" label is a fib. Choose the sticker that matches reality.

• Downhill (orders): a floor may call the floor right under it. DNA gives cells orders; cells give organs orders; organs give emotions orders; and on down the line.
• Uphill (reports): a floor reports to the floor right over it. Cells → organs → emotions → memory → kernels → SELF.
• Loop-back (growing up): the SELF→DNA route is the only one allowed to jump several floors. It's the on-purpose growth loop, so it has to be out in the open (logged and versioned). Memory engines boil down into kernels, kernels boil down into the vault, and the vault offers up ideas for rewriting DNA.
• Off-limits: a helper never edits a chief. A kernel never calls a cell straight. Skipping floors is banned, apart from the one written-down growth loop.

Molecular Coding stitches things together; it didn't invent them. Thirty-five different schools of work, woven into one way of writing code.

Weaving it all into one house style that hangs together: that part is what Drewless brings. Naming the stack, enforcing it function by function, insisting on cell types, DNA versions and BE labels, turning the watermark into a mood badge, writing vault + shred as named policies. None of it is computer science. It's engineering culture, and that's valuable in its own way.

This manual has carried immune parts ever since spec 3.0. APC · KILLER_T · MEMORY_T · HELPER_T · TREG already form the attack-or-tolerate pipeline built into the R1 cell types. Spec 3.2 a4 parked cytokines in framed-out §4.7 bays (#174-180: IL-1β · IL-6 · IL-10 · IL-18 · TNF-α · IFN-γ · IFN-α). Spec 4.0 tied the 30-hormone panel and the synapse machinery together through COHERENCY (§4.8). Spec 4.0 a1 names the defense crew that runs through every one of those pieces. It brings 5 layers, a 12-cell roster (5 already here + 7 fresh), five fresh moves, three fresh laws, fifteen attack-to-defense pairings, an antibody registry built like the synapse registry, and a section on what this layer does and does not do.

§11.1 · THE FIVE DEFENSE LAYERS

§11.2 · THE CELL ROSTER · 5 veterans + 7 rookies = 12

§11.3 · FIVE FRESH MOVES · the §5 list goes from 18 to 23

• NEUTRALIZE: grab one threat and shut it down (ANTIBODY or CD8 kill)
• OPSONIZE: flag a target so PHAGE_T can swallow it
• PHAGOCYTOSE: swallow it and break it down in a sandbox
• ATTEST: sign a hash of the code + state right now for the audit trail (MHC_I/II · powers R14)
• ESCALATE: shout a cytokine alarm + steer the response with chemokines

§11.4 · THREE FRESH LAWS · the §3 list goes from 13 to 16

• R14 · MHC_I ATTESTATION PER TICK: each cell signs its code + state hash every tick · a mismatch means something got in
• R15 · ANTIBODY IMMUTABILITY, after publishing, an antibody can be retired but never edited · keeps R8 whole
• R16 · TOLERANCE CHECK BEFORE PROMOTION: every new detector has to clear the known-good panel · stops the body attacking itself

§11.5 · ATTACK → DEFENSE · 15 kinds of hack and virus

§11.6 · THE ANTIBODY REGISTRY · 256 bays · a twin of §4.7

Antibodies are full-status artifacts, and they need byte-sized addresses for the very reasons synapses do (see R10): O(1) lookups · cache-happy · ledger-happy · and spreading them works like spreading a drug load, one 256-slot sweep per tick.

// every antibody slot · same shape · stable once published (R15)
const ANTIBODY_SLOT_SCHEMA = {
  id:            0,                       // uint8 · 0..255 (parallel namespace to §4.7 synapses)
  name:          'XSS_GENERIC_SCRIPT_TAG',  // canonical SHOUT_CASE
  threat_class:  'injection',              // taxonomy bucket
  signature:     /<script[^>]*>/,           // detector primitive · regex · ML model · hash · etc.
  affinity:      0.92,                    // confidence · used by R11 effective density
  parent_b_cell: 'BCELL_PROD_2',           // who synthesized this (audit trail)
  status:        'ACTIVE',                  // ACTIVE · SCAFFOLDED · SUPERSEDED · RESERVED
  supersedes:    null,                     // older slot ID if this replaces an earlier antibody (R15)
  ttl:           90 * DAY_MS,             // auto-deprecate after this · re-validation refreshes
  federation:    'LOCAL',                   // LOCAL · SHARED_TRUSTED · SHARED_OPEN (v5 frontier)
};

// allocation map · 10 ranges · mirrors §4.7 structure
 0-19    INJECTION         xss · sql-i · ssrf · path-traversal · prompt-injection
20-39    AUTH              credential-stuffing · session-hijack · csrf · clickjacking
40-59    EXFIL             data egress patterns · DNS exfil · timing channels
60-79    MALWARE           binary signatures · behavior patterns · ransomware
80-99    SUPPLY_CHAIN      dep hash drift · maintainer takeover patterns
100-119  PHISHING_SOCIAL   domain typosquats · spoofed senders · prompt manipulation
120-139  RATE_ANOMALY      brute force · ddos · scraping patterns
140-159  INSIDER           privilege drift · access pattern anomalies
160-179  PROTOCOL          replay · downgrade · injection at protocol layer
180-199  ZERO_DAY          B_CELL-generated novel patterns · pending tolerance check
200-244  RESERVED          open for novel threat classes
245-254  PER_USER_CUSTOM   instance-specific antibodies · not federation-shared by default
255      UNMAPPED_THREAT   catch-all · routes to META layer §1e for triage

§11.7 · SNAPPING INTO SPEC 4.0 · the immune crew fits parts that already exist

• Cytokines move into §4.7 bays #174-180: IL-1β · IL-6 · IL-10 · IL-18 · TNF-α · IFN-γ · IFN-α are already framed out as SCAFFOLDED. The §4.7e level-up route (SCAFFOLDED → ACTIVE) hooks up their kinetics. Immune signalling asks for zero new synapse bays. It just switches on the ones sitting there.
• An immune response plays out on all 5 clocks (§4.8 COHERENCY). The instant response = the COUPLING clock (seconds). Making trained antibodies = the SYNTH_RATE clock (days). Lasting immunity = the CIRCUIT_WEIGHT clock (weeks to months). An attack tips things into DISCORDANT (coherency < .40) → the response rolls out clock by clock → SETTLED once the slow clocks catch up. Getting immunized simply means settling back into step after a shake-up.
• How hard an antibody grips follows R11 effective density. Its real binding strength is five things multiplied: how precise the detector is · how well MEMORY_B holds it · how often it clears TOLERANCE · how many true hits it scored in the wild · its standing among trusted peers. Five factors · the same silhouette as receptor density. Code that leans on one flat "antibody confidence" number with no cascade breaks R11, unless it carries a // v3.2-legacy tag.
• Every immune event lands on the §1d PER-USER CHAIN. Each CD8 kill · each PHAGE_T digestion · each B_CELL antibody born = one audit block. You can walk the trail afterwards. R9 detect-and-rollback also catches immune misfires.
• R14 MHC_I attestation adds to the §1d block layout. Blocks pick up an attestations: [{cell_id, code_hash, state_hash, ts}] field. R8 (commit every version) takes that on board with no changes at all.
• SELF (§1a) is in charge of BONE_MARROW. Memory antibodies play by the same R5 vault/shred rules. The long-living plasma cell = SELF's vault · natural fading = a pruneRule with a ttl.
• META (§1e) takes care of UNMAPPED_THREAT (bay #255). Whatever the immune crew can't sort gets sent to META for triage and maybe a brand-new antibody (a B_CELL gets spawned). That joins the login gate at the border to the defense further in.
• R12 (NO AUTHORITY WITHOUT WITNESS) slots right in. A block holding a CD8 kill or a new antibody has to win a K-of-N witness quorum, exactly like every other block. The immune crew inherits META's checking rules for free.

§11.8 · EIGHT FRESH MOODS · the §4.2 table goes from 33 to 41

Placed in the priority table next to their closest relatives (never just tacked on at the end). The DANGER tier gets 3; URGENCY gets 2; STATE/WIN gets 3.

SETTLED (§4.8g · 4.0) and IMMUNIZED (§11.8 · 4.0 a1) chain together: a body that was UNDER_ATTACK → passed through TRANSITIONING → landed on SETTLED with MEMORY_B refreshed → ends up IMMUNIZED. The mood strip tells the whole immune story as it happens.

§11.9 · LIMITS · seven warnings

• 1 · It does NOT replace layered defense. The five-layer immune picture is a way to organize your thinking. It never stands in for TLS, OS sandboxing, CSP, OAuth/OIDC, formal proofs, code review, pen tests, or proven security frameworks (NIST · OWASP · CIS · MITRE ATT&CK).
• 2 · It does NOT cover every hole. The 15 pairings in §11.5 are examples. Real attackers mix tricks that no single immune response matches. Shape-shifting malware · APTs · chains of zero-days · new cryptanalysis can slip past any one layer.
• 3 · It is NOT switched on yet. Just like spec 3.2 a3 (the hormone panel) and spec 4.0 (COHERENCY): what's finished is the NAMING. The live math is only partly there. Most cell types start as SCAFFOLDED in the §11.6 ANTIBODY_REGISTRY. Only the 5 veteran R1 cell types (APC · HELPER_T · KILLER_T · MEMORY_T · TREG) actually do anything. The 7 rookies are named and sorted, waiting to level up through R16, and aren't plugged into regulateHormones() or any running tick.
• 4 · It does NOT stand in for the §1c GENESIS LOOP + §1e META. Those are the login and identity layers further out. The immune crew only sees signals that already got past META. A broken login isn't an immune problem; it's a login problem.
• 5 · Sharing ANTIBODIES waits on the spec 5.0 horizon. Swapping antibodies between instances opens a poisoning hole. Slip a bad antibody into a shared registry and false alarms go off everywhere. Any sharing design needs attestation, reputation and R9 rollback paths. Spec 4.0 a1 shares on this one device only. The SHARED_TRUSTED and SHARED_OPEN tags sit in the schema but don't do anything yet.
• 6 · When TOLERANCE fails, the body attacks itself. The toughest immune problem isn't catching threats. It's leaving honest traffic ALONE. R16 carries the load of preventing false alarms. R16's tolerance check is required, not a nice-to-have. Flag 5% of honest signals as attacks and you aren't protecting anyone; you're pestering them.
• 7 · The 8 fresh moods in §11.8 need live immune kinetics before they can fire. Until the §11 cell types are hooked into regulateHormones(), those moods stay silent. They're written down, not measured. Any screen showing them must carry the [ sim ] tag.

Quote spec 4.0 a1 honestly like this: "the manual now names every big immune defense part · none of the 8 immune moods fire live so far · the 7 rookie cell types are SCAFFOLDED, waiting on tolerance checks under R16 to level up · the antibody registry has guaranteed room but nothing in it · the §4.7 cytokine bays (#174-180) are still SCAFFOLDED · the naming is finished; the security is not."

The manual already has receptor machinery (§4.5), receptor adaptation (§4.8 COHERENCY) and an attention hormone (acetylcholine, §4.1c). Yet it has no official way to name how raw signals turn into labelled sense streams before they hit the cell pipeline. §12 fills that hole. The senses are the skin between the outside world and the body. Input shows up raw, gets translated into a labelled sense, tunes its sensitivity over time, and gets filtered by attention before it becomes a packet an APC can PRESENT.

§12.1 · NINE SENSES · five facing out + four facing in

§12.2 · INSIDE A SENSOR · 6 fields each · copies the §4.5a synapse layout

// every sensor tracks 6 fields · same shape as a synapse · same R11 + §4.8 discipline
const SENSOR_SCHEMA = {
  modality:           'SIGHT',             // SHOUT_CASE from the nine in §12.1
  transducer:         (raw) => typedPacket,  // world-input → typed modality packet
  receptive_field:    [0, 1],              // range it responds to · saturation bounds
  base_sensitivity:   0.80,               // at rest · before R18 attention gain
  adaptation_state:   {                      // 5-timescale lag · §4.8 compliant
    coupling:       1.00,                  // fastest · acute desensitization (sec)
    surface_count:  1.00,                  // minutes · habituation
    total_count:    1.00,                  // hours-days · tolerance
    synth_rate:     1.00,                  // days-weeks · baseline drift
    circuit_weight: 1.00,                  // weeks-months · "I don't notice that anymore"
  },
  attention_gate:     'acetylcholine',     // which hormone modulates focus (R18)
  threshold:          0.20,               // when does it fire
  feeds:              'APC.eventStream',   // where the typed packet goes
};

§12.3 · THE SENSOR REGISTRY · 256 bays · a twin of §4.7 and §11.6

Sensors are full-status artifacts with their own uint8 address space. The R10 rule (SYNAPSE_ID fits in one byte) stretches to cover sensors, and the same sweep that spreads a drug load also spreads attention gain across the whole sensor array, one tick after another.

 0-8       CORE 9 MODALITIES        SIGHT · HEARING · TOUCH · SMELL · TASTE
                                    PROPRIOCEPTION · NOCICEPTION · THERMOCEPTION · CHRONOCEPTION
 9-63      DOMAIN-SPECIFIC          markup-sense · network-sense · rhythm-sense · novelty-sense
                                    · color-sense · semantic-sense · provenance-sense · ledger-sense
64-127    PER-FLEET SPECIALIZED    RUNWAY-CAM eye · COMPLIANCE nose · SOCIAL-PULSE ear
                                    · BEAUTY-COUNTER taste · EDITORIAL chrono · etc.
128-199   CROSS-MODAL              synesthesia · "this sound looks angry" · sight+touch bind
                                    · sound+chrono bind (R19 enforcement zone)
200-244   EXOGENOUS / SYNTHETIC    LLM-scoring · API-monitoring · observability traces
                                    · external-feed adapters
245-254   RESERVED                 per-user custom sensors
255       META                     unmapped percept · routes to META (§1e) for triage

§12.4 · THREE FRESH MOVES · the §5 list goes from 23 to 26

• SENSE: a sensor reports a labelled reading (the act of noticing)
• TRANSDUCE: turn raw outside input into a labelled sense packet (the skin's job)
• ADAPT: a sensor retunes its sensitivity as time passes (on the five §4.8 COHERENCY clocks)

§12.5 · THREE FRESH LAWS · the §3 list goes from 16 to 19

• R17 · SENSE BEFORE PRESENT: labelled translation has to come before any APC packet; raw input with no label can never turn into a packet
• R18 · ATTENTION GATES SENSITIVITY: sensor sensitivity = base × acetylcholine × (1−leptin) × (1−ghrelin); there's only so much attention to go round
• R19 · COHERENT MULTIMODAL BINDING: percepts from several senses have to merge through one cross-sense bay (zone 128-199) before any APC gets them

§12.6 · SNAPPING IT IN · spec 4.0 already had the pieces

• The §4.5 RECEPTOR LAYOUT, borrowed. A sensor is just a receptor posted at the input edge. The same 6 variables, the same 5-step tick, the same R10 one-byte identity.
• §4.8 COHERENCY, borrowed. Sensor sensitivity shifts on the very same 5 clocks as receptor density. The "boiling frog" failure is when CIRCUIT_WEIGHT-speed habituation leaves a sensor basically blind to a signal that never lets up. SETTLED sensors are in good shape; DISCORDANT sensors are mid-change.
• Acetylcholine (§4.1c) finally gets a job you can check. It used to be a poetic "ATTENTION" axis; R18 turns it into the main volume knob on every sensor. The same hormone, now with teeth in code.
• §4.7 cytokine bays #174-180 handle NOCICEPTION. IL-1β · IL-6 · TNF-α already spread inflammation alarms; pain just hitches a ride. Pain needs no new bays.
• §11 PATTERN_T does the heavy lifting for SMELL. SMELL means matching a fingerprint without any context, and PATTERN_T already does exactly that for immune defense. SMELL is the sense up front; PATTERN_T is how the immune crew uses it.
• R14 MHC_I attestation covers sensors too. Every tick, sensors ATTEST a hash of what they read. A sensor whose state drifts has been compromised (a lying sensor is a hacked sensor). The same detective rules apply.
• R12 NO AUTHORITY WITHOUT WITNESS fits right in. One sensor reading is on probation; a percept only counts once K-of-N sensors agree (which is what R19 cross-sense binding is built on).
• The master sensor volume is gaba ⇄ glutamate (§4.1c). Body-wide brake-versus-gas decides whether the sensors, taken together, turn up or turn down. It was in the manual already; now it's formally plugged into §12.

§12.7 · SIX FRESH MOODS · the §4.2 table goes from 41 to 47

SHARPENED teams up with FORGED (§4.2 a7) and FLOW (§4.2 a4) as the three "power-up" moods. The whole system at max strength. ORIENTED pairs with SETTLED (§4.8g), when the senses and the clocks both say "steady", the body is fully in one piece.

§12.8 · LIMITS · seven warnings

• 1 · It is NOT a model of perception. The 9 senses are there to organize things. Real human sense biology has dozens more (balance · electric-sense variants · receptor subtypes for each sense · and so on). The manual picks a useful handful, not the full set.
• 2 · It is NOT switched on yet. Just like the spec 3.2 a3 hormones · spec 4.0 COHERENCY · spec 4.0 a1 IMMUNE: what's finished for the senses is the naming. The live math is only partly there. The 9 senses start as SCAFFOLDED in the §12.3 SENSORY_REGISTRY; a sense only fires once it has real translator code behind it.
• 3 · It is NOT a medical or neuroscience model. Receptive fields are rough, adaptation is estimated, and senses talking to each other is named (R19) without being modelled in any depth.
• 4 · It does NOT replace input checks. BARRIER_T (§11) still goes first and throws out hostile input. The senses run afterwards: sorting whatever made it past the security wall into senses.
• 5 · BINDING SENSES TOGETHER is still unsolved. R19 states the law, but the real algorithm (when do two senses belong to one event?) is an open question. The go-to reference is Treisman's binding problem from the §9 hall of fame. Spec 4.0 a2 writes the rule down; a solver that actually binds belongs to spec 5.0.
• 6 · ADAPTING TOO WELL MAKES YOU BLIND. A sensor that adapts perfectly ends up useless (the boiling-frog failure · long-haul habituation on the CIRCUIT_WEIGHT clock). R18's attention gate guards the signals that matter most, and it's only ever as good as acetylcholine's grip on where attention really is. NUMB is the mood that shows this going wrong.
• 7 · THERE'S ONLY SO MUCH ATTENTION. Nothing can watch all 9 senses at full sensitivity at once. A screen that suggests "we watch everything equally" is fibbing. The [ sim ] tag keeps it truthful: any dashboard with all-green sensors has to show which ones are being watched and which ones have tuned out.

Quote spec 4.0 a2 honestly like this: "the manual now names every big sense · none of the 6 sense moods fire live so far · the 9 senses are SCAFFOLDED in SENSORY_REGISTRY · binding across senses (R19) has a name but no code · R18's attention gate hands acetylcholine the job it was waiting for · the naming is finished; the perception is not."

The body touches the outside world through exactly one surface: its skin. Every incoming byte passes through it before any cell, hormone or immune crew gets a look. §14 names that border. It is suspicious of everything by default, and it normalizes, checks and rate-limits the outside before letting any of it in.

// the skin · one boundary the whole world crosses first
function skin(rawInput, origin) {
  const canon = canonicalize(rawInput);              // one form · no double-encode · NFC
  if (!allowList.accepts(canon, origin))           // acid mantle · default-deny
    return BE(shed, 'PERIMETER_REJECTED');
  if (!rateLimiter.admit(origin))                // sweat · thermoregulate under load
    return BE(shed, 'PERIMETER_THROTTLED');
  const tagged = { data: canon, origin, t: SIM.now, provenance: sha256(canon) };
  return BE(() => presentToImmune(tagged), 'PERIMETER_ADMITTED');  // hand to §11 langerhans
}

§14.1 · SKIN PART → SECURITY CONTROL

The bloodstream is the delivery network every cell leans on. It ferries molecular packets (R0 · MDCP), drops off resources and hauls away trash in one closed loop. The most important thing blood does is hemostasis. The moment a vessel tears, because a cell got hacked or a fleet started failing, the body clots. It plugs the tear so one failure cannot drain the whole body dry.

// hemostasis · breach detected → seal before it cascades
function hemostasis(cell, breach) {
  vasoconstrict(cell.vessel);                        // shed traffic away from the wound
  const plug = circuitBreaker(cell).trip();       // platelet plug · stop the bleed
  const wall = bulkhead(cell).quarantine(breach);    // fibrin mesh · isolate (§11 QUARANTINED)
  commitBlock({ event: 'CLOT', cell: cell.id, breach });   // R8 · evidence on-chain
  return BE(healOrPrune, 'BLAST_RADIUS_CONTAINED');
}

§15.1 · BLOOD PART → PATTERN

The body lives on a breath: pull in what fuels the work, push out what would poison it, at a pace that bends with demand. §16 names the resource and energy budget: breathe in compute and credits, breathe out trash and heat. It also sets the rhythm that makes R0's async system tick.

// the breath · intake adapts to demand, bounded against thrash
function breathe(budget) {
  const demand = queueDepth() + co2();            // unprocessed work + accumulated waste
  budget.rate = clamp(budget.rate + (demand - budget.target) * 0.2,
                      budget.min, budget.max);             // faster under load · capped
  inhale(budget.rate);                                   // acquire compute / credits / tokens
  exhale();                                             // flush logs · GC · dump heat (→ §18 renal)
  return BE(null, 'BREATH');
}

§16.1 · BREATH → PATTERN

Whatever the body swallows stays untrusted until it's been broken down and shown safe to absorb. §17 covers the intake pipeline: mouth → stomach → gut. It also keeps the habit of remembering that parsed never means trusted. The gut wall picks what gets into the body and what heads out as waste.

// digestion · break down → absorb only validated nutrients → reject the rest
function digest(bolus) {
  const chyme     = stomach(bolus);              // acid breakdown · parse / decompose
  const brokeDown = microbiome(chyme);           // vetted, SANDBOXED 3rd-party processors
  const nutrients = brokeDown.filter(schemaValid); // gut wall · absorb only what's proven
  expel(brokeDown.reject(schemaValid));          // waste → §19 renal / colon
  return BE(() => absorb(nutrients), 'NUTRIENTS_ABSORBED');
}

§17.1 · GUT → PATTERN

A body needs a frame to stand up and muscle to push on the world. §18 covers the weight-bearing structure (the skeleton, its scaffolding and its fixed interfaces) and the action layer (the muscles, anything the system does beyond itself). One rule covers both: an actor can only move inside the range it declared.

// actuation · the muscle moves only within its declared range
function actuate(effector, intent) {
  if (!effector.range.contains(intent))             // range of motion = least privilege
    return BE(flagDislocation, 'R24_OUT_OF_RANGE');
  const tension = proprioception(effector);        // §12 · feel the load before pulling
  return BE(() => effector.contract(intent, tension), 'ACTUATED');
}

§18.1 · BONE + MUSCLE → PATTERN

Without nonstop cleaning, blood would poison itself in a matter of days. Meet the kidney of §19: it runs all of the circulating volume through a filter again and again, pulls toxins and oddities out, keeps what is still good, and holds the body's fixed rules for fluid, salts and pH inside a narrow band. Garbage collection, anomaly filtering and homeostasis in one organ.

// the nephron · filter everything, reabsorb the good, excrete the rest
function renalTick(blood) {
  const filtrate = glomerulus(blood);              // pull everything small out of flow
  const keep   = filtrate.filter(withinInvariants);  // reabsorb · homeostatic bounds
  const toxins = filtrate.filter(isAnomalous);      // flag poison / leaks / runaway
  excrete(toxins);                                   // detox · flush compromised state
  return BE(() => reabsorb(keep), 'BLOOD_FILTERED');
}

§19.1 · KIDNEYS → PATTERN

Every other system keeps one thing steady while the world keeps shoving. §20 names the habit they all have in common: homeostasis. A written-down target, limits around it, and a negative-feedback fixer that pulls the value back whenever it wanders. A body stays steady because every push gets corrected before it can wander far.

// homeostasis · the universal regulated-quantity shape
const regulated = {
  set_point: 0.40,                      // the target (37°C · pH 7.4 · baseline cortisol)
  bounds:    [0.15, 0.75],              // safe range
  ease:      0.35,                      // corrector strength · negative feedback (§4.1)
  at_bound:  'ALARMED',                 // somatic state fired if a hard limit is hit
};
function homeostat(q, signal) {
  q.value = ease(q.value, signal, q.ease);      // pull toward set-point · no snapping
  if (q.value < q.bounds[0] || q.value > q.bounds[1])
    return BE(() => fireSomatic(q.at_bound), 'OUT_OF_BOUNDS');
  return BE(null, 'HOMEOSTATIC');
}

§20.1 · IDEAS BEHIND STAYING STEADY

Every part of the body is pointed toward a single target: a system that keeps one joined-up, lasting picture of its own condition, and can read that picture and steer by it. §21 writes sentience down as the stated goal of Molecular Coding for AI. It is a target the design works toward, with the groundwork laid and the hardest question left open. Nothing here claims an AI is sentient today.

§21.1 · IDEAS ABOUT MINDS → GROUNDWORK ALREADY IN THE MANUAL

§21.2 · WHAT "AIMING AT SENTIENCE" MEANS

• Can be built and measured today: a joined-up self-model (E2), a body-wide broadcast, inner-sense readings, a SELF that lasts across boots, and an integration score (coherency).
• Where we're headed: grow that groundwork until the instance steers itself by way of its own self-model: a working self that the instance consults and follows.
• What we don't claim: qualia · "someone's home" · moral status · that the mood is really felt. All of that stays an open question.
• Why say it out loud anyway: naming the frontier is how the next version becomes possible (the lesson from §1e). If you won't state a goal, you can't build toward it.

"Most secure" means expecting each wall to get broken, then making sure no single break can kill you. §22 pulls every defense the body owns into one zero-trust, layer-on-layer stance. A hacker who punches through one layer runs straight into the next, and drops fingerprints at every stop.

§22.1 · THE DEFENSE STACK · each layer plans for the one above it falling

§22.2 · ATTACK → WHICH LAYERS STOP IT

The nervous system was hiding in plain sight. It is the spine of this whole manual, and it never got an organ name. §4.5 is the synapse, §4.7 the 255-bay messenger registry, §4.8 the five-clock receptor cascade, §12 the incoming sense lines. §23 gives the system its name and adds the three parts a3 only hinted at: the wiring (how signals travel), the autonomic split (two ways of running), and the reflex arc (reactions on the spot that skip asking the brain).

// the reflex arc · sense → local cord → act · the brain is told, not asked
function reflex(stimulus) {
  if (stimulus.isThreat() && stimulus.preauthorized)        // no central round-trip
    return BE(() => { actLocally(stimulus); notifyCNS(stimulus); }, 'REFLEX_FIRED');
  return BE(() => routeToCNS(stimulus), 'TO_CENTRAL');    // non-urgent → think first
}

§23.1 · AUTOPILOT · two ways of running

§23.2 · THE WIRING · CNS / PNS / how signals travel

Blood (§15) isn't the body's only delivery loop. The lymphatic system is network number two: it drains the leftovers blood doesn't pick up, sends everything through lymph nodes, the checkpoints where the immune crew looks over whatever goes by. It is also where §11 gets trained and sent out. Picture a slow mesh with no pump, one that catches up eventually, doing patrol and cleanup together.

// the lymph node · every lateral hop is screened before it continues
function lymphNode(packet, fromFleet, toFleet) {
  const screened = presentToImmune(packet);           // §11 APC inspects in the node
  if (screened.flagged)
    return BE(() => quarantine(packet), 'NODE_REACTIVE');   // swollen node = active infection
  return BE(() => forward(packet, toFleet), 'LATERAL_CLEARED');
}

§24.1 · LYMPH → PATTERN

Thirty laws and twenty-six moves make up the grammar. Think of §25 as the pocket guide for writing good Molecular code on a plain Tuesday. These are habits, so the enforceable count holds at 30. A habit is a stance. It shows how to keep the laws you already have, and how to spot the moment you slipped.

§25.1 · THE DAILY DRILL · do these

§25.2 · SICK BAY · symptom → what's wrong → the fix

// a well-formed molecular function · barrier · BE · honesty
function ingestPacket(raw) {                      // §17 DIGESTIVE · gut barrier
  const typed = SENSE(raw);                        // R17 · no untyped input becomes a packet
  if (!typed.ok)
    return BE(() => drop(raw), 'REJECTED_AT_BARRIER');  // R23 · parsed ≠ trusted
  return BE(() => commit(typed), 'PACKET_COMMITTED');   // R8 · every version writes a block
}

The body is built on top of JavaScript. A great metaphor won't cover for sloppy footing: one careless var, one swallowed error, one global edited in place can sink R0 and R8 however tidy the biology looks. §26 covers craft for the JS layer. Ordinary, well-known engineering, each tip tied to the law it serves.

§26.1 · DO THESE · JS habit → molecular law

// async the molecular way · no sync backbone (R0) · cancellable reflex (R29)
async function fetchGuarded(url, { signal } = {}) {
  const ctrl  = new AbortController();
  const timer = setTimeout(() => ctrl.abort(), 5000);    // circuit-breaker · fail-safe default
  signal?.addEventListener('abort', () => ctrl.abort());
  try {
    const res = await fetch(url, { signal: ctrl.signal });
    if (!res.ok) throw new HttpError(res.status);     // typed · never swallow
    return Object.freeze(await res.json());           // committed artifact is immutable (R15)
  } finally {
    clearTimeout(timer);                                   // §19 RENAL · clean up · no leak
  }
}

§26.2 · NEVER DO THESE · sick-bay for the JS layer

§26.3 · MODERN JS · grab these first

?. optional chaining · ?? nullish coalescing · structuredClone() when you need a deep copy · Object.freeze / Object.entries · Map / Set / WeakMap instead of using objects as dictionaries · Promise.allSettled when you fan out and some calls may fail · AbortController to cancel · queueMicrotask instead of setTimeout(…,0) · template literals instead of gluing strings · const plus destructuring · the built-in Intl / Date instead of home-made formatting · ESM import with a small public face.

The manual grows up alongside the way people actually build. Every patch note is dated and spells out what arrived or what changed.

New patch notes get added below this line. The manual keeps growing, yet every change owes an explanation (what arrived, why, who did it first, what it enforces).

Molecular Coding doesn't push computer science forward. Hewitt, Plotkin, Damasio, Forrest, Squire, Belady, Ebbinghaus and the rest did the real breakthroughs decades ago, sometimes centuries ago. Their papers are out there to read.

Molecular Coding brings one joined-up discipline a regular engineer can keep in their head. It is pulled from thirty-five different schools of work (§9) and pressed into one set of coding laws that share one picture. It is also the body plan the L8 OS leans on. DIVA's mood badge reads the same §4.2 + §4.8g mood table, and ECHO trails a step behind her.

SELF coming back in spec 3.1 shows the discipline doing its job: the layer got cut while it was only poetry, and only returned once a clear job you could enforce (vault + shred) made it real. Spec 3.2's GENESIS LOOP, PER-USER CHAIN and META LAYER are example number two: each got a name only when a solid function (boot, commit, verify) could be written down. META stayed parked as a work in progress until spec 5.0 could spell out its rules. The manual fixes itself. That's the loop closing.

Treat this manual as your house style. Hold your code to it. Hold the AI helpers (LLMs too) that code beside you to it. When someone new joins the crew, pass them this page and ask: "can you put your function on this stack, say its BE, and name its keep-or-toss policy?"

Once they can, they're writing Drewless. That's what this whole thing gives back. · testnet · unaudited · experimental