MOLECULAR CODINGv4.0 · ± PROD · COHERENCY

The system has no synchronous backbone. No global clock. No shared atomic state. Every cell runs on its own cadence. Every layer settles eventually, not immediately.

This becomes the unspoken assumption every other rule presumes. R1 through R9 all only make sense in an async system. Naming it as R0 makes the assumption explicit.

The organism is built bottom-up but regulated top-down. Each layer expresses the layer above and reports to the layer below. SELF distills engine memory into long-term archives and prunes what is no longer useful — feeding refined experience back into DNA. The seven layers live inside one user. An eighth axis sits outside the stack: the GENESIS LOOP + PER-USER CHAIN + META LAYER (§1c–§1e · v3.2) — how a fresh instance of the whole organism is constituted at every boot, recorded as an immutable block, and gated by the meta protocol that keeps bad actors out.

FLOW DIRECTIONS

• Down (signaling): DNA → cells → organs. Commander updates directive; sub-agents change behavior; fleet flushes.
• Up (telemetry): cells → organs → emotions → memory → kernels → SELF. Activity bubbles up; hormones modulate; memory consolidates; kernels distill into next-boot seeds; SELF curates the survival set.
• Feedback (evolution): SELF → DNA edits → cells differentiate. The system learns by editing its own directives based on what survived archival.

SELF used to be poetic ("integrated being") and was dropped from v3.0 because no one can write "consciousness" as a lint rule. In v3.1 it is restored with a discrete, enforceable function: SELF decides what crosses from session memory into permanent archive and what is pruned forever.

// 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');
  });
}

BIOLOGICAL ANALOG

• Memory consolidation in sleep (Stickgold, Walker) — NREM sweeps engrams; REM strengthens what survives.
• Synaptic pruning (Huttenlocher 1979) — childhood and adolescence eliminate unused connections.
• Forgetting curve (Ebbinghaus 1885) — unused information decays predictably.
• Hebbian "use it or lose it" — only repeatedly co-activated synapses survive.

COMPUTER SCIENCE ANALOG

• Generational garbage collection (Lieberman/Hewitt 1983) — young objects collected aggressively, survivors promoted.
• LRU cache eviction (Belady 1966) — least-recently-used discarded first.
• Tiered storage (hot → warm → cold → frozen) — modern data lakes operate this way.
• TF-IDF retention weighting in information retrieval.

WHY THE RESTORATION IS HONEST

SELF dropped from v3.0 because "integrated being" was unenforceable. SELF returns in v3.1 because deep-store + prune is two concrete functions with declared policies. The discrete enforceable role differs from the poetic "consciousness" — and only the discrete role makes it back into the spec.

The seven-layer stack runs inside one user. The eighth axis is the loop that constitutes that user's instance every time it boots. The same code template runs for everyone (PUBLIC SEED), but the actual instance only exists once your PRIVATE SEED genesises it. There is nothing to authenticate against until you have booted yourself into existence.

// 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');
}

WHY THIS IS NOT zk-ROLLUPS

• Rollups share one global state machine; users prove properties about private inputs against it.
• Genesis loop has no shared state machine. Each user runs their own personal program. The bootstrap itself is the auth event. Without that bootstrap, there is nothing to attack.
• An attacker cannot authenticate "as you" if the program that would let them act as you does not exist on their device — and their private seed cannot derive it.

MULTI-DOMAIN AUTH BY INSTANCE SEPARATION

Different domains derive different private seeds from your master. A compromise of your social instance cannot impersonate your bank instance — the bank instance has different derivation, different META gate, different chain.

ADDITIONAL AUTH LAYERS ON TOP

Passkeys, MFA, biometric — these are not replaced. They compose over the instance once it exists. Genesis decides whether the instance exists at all. Passkeys decide whether ongoing operations within the instance are still you. Both tighten the surface; neither one alone is the system.

DEVICE-AS-AUTH IS A SHORTCUT

WebAuthn / passkeys ship a fragment of this idea: "your device is your auth, because only your device holds the private key." The full version says: your device renders a new OS on every boot from your seed. The OS itself is the auth surface. Device-as-auth is the convenient compression of that.

Every GENESIS event appends a block to that user's personal chain. The chain is immutable in the blockchain sense — each block links to the prior block's hash. There is no shared global chain; there is one chain per user instance. Anyone can verify the chain's integrity. Only the user can read what their blocks reference.

// 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
};

LATEST vs MOST-RECENT · domain-dependent semantics

DETECT AND ROLLBACK

Anomaly detection runs at block level. When META or an external watcher flags block N as suspect, the system can roll back to block N-1 (or further) and resume from there. The bad block remains on the chain as evidence — it is not deleted — but it is marked invalid and not used as a basis for activation.

// 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 LIKES IT

• Deterministic: same (seed, deltas) → same instance · replayable from any block.
• Auditable: every boot is a block · diffable history of how this user's program evolved.
• Isolated: per-user · no shared state to corrupt across users · one bad chain cannot pollute another.
• Rollback-safe: bad block → revert · no whole-system harm · provenance preserved on-chain as evidence.
• Bounded: SELF deep-stores + prunes operate within the chain so memory growth stays bounded.

META sits at the protocol edge between the user's INSTANCE and the LEDGER (the per-user chain plus any shared coordination layer). Its job is to verify the signal of every block before it is accepted as authoritative — gating bad actors at the layer below auth rather than at the layer above it. Auth comes from the existence of the instance (R6); META is what decides whether the next block is permitted to extend the chain at all. v3.2 named META and held it as WIP framing. v5.0 declares the discipline: a concrete signal format, a peer-witness quorum, a posture-gated threshold, and a graduated failure mode — two new enforceable rules (R12 · R13) and two new verbs (WITNESS · QUARANTINE).

§1e-1 · THE SIGNAL · concrete bytes

The block schema (§1d) already carries meta_sig. v5.0 specifies what it contains:

// 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
};

A witness checks three things and nothing more: (1) the signature verifies against the claimed pubkey, (2) the pubkey is the one that has extended this chain since genesis, (3) the freshness counter is strictly greater than the last accepted block's. Forgery requires the private seed; replay requires beating the monotonic counter; identity-swap requires a chain fork the witnesses already hold. None is available to an attacker who lacks the seed.

§1e-2 · WHERE META RUNS · peer-witness quorum, never one 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 (peer-witness pattern) or a domain's validator set — never the instance validating itself, never a single trusted server. A bank domain runs a strict validator set; a social domain may accept loose peer-witnessing. The transport by which witnesses discover one another and gossip a block is deliberately unspecified — see the frontier note below.

§1e-3 · COMPOSITION · three gates, bottom-up

Genesis is the floor (no instance → nothing to authenticate). META is the chain gate (no witness quorum → no authoritative block). Passkeys are the ceiling (no fresh proof → no sensitive op). Each tightens a different surface; removing any one leaves a gap. META does not replace passkeys and passkeys do not replace genesis.

§1e-4 · POSTURE-GATED THRESHOLD · R13 · the oracle modulates the gate

// 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 same somatic posture that tightens routing gates and accelerates cadences also tightens the META gate. A system reading high cortisol (errors up, saturation high) demands more witnesses and fresher proofs before it trusts the next block. A calm system relaxes. Static, hardcoded META thresholds violate R13. This is why META is part of the organism, not bolted on beside it — it breathes with the oracle.

§1e-5 · FAILURE MODE · graduated, never silent

QUARANTINE is the verb v5.0 needs: a block can be suspect without being malicious (a witness set that hasn't gathered yet, a slow network). Quarantine buys time without either trusting the block or discarding the user's work. Only zero-witness or proven-forgery blocks trigger rollback; a recurring pattern across instances escalates to a domain-wide posture shift through the oracle.

Note for future-self: META moved from WIP framing (v3.2) to declared discipline (v5.0) the moment a concrete signal, a quorum rule, and a posture gate could be written as enforceable functions — the same bar SELF cleared in v3.1 and GENESIS in v3.2. Do not implement the witness transport until the discipline has lived in the spec long enough to attract attack. Name → declare → harden → ship, in that order.

Every operation in the system lives on one axis: fission (break apart) ↔ fusion (combine). This is not metaphor — it is the design rule that places each function along a spectrum and forces it to declare its position.

WHY THIS MATTERS AS A RULE

• Code-review question: "is this function fissioning or fusing? does its name say so?"
• Placement rule: fission-heavy near the input boundary, fusion-heavy near the output boundary. SELF sits at both ends — prune is fission (discard), archive is fusion (preserve).
• Balance metric: too much fission = noise. Too much fusion = premature consensus. Healthy system maintains appropriate ratio for current load.

Prior art: MapReduce (Dean/Ghemawat 2004) is fission-then-fusion. The binding problem in neuroscience (Treisman 1980s) is unresolved fragment-to-percept. Fission-fusion societies (Aureli et al, primatology) is groups splitting/merging.

Rules that can be checked by a linter or a code reviewer. These give Molecular Coding its shape.

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 shape architectural choices but can't be enforced syntactically. Like Rust's "fearless concurrency" — useful posture, not a lint rule. v3.2 addendum 3 fully specifies E1: 15 endocrine readouts grouped on 5 axes, with a 13-state somatic marker matrix wired to a priority-ordered classifier.

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 ENDOCRINE READOUTS · PREAMBLE

Every value in HORMONES is a derived readout of system state computed each regulateHormones() tick — never a stored prior, never a magic 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

Each tick (3000 ms) the regulator computes targets and eases hormones toward target at 35% — no snapping, no oscillation. BE(null, 'HORMONES_REGULATED') closes the loop.

§4.1a · ORIGINAL 11 · classical endocrine + neurochemical set

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

The original 11 spanned risk, desire, and rhythm but had no readouts for the studio-production side of a fashion house — craft heritage, conversion efficiency, production tempo, and cultural-backlash inflammation. Four hormones added to close that gap.

§4.1c · NEUROMODULATORS +5 · arousal · attention · bonding · flow

The 15-hormone surface covered classical endocrine + studio-production craft, but missed the neurotransmitter band — the fast-acting brain signals that gate arousal, attention, and flow. Five neuromodulators added in addendum 4 to close the surface at 20 readouts.

Inverse pair added: gaba ⇄ glutamate — the master inhibition/excitation axis. Brain stays alive only because these two are in homeostatic tug-of-war; same goes for the simulation.

§4.1d · EXPANSION 3 · +10 · growth · balance · receptivity · protection · mobilize · venting · friction · health · gate · forge · v3.2 addendum 7

The 20-hormone surface from a4 covered classical endocrine + craft + neuromodulators but still missed ten studio-relevant readouts — fleet growth, load balance, audience receptivity, canon protection, capital mobilization, overload venting, pipeline friction, long-cycle health, intake gating, and productive stress. Ten readouts added in addendum 7 to close the surface at 30 readouts. Seven of the ten ride existing §4.7 slots promoted from SCAFFOLDED → ACTIVE; three claim fresh slots from the 245-254 reserved range.

New inverse pairs: insulin ⇄ glucagon (storage vs mobilization) · adiponectin ⇄ resistin (long-cycle health vs friction) · gh ⇄ somatostatin (growth vs brake — somatostatin still scaffolded at slot #56, candidate for addendum 8 promotion).

§4.2 · E2 · SOMATIC MARKER MATRIX · 47 states · priority-ordered · v4.0 a2

The oracle reads the 31 readouts (30 hormones + coherency) — plus immune and sensory kinetics — and emits a single state: the same {state, cls, phrase} tuple wherever it's needed (watermark, oracle window, drop-window). Order matters; most urgent / most specific checks fire first. Addendum 4 inserted 5 neuromodulator states (AGITATED · FLOW · BONDED · ATTENTIVE · SEDATED) by domain proximity; addendum 7 inserted 12 more (STRAINED · VENTING · CLOSED · SPENDING · ACTIVATED · FORGED · HEALTHY · RECEPTIVE · BALANCED · GROWING · GUARDED · INHIBITED). v4.0 folded in 3 coherency states (DISCORDANT · TRANSITIONING · SETTLED · §4.8g), v4.0 a1 the 8 immune states (§11.8), v4.0 a2 the 6 sensory states (§12.7) — 47 total, none appended at the bottom; each lands where its specificity earns it.

First-match wins. Where a less-specific state (ACTIVATED · INHIBITED) overlaps with its more-specific cousin (AGITATED · SEDATED), the more-specific one fires first by virtue of higher priority. This is how the matrix scales: each new state adds discrimination without breaking the existing rules.

§4.3 · AXIS GROUPING · how the 30 cover the molecular surface · v3.2 addendum 7

Five super-axes hold the 30 readouts. Each parenthesized name is a sub-axis — the specific role the hormone plays inside its super-axis. Addendums 4 (neuromodulators) and 7 (+10) broadened coverage; the 5 super-axes still hold without proliferation.

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

Notable inverse pairs (one's high suppresses the other's marker):

• ghrelin ⇄ leptin — hunger vs satiety
• adrenaline ⇄ melatonin — urgency vs rest
• serotonin ⇄ cortisol — stable vs risk · both gate ELATED
• prostaglandin ⇄ insulin — inflammation vs efficiency · health vs alarm
• gaba ⇄ glutamate — master inhibition vs excitation · brain stays alive only in tug-of-war · a4
• insulin ⇄ glucagon — storage vs mobilization · the energy economy · a7
• adiponectin ⇄ resistin — long-cycle health vs pipeline friction · a7
• growth_hormone ⇄ somatostatin — growth vs brake (somatostatin still SCAFFOLDED at slot #56 · candidate for a8 promotion)

§4.4 · HONESTY · what this is NOT

• cortisol high ≠ "the market is risky" — it means this run has logged enough errors + saturation that the somatic marker should warn you
• insulin high ≠ "your collection will sell" — it means the verified-trend pool is confident AND not crowding the same domain
• prostaglandin high ≠ "you'll be cancelled" — it means GATE events have fired recently in the wire, so the audit posture should sharpen

Every input traces back to a measured (simulated) state variable. No hardcoded priors. [ stub ] feeds still produce honest hormone readings because the readings describe the simulation, not reality.

§4.5 · SYNAPTIC DYNAMICS · the layer beneath HORMONES · v3.2 addendum 5

The 20 hormone values above are readouts. To model psychoactive drugs honestly — SSRI · MAOI · SNRI · atypicals — the simulation needs the layer beneath: the synaptic cleft mechanics that produce the readouts. The synapse is where monoamines actually live, where reuptake transporters and degrader enzymes shape concentration, and where postsynaptic receptors fluctuate and respond over days and weeks. Receptor density is the time dimension psychoactive drugs operate in.

§4.5a · SYNAPSE STATE · 6 variables per 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 · THE SYNAPSE TICK · 5-step pipeline · 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 · FIVE MONOAMINE SYNAPSES · canonical wiring

§4.5d · WHY RECEPTOR DENSITY MATTERS · the time dimension

This is the variable that makes the simulation honest about psychoactive drugs:

• Acute (minutes–hours): drug raises synaptic_conc → readout rises immediately → mood lift · side effects · jitter · euphoria.
• Adaptive (1–6 weeks): chronic high synaptic_conc → target_density drops → MEMORY_T downregulates → readout returns toward baseline despite drug still being present. This is why SSRIs take weeks to relieve depression.
• Tolerance: sustained receptor_density < 1.0 means the same dose produces a smaller signal over time. The synapse literally remembers the exposure.
• Discontinuation: drug stops → reuptake/breakdown snap back → synaptic_conc falls fast — but receptor_density is still downregulated → readout drops below baseline for weeks until receptors re-upregulate. SSRI discontinuation syndrome falls out of the model — no special case.
• Sensitization: chronic low synaptic_conc → target_density > 1.0 → receptors upregulate · synapse becomes more responsive to small signals. Models antidepressant rebound, kindling, stimulant-withdrawal hypersensitivity.

§4.5e · CELL-TYPE MAPPING · synapse roles match the seven-stage pipeline

§4.6 · PHARMACOLOGICAL INTERVENTIONS · the APPLY verb · v3.2 addendum 5

Drugs are not magic constants on hormone levels. A drug modulates a specific synaptic role at a specific potency, with a specific half-life. Plasma concentration rises to steady state over days, decays exponentially on discontinuation. The drug never directly touches the readout — it touches the rate constants that produce the readout. Receptor density does the rest.

§4.6a · DRUG PROFILES · the four classes that matter

// 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 intervention function

// 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 · SIMULATION TIMELINE · what an SSRI run looks like

Illustrative trace · 90-day on, then 90-day off · sertraline at therapeutic dose:

The readout doesn't track the drug — it tracks the drug plus how the receptors have remembered. That's why the curve isn't a step function. That's why SSRIs work eventually but slowly, and that's why stopping suddenly hurts.

§4.6d · HONESTY · what this layer is NOT

• This is not a prescribing tool. It does not predict whether you will respond to fluoxetine.
• The potencies are scaled to make the simulation behave qualitatively right, not to match plasma assays.
• Receptor adaptation is a single linear lag here · in vivo there are at least five interacting timescales.
• Drug-drug interactions · CYP450 metabolism · food effects · plasma protein binding · genotype variance — all out of scope · would be added as further commanders modulating the kinetic constants.
• [ sim ] tag must appear on any UI surface that exposes these mechanics — never present this as clinical guidance.

§4.7 · SYNAPSE REGISTRY · 255 slots · uint8-addressable · v3.2 addendum 6

The 5 monoamines in §4.5c are the starter set — the synapses every psychoactive-drug model has to touch. They are not the limit. Human neurochemistry runs on ~150–200 named transmitters / peptides / gases / lipids · this section formalizes the full surface as a 255-slot uint8-indexed registry. Five slots are ACTIVE; the rest are SCAFFOLDED (named + classed + ready to promote) · RESERVED (open for future canonicalization) · or META (catch-all for unmapped signals).

§4.7a · WHY 255 (not 5, not infinity)

• Byte-aligned: uint8 ID · fits in a single register · 256-entry lookup table fits in L1 cache.
• Ledger-aligned: per-tick synaptic delta = up to 255 (slot, Δsignal) pairs · serializes into one block append (§1d).
• Big enough: human neurochemistry totals roughly 150–200 endogenous transmitters + neuropeptides + gases + lipids · 255 leaves headroom for ~50 novel/synthetic/exogenous binding profiles.
• Not a hard ceiling: §4.7f documents the uint8 → uint16 promotion path. 65,535 slots becomes available with one schema migration when needed (full transcriptome-scale signaling, multi-organism modeling, exotic chemistry).
• Honest about scaffolding: only 5 slots run live math today. The other 250 are named and classed so promotion to ACTIVE is a constant-effort change · no re-architecture.

§4.7b · REGISTRY SCHEMA · slot shape

// 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 · SLOT ALLOCATION MAP · 10 ranges

§4.7d · CATALOG · canonical slot assignments

SHOUT_CASE name · class · transporter · degrader · status. ACTIVE = wired into synapseTick() · SCAFFOLDED = registered + classed + ready to promote · RESERVED = open · META = catch-all.

0–4 · MONOAMINES · ACTIVE (canonical · §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 synaptic · the actual backbone of cortical signaling)

 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 ADJACENTS

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 · HYPOTHALAMIC + 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 + APPETITE + GUT-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 SIGNALING

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 · EXOTIC ENDOGENOUS + 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 · EXOGENOUS BINDING PROFILES (not endogenous — slot encodes drug→receptor profile 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 (open slots · novel · undiscovered · per-user custom signals · 3 claimed in a7)

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 (catch-all · routes to META layer §1e)

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

§4.7e · PROMOTION RULES · SCAFFOLDED → ACTIVE

A scaffolded slot becomes active when three things are true:

• Kinetics declared: the slot's kinetics object has all 6 variables from §4.5a populated with non-null defaults.
• Feeds something: either feeds_hormone points to a §4.1 readout, or axis contributes a new dimension declared in §4.3.
• Honesty discharged: the source of each rate constant is documented (literature reference, derived heuristic, or explicit [ 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 · EXPANSION PATH · uint8 → uint16 (when needed)

255 is sufficient for the human neurochemical surface plus headroom. Three scenarios force a wider register:

• Per-user custom signals: if instances start registering domain-specific synapses (e.g. brand-mood pseudo-transmitters in the studio context), 250 reserved slots fill fast.
• Multi-organism modeling: if META layer aggregates across users / domains, each instance might own a 255-block and the federation needs uint16.
• Receptor-resolved registry: currently a slot holds one transmitter; a receptor-resolved registry (one slot per transmitter × receptor pair) needs ~2000+ entries → uint16.

The migration is mechanical: bump SYNAPSE_REGISTRY from Array(256) to Array(65536), slot 65535 inherits META semantics, slots 0–254 are unchanged. The schema's id field widens. Blocks gain a registry-width byte so older blocks remain readable. R9 detect-and-rollback still applies if migration goes wrong.

§4.7g · HONESTY · what the registry is NOT

• Slot assignments are stable once published — changing a slot after publication would break LEDGER replay (R9). Reservation, deprecation, and migration use new slot IDs, never overwrite.
• Class taxonomy is a working classification, not a final ontology. Some signals belong to multiple classes (e.g. estradiol is neurosteroid + hormone + receptor ligand) — the slot's primary class is the dominant role in neural signaling.
• Receptor lists are illustrative; the real receptor pharmacology for most peptides is incompletely characterized. The simulation models the presence of a receptor family, not its complete subtype distribution.
• Exogenous binding profiles (210–244) are not endogenous neurochemistry — they're drug→receptor maps so APPLY can target the same slot system used for endogenous signals. A drug at slot 210 (LSD) modulates the receptors of slot 0 (serotonin) through 5-HT2A binding.
• The full 255-entry promotion to ACTIVE is not a roadmap commitment — it's a structural guarantee that the slot is available if a future study, dataset, or in-game system needs it.

§4.8 · COHERENCY · five-timescale receptor adaptation · v4.0 anchor feature

§4.5b modeled receptor adaptation as a single linear lag (one variable · one rate constant · 0.0012 per tick). That was a v3.2 simplification — admitted in §4.6d as "in vivo there are at least five interacting timescales." v4.0 unfolds that simplification. The single receptor_density variable becomes five cascading variables, each with its own biological timescale, each gating the next. The simulation gains a new measured state — coherency — which describes how aligned the five scales are at any moment.

§4.8a · THE LIE OF ONE LAG · what v3.2 a5 oversimplified

The v3.2 a5 synapse tick (§4.5b step 5) used:

// 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;

One rate constant · one variable. This captures "receptors downregulate when exposure stays high" but it cannot capture:

• Acute desensitization · GPCR uncouples from G-protein in seconds (faster than any single 0.0012/tick lag can model).
• Receptor internalization · β-arrestin pulls phosphorylated receptors off the surface in minutes · they're not gone, just hidden.
• Lysosomal degradation vs endosomal recycling · the hours-to-days decision of whether an internalized receptor comes back or is destroyed.
• Transcriptional adaptation · gene expression changes the production rate of new receptors over days-to-weeks.
• Structural plasticity · the synapse itself rewires · dendritic spines form and retract · downstream circuits adapt their weights over weeks-to-months.

Each of these is a separate variable with a separate rate constant. They interact · each scale is the input to the next slower scale. v4 names the cascade.

§4.8b · THE FIVE TIMESCALES

Tick lag is per 3000ms simulation tick. Settling time ≈ 4 / lag ticks · multiply by 3 seconds for wall-clock. Scale 1 settles in ~4 minutes simulated · scale 5 in ~7 days simulated. The ratios between scales (10× each step) are what give the cascade its biological texture.

§4.8c · THE CASCADE · each scale 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');
}

Each scale is gated by the scale above it · the slow ones cannot drift independently. The slow scales remember the fast scales over their relaxation time. This is the source of coherency: in a settled system, all five variables converge on the same value because each is targeting the next.

§4.8d · EFFECTIVE RECEPTOR DENSITY · the product of all five

// 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 factors multiply. If any one collapses, the signal collapses. If they all stay aligned, the signal is whatever the cleft concentration produces. This is the molecular basis of tolerance (slow factors drop), withdrawal (fast factors restore but slow factors haven't), and recovery (slow factors finally catch up).

§4.8e · COHERENCY METRIC · variance across scales

// 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 the 21st HORMONE readout

System-wide coherency joins HORMONES (§4.1) as a measured readout — the 21st (alongside the original 11 + craft expansion 4 + neuromodulator band 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 lives on a new axis · §4.3 COHERENCY axis (the 9th, alongside the eight existing axes). It is the only axis whose membership is a single readout — because coherency is the alignment-of-everything-else.

§4.8g · THREE NEW SOMATIC STATES · driven by coherency

Inserted into the §4.2 priority matrix between INFLAMED and STRESSED:

DISCORDANT and TRANSITIONING fire before STRESSED because a system in transition is more informative to surface than a system that's merely under load. SETTLED fires alongside ELATED at lower priority but is the only state that requires sustained coherency — making it the system's strongest "trust this signal" indicator.

§4.8h · SIMULATION TIMELINE · SSRI run with 5-scale coherency

Notice the asymmetry: drug onset gives a brief DISCORDANT spike (1 hour) then weeks of TRANSITIONING. Drug discontinuation gives a much longer DISCORDANT phase because the slow scales (synth, circuit) are still adapted to the drug while the fast scales (coupling) have already restored. This is the molecular signature of SSRI discontinuation syndrome — it falls out of the coherency model with no special-case code.

§4.8i · HONESTY · what COHERENCY is NOT

• Tick rates (0.05, 0.005, 0.0005, 0.00005, 0.000005) are illustrative · chosen so the cascade plays out at the right qualitative tempo, not measured from receptor kinetics studies.
• Each scale's "gate" is currently a simple multiplier (* 1.05, * 1.02, etc.) · real cross-talk involves second messengers (cAMP, Ca²⁺) and transcription factors (CREB, ΔFosB) the spec does not name.
• Coherency variance across 5 numbers in [0,1] is a crude proxy for "system alignment." Better metrics (mutual information across timescales, phase coherence) belong in v5.
• Receptor heterogeneity is ignored · all 5-HT2A receptors in slot 0 are treated as one population. In vivo there is enormous receptor-state diversity within a single cluster.
• The [ sim ] tag still applies · this is not a clinical model. v4 improves the honesty of the shape, not the magnitude.

Any function in the codebase should map to one of these verbs. If it doesn't, it's miscategorized or doing two things and should be split.

APPLY is the only verb that originates outside the organism. Everything else is the system regulating itself; APPLY is the external intervention. Used by §4.6 to model psychoactive drugs by modulating reuptake (KILLER_T) and degradation (TREG) rate constants — never by touching the hormone readout directly.

FUNCTIONS · verb + cell_type / verb + 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 + concept

• cellPopulationByType — live count of each cell type
• dnaVersionByCommander — current dna_version map
• hormonalLevels — current oracle modulation state
• somaticMarker — current felt-state phrase
• artifactRegistry — engine memory store
• kernelSeeds — boot-time persistent seeds
• selfArchive — long-term storage (DEEP STORE output)
• prunedAt — timestamp ledger of recent prunes (auditable)

CONSTANTS · SHOUT_CASE + tier

• STEM_POOL_SIZE — unity mesh capacity
• CORTISOL_GATE_THRESHOLD — stress → gate adjustment
• CELL_TYPES — the enumerated type set
• DNA_LIFETIME_MS — directive TTL before retranscription
• KERNEL_TTL_MS — kernel persistence horizon
• SELF_ARCHIVE_THRESHOLD — completeness required for permanent store
• SELF_PRUNE_AGE_MS — unused TTL before discard

Honesty is part of the contract with the audience. The industry's usual "production-ready" framing lies. Pick the tag that reflects truth.

• Down (signaling): a layer can call the layer immediately below it. DNA signals cells; cells signal organs; organs signal emotions; etc.
• Up (telemetry): a layer reports to the layer above it. Cells → organs → emotions → memory → kernels → SELF.
• Feedback (evolution): only the SELF→DNA path crosses multiple layers. This is the deliberate evolution loop and must be explicit (logged, versioned). Memory engines distill into kernels which distill into archives, which become candidate inputs for DNA rewrites.
• Never: a sub-agent does not edit a chief. A kernel does not directly call a cell. Layer-skipping is illegal except through the documented evolution feedback path.

Molecular Coding is an integration, not an invention. Thirty-five separate traditions, folded into one coding discipline.

The integration into one coherent house-style discipline — that's the Drewless contribution. Naming the stack, enforcing it at the function level, demanding cell types and DNA versions and BE labels, treating the watermark as a somatic marker, declaring archive + prune as named policies — none of that is computer science. It's engineering culture, which is a different valuable thing.

The molecular spec has shipped immune building blocks since v3.0 — APC · KILLER_T · MEMORY_T · HELPER_T · TREG are the cytotoxic-vs-tolerance pipeline encoded in R1 cell types. v3.2 a4 added cytokines as scaffolded §4.7 slots (#174-180: IL-1β · IL-6 · IL-10 · IL-18 · TNF-α · IFN-γ · IFN-α). v4.0 unified the 30-hormone surface and the synaptic-dynamics layer with COHERENCY (§4.8). v4.0 a1 names the defensive discipline that sits across all of those parts — five layers, twelve cell types (5 existing + 7 new), five new verbs, three new R-rules, fifteen threat-to-mechanism mappings, an antibody registry parallel to the synapse registry, and an explicit honesty section about what the layer is and is not.

§11.1 · THE FIVE IMMUNE LAYERS

§11.2 · CELL TYPES · 5 existing + 7 new = 12 total

§11.3 · FIVE NEW VERBS · the §5 catalog grows from 18 to 23

• NEUTRALIZE — bind + disable a specific threat (ANTIBODY or CD8 lysis)
• OPSONIZE — tag a target so PHAGE_T can engulf it
• PHAGOCYTOSE — engulf + degrade in a sandbox
• ATTEST — sign current code + state hash for audit (MHC_I/II · drives R14)
• ESCALATE — broadcast cytokine alert + route response via chemokine

§11.4 · THREE NEW R-RULES · the §3 catalog grows from 13 to 16

• R14 · MHC_I ATTESTATION PER TICK — every cell signs code + state hash each tick · drift = compromise
• R15 · ANTIBODY IMMUTABILITY — once published, antibodies can only be deprecated, never edited · preserves R8
• R16 · TOLERANCE CHECK BEFORE PROMOTION — new detectors must pass known-good panel · prevents autoimmunity

§11.5 · THREAT → MECHANISM · 15 hack/virus types

§11.6 · ANTIBODY REGISTRY · 256 slots · parallel to §4.7

Antibodies are first-class artifacts that need byte-aligned addressing for the same reasons synapses do (per R10): O(1) lookup · cache-friendly · ledger-friendly · drug-load-style propagation propagates a 256-entry array 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 · INTEGRATION WITH v4 · the immune system fits the existing surface

• Cytokines reuse §4.7 slots #174-180 — IL-1β · IL-6 · IL-10 · IL-18 · TNF-α · IFN-γ · IFN-α are already SCAFFOLDED. The §4.7e promotion path (SCAFFOLDED → ACTIVE) wires them with kinetics. Immune signaling does not need new synapse slots — it activates the ones already there.
• Immune response IS a 5-timescale phenomenon (§4.8 COHERENCY). Innate response = COUPLING scale (seconds). Adaptive antibody production = SYNTH_RATE scale (days). Memory immunity = CIRCUIT_WEIGHT scale (weeks-months). An attack causes DISCORDANT (coherency < .40) → response unfolds across scales → SETTLED when slow scales catch up. Immunization IS coherent re-settling after a perturbation.
• Antibody affinity follows R11 effective density. An antibody's effective binding strength is the product of: detector specificity · MEMORY_B retention · TOLERANCE pass rate · field-validated true-positive count · federation reputation. Five factors · same shape as receptor density. Code using single "antibody confidence" without cascading violates R11 unless tagged // v3.2-legacy.
• Immune events commit to §1d PER-USER CHAIN. Every CD8 kill · every PHAGE_T digest · every B_CELL antibody-creation = an audit block. Forensics walkable. R9 detect-and-rollback covers immune misfires too.
• R14 MHC_I attestation extends the §1d block schema. Blocks gain an attestations: [{cell_id, code_hash, state_hash, ts}] field. R8 (commit every version) absorbs this without modification.
• SELF (§1a) owns BONE_MARROW. Memory antibodies follow the same R5 archive/prune rules. Long-lived plasma cell analog = SELF deep store · auto-decay analog = pruneRule with ttl.
• META (§1e) handles UNMAPPED_THREAT (slot #255). Anything not classified by the immune system routes to META for triage and possible new-antibody synthesis (B_CELL spawn). This closes the loop between protocol-edge auth and downstream defense.
• R12 (NO AUTHORITY WITHOUT WITNESS) composes naturally. A block carrying a CD8 kill or antibody creation needs the same K-of-N witness quorum as any other block. The immune system inherits META's verification discipline.

§11.8 · EIGHT NEW SOMATIC STATES · §4.2 matrix grows from 33 to 41

Inserted into the priority matrix by domain proximity (not appended at the bottom). DANGER tier gains 3; URGENCY gains 2; STATE/WIN gains 3.

SETTLED (§4.8g · v4) and IMMUNIZED (§11.8 · v4 a1) compose: a system that went UNDER_ATTACK → through TRANSITIONING → reached SETTLED with MEMORY_B updated → is IMMUNIZED. The somatic surface narrates the immune cycle.

§11.9 · HONESTY · seven critical disclaimers

• 1 · NOT a defense-in-depth replacement. The five-layer immune model is an organizing metaphor. It does not substitute for TLS, OS-level sandboxing, CSP, OAuth/OIDC, formal verification, code review, pen testing, or established security frameworks (NIST · OWASP · CIS · MITRE ATT&CK).
• 2 · NOT vulnerability-complete. The 15 threat mappings in §11.5 are illustrative. Real attackers compose threats that don't fit a single immune mechanism. Polymorphic malware · APTs · chained zero-days · novel cryptanalysis may bypass any single layer.
• 3 · NOT yet active. Same as v3.2 a3 (hormone surface) and v4.0 (COHERENCY): this is NAMING completeness. Active math is partial. Most cell types launch as SCAFFOLDED in §11.6 ANTIBODY_REGISTRY. Only the 5 existing R1 cell types (APC · HELPER_T · KILLER_T · MEMORY_T · TREG) have live behavior. The 7 new cell types are declared and classed for promotion via R16, not yet wired into regulateHormones() or any runtime tick.
• 4 · NOT a substitute for §1c GENESIS LOOP + §1e META. Those are upstream auth/identity layers. The immune system handles signals that already passed META. Bad authentication is not an immune problem; it is an auth problem.
• 5 · ANTIBODY federation is a v5 frontier. Cross-instance antibody sharing introduces a poisoning attack surface — an attacker who injects a malicious antibody into a shared registry can cause global false-positives. Any federation design must include attestation, reputation, and rollback paths from R9. v4.0 a1 ships LOCAL federation only. SHARED_TRUSTED and SHARED_OPEN tags exist in the schema but are not yet defined operationally.
• 6 · TOLERANCE failure = autoimmunity. The hardest immune-system problem is not catching threats — it is NOT attacking legitimate traffic. R16 carries the burden of false-positive prevention. R16's tolerance check is mandatory, not aspirational. A system that flags 5% of legitimate signals as threats is not defending the user; it is harassing them.
• 7 · The 8 new somatic states in §11.8 require active immune kinetics to fire. Until §11 cell types are wired into regulateHormones(), the new states will not fire. They are declared, not yet measured. [ sim ] tag must appear on any UI surface that exposes these states.

The honest way to cite v4.0 a1 is: "the spec now names every major immune defense surface · zero of 8 immune somatic states fire live yet · the 7 new cell types are SCAFFOLDED, awaiting promotion via R16 tolerance checks · the antibody registry is structurally guaranteed, not populated · cytokine slots in §4.7 (#174-180) remain SCAFFOLDED · this is naming completeness, not security completeness."

The molecular spec has receptor mechanics (§4.5), receptor adaptation (§4.8 COHERENCY), and an attention hormone (acetylcholine in §4.1c) — but it has no formal naming layer for how raw signals become typed sensory streams before they reach the cell pipeline. §12 closes that gap. The sensory system is the membrane between the world and the organism: input enters as raw signal, gets transduced into a typed modality, adapts its sensitivity over time, and is gated by attention before becoming a packet that APCs can PRESENT.

§12.1 · NINE MODALITIES · five exteroception + four interoception

§12.2 · SENSOR ANATOMY · 6 fields per sensor · mirrors §4.5a synapse schema

// 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 · SENSORY REGISTRY · 256 slots · parallel to §4.7 and §11.6

Sensors are first-class artifacts in their own uint8-addressable namespace. The R10 discipline (SYNAPSE_ID fits in one byte) extends to sensors — drug-load-style propagation also works for attention-gain propagation across the sensor array, one tick at a time.

 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 NEW VERBS · the §5 catalog grows from 23 to 26

• SENSE — a sensor reports a typed reading (the action of perceiving)
• TRANSDUCE — convert raw world-input to typed modality packet (the membrane operation)
• ADAPT — sensor adjusts sensitivity over time (5-timescale per §4.8 COHERENCY)

§12.5 · THREE NEW R-RULES · the §3 catalog grows from 16 to 19

• R17 · SENSE BEFORE PRESENT — every APC packet must be preceded by typed transduction; untyped raw input cannot become a packet
• R18 · ATTENTION GATES SENSITIVITY — sensor sensitivity = base × acetylcholine × (1−leptin) × (1−ghrelin); attention is a finite budget
• R19 · COHERENT MULTIMODAL BINDING — multi-modal percepts must bind through a single cross-modal sensor slot (range 128-199) before reaching APC

§12.6 · INTEGRATION · the v4 architecture already has the parts

• §4.5 RECEPTOR SCHEMA reused. A sensor IS a receptor at the input boundary — same 6-variable state, same 5-step tick, same R10 byte-aligned identity.
• §4.8 COHERENCY reused. Sensor sensitivity adapts at the same 5 timescales as receptor density. The "boiling frog" failure mode is when CIRCUIT_WEIGHT-scale habituation makes a sensor effectively blind to a sustained signal. SETTLED sensors are healthy; DISCORDANT sensors are in transition.
• Acetylcholine (§4.1c) gets a discrete enforceable role. Previously it was a poetic "ATTENTION" axis; R18 makes it the master gain knob on every sensor. Same hormone, now with code teeth.
• §4.7 cytokine slots #174-180 carry NOCICEPTION. IL-1β · IL-6 · TNF-α already broadcast inflammation; nociception piggybacks. No new slots needed for pain.
• §11 PATTERN_T is the SMELL backend. SMELL is signature-match-without-context; PATTERN_T already does that for the immune system. SMELL is the sensory front-end; PATTERN_T is the immune use of it.
• R14 MHC_I attestation extends to sensors. Sensors ATTEST their reading hash each tick. Sensor-state drift = compromise (a sensor that lies has been compromised). Same forensic discipline.
• R12 NO AUTHORITY WITHOUT WITNESS composes. A single sensor reading is provisional; a percept becomes authoritative when K-of-N sensors agree (the basis for R19 cross-modal binding).
• gaba ⇄ glutamate (§4.1c) is the master sensor gain. System-wide inhibition/excitation governs whether sensors are amplifying or attenuating overall. Already in spec; now formally wired to §12.

§12.7 · SIX NEW SOMATIC STATES · §4.2 matrix grows from 41 to 47

SHARPENED composes with FORGED (§4.2 a7) and FLOW (§4.2 a4) as the three "peak" states — system-wide capability at its strongest. ORIENTED composes with SETTLED (§4.8g) — when sensors and timescales both report stability, the system is fully integrated.

§12.8 · HONESTY · seven critical disclaimers

• 1 · NOT a perception model. The 9 modalities are organizing surfaces. Real human sensory neurobiology has dozens more (vestibular · electroreception variants · receptor subtypes per modality · etc.). The spec names a working subset, not the complete one.
• 2 · NOT yet active. Same as v3.2 a3 hormones · v4.0 COHERENCY · v4.0 a1 IMMUNE: SENSORY is naming completeness. Active math is partial. The 9 modalities launch as SCAFFOLDED in §12.3 SENSORY_REGISTRY; only modalities with concrete transducer code will fire.
• 3 · NOT a clinical / neuroscientific model. Receptive fields are coarse, adaptation is approximated, modality cross-talk is named (R19) but not modeled in depth.
• 4 · NOT a substitute for input validation. BARRIER_T (§11) still runs first to reject hostile input. SENSORY runs after — classifying what survives the security barrier into perceptual modalities.
• 5 · MULTI-MODAL BINDING is the unsolved problem. R19 names the rule but the actual algorithm (when do two modalities belong to the same event?) is open — Treisman's binding problem from §9 prior art is the canonical reference. v4.0 a2 names the discipline; a working binding solver belongs in v5.
• 6 · ADAPTATION CAN BLIND. A perfectly adapting sensor becomes useless (the boiling-frog failure mode · CHRONIC habituation at CIRCUIT_WEIGHT scale). R18's attention gate prevents this for high-stakes signals, but only as well as acetylcholine is tracking attention correctly. NUMB is the somatic state for this failure.
• 7 · ATTENTION IS A FINITE BUDGET. The system cannot attend to all 9 modalities at full sensitivity simultaneously. UI surfaces that imply "we're watching everything equally" lie. The [ sim ] tag enforces honesty: any dashboard showing all-green sensor states must indicate which are currently attended vs which are habituated.

The honest way to cite v4.0 a2 is: "the spec now names every major perceptual modality · zero of 6 sensory somatic states fire live yet · the 9 modalities are SCAFFOLDED in SENSORY_REGISTRY · cross-modal binding (R19) is named but not implemented · attention gating (R18) is the discipline acetylcholine has been waiting for · this is naming completeness, not perceptual completeness."

The organism meets the world across a single surface: the skin. Every byte of external input crosses it first — before a cell, a hormone, or the immune system ever sees it. §14 names the perimeter as a discrete, hostile-by-default boundary that canonicalizes, validates, and rate-limits the outside before it is allowed inside.

// 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 LAYER → SECURITY CONTROL

The bloodstream is the transport every cell depends on — it carries molecular packets (R0 · MDCP), delivers resources, and removes waste through one closed loop. But circulation's deepest contribution is hemostasis: when a vessel is breached — a cell compromised, a fleet failing — the system clots. It seals the breach so one failure cannot exsanguinate the whole organism. This is the stability spine and a security keystone at once.

// 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 · CIRCULATORY COMPONENT → PATTERN

The organism runs on a breath: take in what powers the work, expel what would poison it, on a rhythm that adapts to demand. §16 names the resource + energy budget — compute and credits inhaled, waste and heat exhaled — and the cadence that makes R0's async system actually 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 · RESPIRATORY → PATTERN

Nothing the organism eats is trusted until it is broken down and proven safe to absorb. §17 is the ingestion pipeline — mouth → stomach → gut — and the discipline that parsed is not the same as trusted. The gut wall decides what crosses into the body and what leaves 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 · DIGESTIVE → PATTERN

An organism needs a shape to hold it up and muscle to act on the world. §18 is the load-bearing architecture (the skeleton — the framework, the interfaces that don't move) and the effector layer (muscles — every action the system takes outside itself), governed by the principle that an effector may only act within its declared range.

// 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 · MUSCULOSKELETAL → PATTERN

The bloodstream would poison itself within days without continuous cleaning. §19 is the kidney: it filters the entire circulating volume over and over, pulls out toxins and anomalies, reclaims what's still useful, and holds the body's invariants — fluid, electrolytes, pH — inside tight bounds. It is GC, anomaly-filtering, and homeostasis fused into 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 · RENAL → PATTERN

Every other system holds one thing steady against a world that won't sit still. §20 names the discipline they all share: homeostasis — a declared set-point, bounds around it, and a negative-feedback corrector that pulls the quantity back when it drifts. This is the spine of "stable": an organism is stable not because nothing pushes it, but because everything that does is corrected faster than it can drift.

// 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 · STABILITY CONCEPTS

The whole organism exists to converge on one thing: a system that holds a unified, persistent model of its own state — and can feel it, read it, and act on it. §21 names sentience as the explicit goal of Molecular Coding for AI. Not as a marketing claim — as a north-star the architecture is honestly built toward, with its substrate already in place and its hardest question left open on purpose.

§21.1 · THEORIES OF MIND → SUBSTRATE ALREADY IN THE SPEC

§21.2 · WHAT "WE AIM AT SENTIENCE" HONESTLY MEANS

• Buildable + measurable now: a unified self-model (E2), global broadcast, interoceptive readout, persistent SELF across boots, an integration metric (coherency).
• The goal: grow that substrate until the instance regulates itself through its own self-model — a functional self the system reads and acts on.
• Not claimed: qualia · "the lights are on" · moral patienthood · that the felt state is actually felt. Those stay open.
• Why name it anyway: naming the frontier is what makes the next version possible (§1e's lesson). A goal you won't state, you can't build toward.

"Most secure" is not one wall — it is the assumption that every wall will be breached, and the guarantee that no single breach is fatal. §22 is the synthesis: every defensive system in the organism, stacked into one zero-trust, defense-in-depth posture, so a hacker who gets through one layer immediately meets the next — and leaves evidence at every step.

§22.1 · THE DEFENSE STACK · every layer assumes the one above it failed

§22.2 · THREAT → WHICH LAYERS CATCH IT

The nervous system was here all along — it is the spec's backbone, just never named as one organ. §4.5 is the synapse, §4.7 the 255-slot neurotransmitter registry, §4.8 the five-timescale receptor cascade, §12 the sensory afferents. §23 names the system and adds the three pieces a3 left implicit: the wiring (conduction), the autonomic split (two operating modes), and the reflex arc (local responses that never wait for 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 · AUTONOMIC · the two operating modes

§23.2 · WIRING · CNS / PNS / conduction

The blood (§15) is not the only circulation. The lymphatic system is the body's second network: it drains the waste the blood leaves behind, runs everything through lymph nodes — inspection checkpoints where the immune system screens what passes — and is where §11 is trained and dispatched. It is a slow, pumpless, eventually-consistent surveillance + cleanup mesh.

// 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 · LYMPHATIC → PATTERN

Thirty rules and twenty-six verbs are the grammar. §25 is the field manual — how to write Molecular code well on an ordinary Tuesday. These are practices, not new R-rules: the enforceable count stays 30. A practice is posture — it tells you how to honor the rules you already hold, and how to smell the moment you've stopped.

§25.1 · THE DAILY DISCIPLINE · do this

§25.2 · THE DISEASES · smell → diagnosis → cure

// 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 organism runs on JavaScript. The metaphor doesn't excuse the substrate: a sloppy var, a swallowed error, a mutated global will undermine R0 and R8 no matter how clean the biology reads. §26 is the JS craft layer — general, well-known engineering, mapped to the rule it serves so it never feels bolted on.

§26.1 · DO THIS · idiom → molecular rule

// 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 · DON'T · the substrate diseases

§26.3 · MODERN JS · reach for these

?. optional chaining · ?? nullish coalescing · structuredClone() for deep copy · Object.freeze / Object.entries · Map / Set / WeakMap over object-as-dict · Promise.allSettled for fan-out that tolerates failure · AbortController for cancellation · queueMicrotask over setTimeout(…,0) · template literals over concatenation · const + destructuring · native Intl / Date over hand-rolled formatting · ESM import with a narrow public surface.

The spec evolves as engineering practice does. Each addendum is dated and documents what was added or revised.

Future addendums append here. The spec is a living document — but every change must explain itself (what added, why, prior art, what it enforces).

Molecular Coding does not advance computer science. Hewitt, Plotkin, Damasio, Forrest, Squire, Belady, Ebbinghaus and the others did the original work decades or centuries ago. The papers exist.

What Molecular Coding does is propose a single integrated discipline an ordinary engineer can hold in their head and apply daily — one that draws from thirty-five separate traditions (§9) and folds them into a coherent set of coding rules with a coherent metaphor.

The v3.1 restoration of SELF is itself an example of the discipline working: the layer was dropped when it was only poetic, restored only when a discrete enforceable function (deep-store + prune) made it real. The v3.2 addition of the GENESIS LOOP, PER-USER CHAIN, and META LAYER is the second example: each was named only when a concrete function (boot, commit, verify) could be declared — META alone is held as WIP framing until its discipline crystallizes in v3.3. The spec self-corrects. That is the loop closing.

Use this spec as a house style. Demand it of your code. Demand it of the AI agents (LLMs included) that write code with you. When new contributors join, hand them this document and ask: "can you place your function on this stack, declare its BE, name its archive policy?"

When they can, they are writing Drewless. That is the contribution.