organism/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md

# Tripartite Synapse — Pseudocode v17

> Companion: `tripartite_synapse_v17_biology.md` · principle: `logic_principles_v3`.
> Changes from v16 — NIGHT is no longer an external driver; it is an EMERGENT, per-component
> state driven by a fatigue→sleep-pressure loop. Actors at every scale are written as peers.
>  (1) EIGHT actors in one uniform template:
>      LOCAL components — SOMA · PRE · POST · DEND · AXON · ASTROSYNAPSE (behave by DAY)
>      CELL actors      — NEURON (over soma/pre/post/dend/axon) · ASTROCYTE (over astrosynapses)
>      SYSTEM actor     — HYPOTHALAMUS (integrates fatigue, emits sleep-pressure)
>  (2) DAY/NIGHT are PER-COMPONENT emergent states, not a global clock: a component is in NIGHT
>      when its OWN activity is low AND sleep-pressure is high; back to DAY when pressure falls.
>      (transition rule stated once in Conventions). The HYPOTHALAMUS alone is CONTINUOUS.
>  (3) the external NIGHT driver is REMOVED. Restructuring is gated by local low-activity
>      (behavior and restructuring are mutually exclusive at the substrate).
>  (4) higher actors INTEGRATE constituents' emitted activity by their day and BROADCAST
>      permission / renormalization / reallocation by their night — they never reach in;
>      each component restructures ITSELF in response to arrived signals (locality holds).
>  (5) governing rule: NO actor authorizes its own restructuring — each is PUT IN THE POSITION
>      to restructure by the actor above it (which holds an aggregate it cannot see and opens a
>      quiet window it cannot open). The system acts locally and consolidates hierarchically.
> Carried: cyclic/phased NIGHT, occupancy reset, tag-as-fuel, transit, two-resource metabolism.

---

## Functional groups (seven-group grammar)

```
RECEIVE   take in resources + signals that arrived from outside     (boundary: in)
TRACE     maintain the trace hierarchy — deposit fast trace; accumulate
          possible_tag + endurance_need; stabilize tag on coincidence
ADJUST    compute local operating parameters from structure + traces + modulators
BEHAVE    the component's defining action, within both ceilings
EMIT      send out — signals (messages) + resources (shipments)      (boundary: out)
RECOVER   refill own private pools consumed by behaving
DECAY     let traces recede, closing their windows
```

EVALUATE merged into TRACE: judging a behavior is always maintaining a trace, whether or not
a trace is written. BEHAVE and EMIT stay separate — EMIT is the output half of the locality
interface (RECEIVE/EMIT are the only boundary crossings). TRACE spans all timescales: the
soma's inactivation, adaptation, and nuclear-Ca deposits are all TRACE. Order within a context
follows data dependencies; TRACE reads/writes whatever trace state is current.

EVERY FLOW HAS A TIMESCALE. Decay relaxes toward 0 over τ; creation/arrival relaxes toward a
target over τ — the same first-order operator. Within-step writes are the special case τ ≪ Δt.
Rate-limited inflows (fill/refill/flux·Δt) carry their τ implicitly; shipment carries an
explicit transit delay (see `transit`).

THE GROUPS MOVE BETWEEN TIERS (the ladder; see logic_principles "The Timescale Ladder").
Four tiers: FAST (ms–s) · MEDIUM (s–min) · SLOW (hr) · PERSISTENT (NIGHT-written). The groups
move evidence UP the ladder and read capacity DOWN it:

```
  ADJUST    reads PERSISTENT ceiling + FAST trace  → sets this step's operating point (down)
  BEHAVE    acts at FAST, bounded by the PERSISTENT ceiling                          (down)
  TRACE     deposits FAST, accumulates FAST→MEDIUM evidence, stabilizes MEDIUM→SLOW tag (up)
  RECOVER   refills toward the PERSISTENT ceiling                                     (down)
  DECAY     relaxes FAST · MEDIUM · SLOW (PERSISTENT never decays in DAY)
  NIGHT     commits SLOW tag + MEDIUM endurance_need → PERSISTENT ceilings            (up)
```

Capacity flows downward (slow sets the ceiling for fast); evidence flows upward (fast
accumulates toward slow). Each component's DECAY group below is banded by tier to show this.

NIGHT IS THE SAME GRAMMAR, ITERATED, WITH THE FLOW REVERSED. NIGHT is not a separate section —
each component carries a `NIGHT |` block, and a driver loops all blocks for cycle = 1,2,3…
until the night ends. DAY runs bottom-up (consumers act first, evidence ascends leaves→roots);
NIGHT runs top-down (producers act first, capacity descends roots→leaves). Per cycle, each
component:

```
  RECEIVE   take in the material + energy batch that arrived from my producer this cycle
  TRACE     read my own tag / endurance_need (the standing demand)
  ADJUST    size this cycle's commit from material + energy actually on hand
  BEHAVE    commit a BATCH: structure += Δ (from tag) ; budget_ceiling += Δ' (from need)
            spend material + energy ; SPEND the tag/need by the committed amount (tag-as-fuel)
  EMIT      ship a batch of material + energy one hop down to my consumers (demand-weighted)
  RECOVER   reclaim material from any ceiling that decayed this cycle (energy is NOT recovered)
  DECAY     unmaintained ceilings drift down a little; tags decay a little
```

Roots (SOMA, ASTRO cell body) PRODUCE the batch each cycle (RECEIVE = production, capped by
glucose / CREB). The night ends when DEMAND is exhausted (no tag stands above tag_expiry,
system-wide) OR SUPPLY is spent (the night's energy throughput is used up) — whichever first.
Unspent tags are NOT cleared; they carry to the next DAY and compete again next NIGHT. The
top-down order needs no schedule: iterating the local cycle delivers capacity to distal sites
over successive cycles, as transport physically does.

DAY AND NIGHT ARE PER-COMPONENT EMERGENT STATES, NOT A GLOBAL CLOCK. There is no global SCOPE
variable. Each component is in its own DAY or NIGHT, decided locally from its own activity and
the arrived sleep-pressure signal. The labels `DAY | …` and `NIGHT | …` below denote these
LOCAL states. One transition rule governs every component (stated once here, not repeated):

```
TRANSITION (evaluated per component, from local state + the arrived signal):
    enter NIGHT  when own_activity < rest_thr  AND  sleep_pressure > sleep_thr
    enter DAY    when sleep_pressure < wake_thr
  own_activity = the component's own running activity trace (it cannot restructure while busy:
                 behavior and restructuring compete for the same substrate — mutual exclusion).
  sleep_pressure = arrived signal broadcast by the HYPOTHALAMUS (see below).
```
Components therefore cross into NIGHT at different times — a wave, not a switch (local sleep).

THE FATIGUE LOOP REPLACES THE EXTERNAL DRIVER. The system has no scheduler. Activity generates
fatigue; the hypothalamus integrates fatigue and broadcasts sleep-pressure; high pressure (plus
a component's own quiet) opens the restructuring window; restructuring discharges fatigue;
discharge lowers pressure; components re-enter DAY. DAY and NIGHT are the two phases of one
homeostatic loop the system runs on itself.

```
  every component  →  emits fatigue (metabolic debt, unspent demand)  ↑
  HYPOTHALAMUS     →  integrates fatigue, emits sleep_pressure         ↓ (CONTINUOUS — never sleeps)
  every component  →  reads sleep_pressure + own activity → enters DAY or NIGHT locally
```

ACTORS ARE PEERS AT EVERY SCALE; EACH IS PUT IN POSITION BY THE ONE ABOVE. No actor authorizes
its own restructuring. Each holds an aggregate its constituents cannot see and opens a window
they cannot open, then BROADCASTS — it never reaches into a constituent's interior.

```
  HYPOTHALAMUS   integrates fatigue from all → broadcasts sleep_pressure   (system, CONTINUOUS)
       ↓ signal
  NEURON         integrates its components' activity/weight → broadcasts    (cell actor)
  ASTROCYTE      rest-permission + renormalization / reallocation           (cell actor)
       ↓ signal   (NEURON over soma/pre/post/dend/axon ; ASTROCYTE over astrosynapses)
  COMPONENTS     soma · pre · post · dend · axon · astrosynapse — each restructures ITSELF
                 when its own DAY/NIGHT transition (above) grants the window
  [ ASSEMBLY / NETWORK ]  replay_reweight arrives as an EXTERNAL signal (like dopamine/glucose)
```

The two cell actors are structurally identical — same integrate-and-broadcast role, different
constituents and conserved quantity: NEURON conserves activity/weight, ASTROCYTE conserves
territory demand/load. Both have their own DAY (integrate, allocate in the gaps) and NIGHT
(broadcast the restructuring window). The HYPOTHALAMUS alone has no night: it runs CONTINUOUS,
always integrating fatigue and emitting sleep-pressure, spanning every other actor's day and
night — the clock that never sleeps.

NIGHT IS PHASED, AND OCCUPANCY RESETS. When a component is in NIGHT, early cycles DOWNSCALE
(occupancy filled during its day — VGCC_active, AMPA_surface, possible_tag — driven toward
baseline by multiplicative-global scaling broadcast by the neuron; total weight renormalized),
later cycles COMMIT (survivors' tags build ceilings). The rule the phasing enforces: WHAT
PERSISTS ACROSS A NIGHT MUST HAVE EARNED PERSISTENCE — occupancy that earned no tag returns to
baseline; only ceilings carry forward. A tagged synapse starts the next day strong because its
ceiling was raised, not because its transient occupancy was spared.

---

## Conventions

```
SCOPE = {DAY, NIGHT}   CONTEXT = {AP, NOT_AP, bAP, NOT_bAP, CONTINUOUS}

VARIABLE TIERS (timescale = meaning; see logic_principles "The Timescale Ladder")
  FAST       (ms–s)   immediate response     fast_trace
  MEDIUM     (s–min)  occupancy + evidence   possible_tag · endurance_need · VGCC_active · AMPA_surface · RRP
  SLOW       (hr)     consolidation bridge   tag
  ─────────────────────────────────────────────────────────────────────────────
  PERSISTENT (NIGHT)  capacity (the ceilings) structure · budget_ceiling
                      energy (not recoverable) · material (recoverable)

DAY      budget · fast_trace · possible_tag · endurance_need
BRIDGE   tag (POST: CANDIDATE→STABLE)
NIGHT    energy (not recoverable) · material (recoverable) · structure · budget_ceiling

LOCALITY only local state + arrived signals; no component reads another's internal state.

CLEFT MESSAGE CHANNELS              SHIPMENT CHANNELS (transit-delayed)
  glutamate     PRE → POST, ASTRO     soma_ship_dend SOMA→DEND
  astro_Dserine ASTRO → POST          soma_ship_axon SOMA→AXON
  retro_NO      POST → PRE (+)        dend_ship_post DEND→POST
  retro_eCB     POST → PRE (−)        axon_ship_pre  AXON→PRE
```

---

## Primitives (return the increment; caller applies it)

```
sat(x, K) = x / (K + x)

fill(pool, ceiling, rate, cost, budget) -> amount:        // PRIVATE reserve, rate-limited (implicit τ)
    amount = min(rate, ceiling - pool)·Δt;  budget -= amount·cost;  return amount

refill(c from supply S) -> amount:                         // CONTESTED supply, gap-bounded
    demand = c.budget_ceiling - c.budget
    factor = min(1, S / (Σ demand over components on S + ε));  S -= demand·factor
    return demand·factor

ship(from_budget, demand_sig, frac, cost) -> amount:       // emit into transit (not to target directly)
    amount = min(from_budget·frac, demand_sig);  from_budget -= amount·(1+ship_cost);  return amount

transit(channel, τ_transport) -> arrival:                  // delivers in-transit cargo over τ
    arrival = channel·(Δt/τ_transport);  channel -= arrival;  return arrival
```

---

## SHARED parameters

```
dopamine  NE  ACh                         // organism broadcasts (external)
replay_reweight[·]                        // assembly/network replay re-weighting (external, NIGHT)
glucose  geometry                         // physical (external)
sleep_pressure                            // emitted by HYPOTHALAMUS, read by all (the day/night signal)
rest_thr  sleep_thr  wake_thr             // per-component DAY↔NIGHT transition thresholds
elig  dop_thr  tag_thr  tag_expiry        // strength gates (universal)
traj_thr  endur_thr                       // endurance gates (universal)
ship_cost                                 // transport overhead (all shipments)
{dend,axon,pre,post}_ship_frac            // DAY budget-shipment fractions
τ_transport_{dend,axon,spine,bouton}      // shipment transit times (distance-dependent)
ε
```

## NIGHT parameters (consolidation only)

```
slot_batch  cap_batch  f_cap              // per-CYCLE commit sizes / endurance fraction
night_energy_ceiling                      // total energy a single night can spend (supply bound)
Δt_cycle                                  // duration of one NIGHT cycle
maint_frac  cap_frac                      // maintenance allocation
decay_rate  capacity_decay_rate  recycle  // passive ceiling decay + material recovery
homeostatic_ceiling  coherence_factor  assembly_cost  biogenesis_cost  maint_cost
f_dend  f_axon  f_spine  f_bouton         // per-cycle material/energy ship fractions (down the chain)
downscale_factor                          // per-early-cycle multiplicative occupancy reset (<1)
neuron_weight_ceiling                     // the cell's total-weight budget (renormalization target)
early_phase_frac                          // fraction of night cycles that are DOWNSCALE phase
```

---
---
# LOCAL COMPONENTS
> Each behaves by its DAY and restructures by its NIGHT — per-component emergent states
> (see Conventions: the transition rule). `DAY | …` / `NIGHT | …` label local states, not a clock.
---

## PRE

The presynaptic bouton releases neurotransmitter and gathers evidence about whether that
release was worth strengthening and worth sustaining. Like every component it turns one ring —
ACTION → EVALUATION → PREPARATION — in two directions: outward by DAY (against the cleft), inward
by NIGHT (against the economy).

**DAY · ACTION (the AP) — the bouton releases.** The amount released depends on residual
**calcium** (the fast trace, set by this spike), the current **VGCC coupling occupancy** (how
tightly channels are coupled right now, bounded by structure), the two **retrograde messages**
(`retro_eCB` brakes, `retro_NO` confirms release reached a responsive target), and the
availability of **fuel and vesicles**. The action deposits the fast trace the rest of the turn
reads. Two shortfalls read differently: a fuel shortfall on a succeeding release is *endurance*
evidence; an empty pool with fuel to spare is ordinary short-term depression.

**DAY · EVALUATION (after the AP, trace fresh) — climb toward the tag.** Reading the fast trace,
the bouton accumulates eligibility (`possible_tag`) and, on the dopamine coincidence, the `tag` —
the inert token minted for the night. It never acts here; it lays down evidence.

**DAY · PREPARATION (trace decaying) — ready the next release.** The bouton latches the retrograde
messages, tightens its VGCC coupling from accumulated eligibility (reversible short-term
potentiation, no dopamine, bounded by structure — readiness, not evidence), refills budget and
vesicles *toward the next demand* (not a restoration — forward-facing), and lets its traces decay.
Preparation is the sole gateway to the next action.

**NIGHT — the ring turned inward.** ACTION is the coherence check (does post and astro concur this
change should be kept). EVALUATION is draw-and-commit: burn shipped material and energy into
**structure** (where a validated tag stood) or **budget capacity** (where fuel interrupted a
succeeding release), spending the tag — the token minted for the next day. PREPARATION is
make-room: take the descended constraint, recycle material from decayed ceilings, ready for the
next round. The bouton is not a sink — by night it emits inward and upward (fatigue, demand,
recycled material).

```
// PARAMETERS  K_release · release_cost · fusion_cost · vatpase_cost · spillover · brake
//             stp_thr · coupling_gain · coupling_drift · VGCC_baseline
// INTERFACE
//   EMIT      glutamate → POST, ASTRO
//   RECEIVE   retro_NO, retro_eCB ← POST  (signals latched in EVALUATION/PREPARATION; pools refill in PREPARATION)
//   READ      glutamate (own cleft, autobrake) ; dopamine (gates tag)
//   OWN       pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling
//             VGCC_active (occupancy: current coupling, filled toward VGCC_coupling ceiling)
//   SUPPLY    astro_lactate[syn] ← ASTRO ; axon_ship_pre ← AXON ; pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT)
//   EMERGENCY shockwave_lockdown ← ASTRO
//
// TRACE CREATION MODES (every trace: trace += input·Δt − trace·(Δt/τ_decay))
//   impulse    input = quantum·δ(event)  — a point event; no rise time, τ = decay only   (FAST)
//   accumulate input = rate(condition)·Δt — ramps while a condition holds; τ = rise AND decay (MEDIUM/SLOW)
//
// THE RING: ACTION (lateral, punctate — the AP) → EVALUATION (local, trace fresh — climb to tag)
//           → PREPARATION (vertical, trace decaying — ready next release). Phase edges are
//           event/decay-timed, not clocked: AP ends preparation; fast-trace decay ends evaluation.

DAY · ACTION | AP:                                         // lateral: release into the cleft
    // deposit the fast trace THIS action leaves  (FAST · impulse)
    pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)·δ(spike)
    drive = sat(pre_fast_trace × VGCC_active, K_release) × (1 - retro_eCB_local)
    if pre_budget < release_cost:                          // FUEL shortfall → endurance evidence
        suppress(NT_flux)
        if pre_fast_trace > traj_thr:                      // MEDIUM · accumulate
            pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)·Δt
        exit
    if RRP == 0:  suppress(NT_flux);  exit                 // OCCUPANCY shortfall → STD (not endurance)
    NT_flux = RRP × drive;  RRP -= NT_flux·Δt;  pre_budget -= NT_flux·fusion_cost
    glutamate += NT_flux·Δt                                // EMIT glutamate → POST, ASTRO
    if glutamate > spillover: drive *= brake               // own-cleft autobrake

DAY · EVALUATION | after AP, fast trace fresh:             // local: climb the ladder toward the tag
    if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt        // MEDIUM · accumulate
    if dopamine > dop_thr and pre_possible_tag > tag_thr:                  // SLOW · accumulate
        pre_tag += dopamine × pre_possible_tag·Δt          // the inert token minted for NIGHT

DAY · PREPARATION | fast trace decaying:                   // vertical: ready the next action
    retro_NO_local = retro_NO;  retro_eCB_local = retro_eCB     // latch descended/arrived signals
    // short-term potentiation: eligibility → coupling readiness (NO dopamine; drifts back)
    if pre_possible_tag > stp_thr:
        VGCC_active = min(VGCC_active + coupling_gain × pre_possible_tag, pre_structure.VGCC_coupling)
    else:
        VGCC_active = max(VGCC_active - coupling_drift·Δt, VGCC_baseline)  // STD = un-honored decay
    // refill BOTH pools TOWARD next demand (forward-facing, not restoration)
    pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton))
    RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
    // decay times the phase edges (fast clears evaluation; medium/slow settle; persistent waits for NIGHT)
    pre_fast_trace *= decay(100ms)                                          // FAST
    pre_possible_tag *= decay(s);  pre_endurance_need *= decay(min)         // MEDIUM
    pre_tag *= decay(hr)                                                    // SLOW
    dopamine *= decay(ms);  retro_NO *= decay(s);  retro_eCB *= decay(s)

NIGHT · ACTION | coherence check:                          // lateral: does post & astro concur?
    coh = coherence_signal                                 // arrived verdict (pre+post+astro tags aligned)
    // (this is the night's "release": signal the standing claim, read what returns; leaves coh as trace)

NIGHT · EVALUATION | draw & commit (only if coherent + permitted):   // local: mint structure for next DAY
    if rest_permission and pre_tag > tag_expiry:
        Δ = min(slot_batch, pre_material, pre_energy·f_cap)
        pre_structure += Δ × coh;  pre_material -= Δ;  pre_energy -= Δ·assembly_cost
        pre_tag -= Δ                                       // tag-as-fuel; energy burned only here (irreversible)
    if rest_permission and pre_endurance_need > endur_thr:
        Δ' = min(cap_batch, pre_material·f_cap, pre_energy·f_cap)
        pre_budget_ceiling += Δ';  pre_material -= Δ';  pre_energy -= Δ'·biogenesis_cost
        pre_endurance_need -= Δ'
    // if not coherent / not permitted: draw nothing, hold the tag, leave resource for peers — defer

NIGHT · PREPARATION | make room:                           // vertical: take constraint, recycle, ready
    // receive shipped batch for the next round (forward-facing)
    pre_material += transit(pre_material_ship, τ_transport_bouton)
    pre_energy   += transit(pre_energy_ship,   τ_transport_bouton)
    // apply the descended constraint to MYSELF (neuron only broadcasts; I scale myself)
    VGCC_active *= occupancy_downscale;  pre_possible_tag *= occupancy_downscale
    if renorm_signal arrived:
        freed = pre_structure × (1 - renorm_signal);  pre_structure *= renorm_signal
        emit(freed → recycled material pool)
    // recycle material from decayed ceilings; unmaintained ceilings drift; emit inward/upward
    pre_material += pre_ceiling_shrinkage·recycle          // energy NOT recovered
    pre_structure -= decay_rate·Δt_cycle;  pre_budget_ceiling -= capacity_decay_rate·Δt_cycle
    pre_structure += min(pre_maint, maint_cost);  pre_budget_ceiling += min(pre_cap_maint, cap_cost)
    pre_tag *= decay(slow);  pre_endurance_need *= decay(slow)
    emit(pre_fatigue, pre_demand → upward)                 // not a sink: emits inward/upward by night
```

---

## POST

The postsynaptic spine is the synapse's primary memory locus: it detects coincident input,
runs the calcium dynamics that decide potentiation versus depression, and requires the most
validation (three coincidences) before committing. Its behavior unfolds across two DAY
contexts and the NIGHT scope.

**During DAY, during NOT_bAP — the spine integrates input and decides plasticity.** Three
calcium sources feed its fast trace: AMPA current (small Ca, begins ejecting the NMDA Mg block),
NMDA (large Ca, but only on the local coincidence of depolarization + astrocyte D-serine +
glutamate), and — in the bAP context — the back-propagating spike. High calcium drives AMPA
receptors to the surface (short-term potentiation, occupancy filled toward the slot ceiling, no
dopamine); when calcium falls, they drift back (short-term depression as a consequence). The
spine also emits two retrograde messages from its own state — NO when it responded, an
endocannabinoid brake when over-driven — and accumulates a dopamine-gated tag toward
consolidation. A fuel shortfall while calcium was climbing toward a tag is endurance evidence;
a surface already at its ceiling is a structural limit, not endurance.

**During DAY, during bAP — the back-propagating spike confirms coincidence.** The somatic spike
arrives at the spine, adds depolarization and calcium, and supralinearly amplifies an existing
candidate — the soma's confirmation that it fired, one of the three coincidences the spine
requires.

**During NIGHT — the spine's ceilings are rewritten.** NIGHT raises **structure** (the AMPA
slot ceiling, spine volume) where a validated tag accumulated — with a coherence bonus when pre,
post, and astro all tagged the same synapse — and **budget capacity** where fuel interrupted a
climbing calcium trajectory. Both draw the same finite pool, so they compete; unmaintained
ceilings drift down.

```
// PARAMETERS  K_AMPA · AMPA_Ca · AMPA_cost · NMDA_cost · bAP_cost · pka_cost · traffic_cost
//             req_cost · Mg_eject · Dserine_thr · Ca_STP · Ca_TAG · eCB_thr · drift · baseline
//             NO_synth_cost · eCB_synth_cost
// INTERFACE
//   EMIT      retro_NO (+), retro_eCB (−) → PRE
//   RECEIVE   (signals) glutamate ← PRE ; astro_Dserine ← ASTRO ; bAP ← DEND/SOMA ; dopamine
//   READ      glutamate ; astro_Dserine ; bAP (dend_structure.bAP_fidelity) ; dopamine
//   OWN       post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling
//   SUPPLY    astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND ; post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
//   EMERGENCY shockwave_lockdown ← ASTRO
// NOTE      POST endurance is own-state only (own Ca climbing); no arrived feedback term.

DAY | NOT_bAP:
    // ADJUST    (AMPA drive from arrived glutamate)
    a = sat(glutamate, K_AMPA)
    // BEHAVE    (SOURCE 1 AMPA: current + small Ca + begins Mg ejection)
    AMPA_current = a × AMPA_surface;  Vm += AMPA_current;  post_budget -= AMPA_cost
    // TRACE     (Ca deposited by AMPA)
    post_fast_trace += AMPA_Ca·AMPA_current
    // BEHAVE    (SOURCE 2 NMDA: large Ca on local coincidence)
    if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0:
        post_fast_trace += NMDA_Ca(glutamate)·rise_speed();  post_budget -= NMDA_cost
        // EMIT      (+ NO/BDNF: "release reached a responsive target")
        retro_NO += NO_emit(post_fast_trace);  post_budget -= NO_synth_cost
    // EMIT      (− endocannabinoid / DSE when over-driven)
    if Vm > eCB_thr:
        retro_eCB += eCB_emit(Vm);  post_budget -= eCB_synth_cost
    post_fast_trace *= decay(ms)
    // BEHAVE    (STP fill slots from private reserve ; else STD drift = consequence)
    if post_fast_trace > Ca_STP:
        if post_budget < traffic_cost:
            // FUEL shortfall → endurance (own Ca was climbing toward a tag)
            if post_fast_trace > traj_thr and post_fast_trace_rising:
                post_endurance_need += post_fast_trace
        else if AMPA_surface < post_structure.slot_ceiling:
            AMPA_surface += Ca_insert(post_fast_trace);  post_budget -= traffic_cost
        // else: surface already at slot_ceiling → structure-limited (not endurance)
    else:
        AMPA_surface = max(AMPA_surface - drift·Δt, baseline)   // STD = consequence
    // TRACE     (strength: CANDIDATE then STABLE via dopamine)
    if post_fast_trace > Ca_TAG: post_possible_tag += post_fast_trace;  post_budget -= pka_cost
    if dopamine > dop_thr and post_possible_tag > tag_thr:
        post_tag += dopamine × post_possible_tag
    // RECOVER   (refill budget from contested supply)
    post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine))
    // DECAY
    //   FAST   (ms–s) — post_fast_trace already decayed above (intra-step, pre-tagging)
    //   MEDIUM (s–min)
    post_possible_tag *= decay(min);  post_endurance_need *= decay(min)
    //   SLOW   (hr)
    post_tag *= decay(hr)
    //   (signals)
    dopamine *= decay(ms)
    //   (PERSISTENT: post_structure, post_budget_ceiling — no DAY decay; NIGHT only)

DAY | bAP:
    // BEHAVE    (SOURCE 3 bAP: depolarization + Ca, amplifies existing signal)
    Vm += bAP_depol × dend_structure.bAP_fidelity;  post_budget -= bAP_cost
    // TRACE     (supralinear boost only if a CANDIDATE is present)
    if post_possible_tag > Ca_TAG: post_fast_trace += bAP_Ca_boost()

NIGHT | cycle:                                             // leaf consumer (no downstream emit)
    // RECEIVE   batch arrived from DEND (material) + SOMA (energy) this cycle
    post_material += transit(post_material_ship, τ_transport_spine)
    post_energy   += transit(post_energy_ship,   τ_transport_spine)
    // TRACE     read standing demand (post_tag → structure ; post_endurance_need → budget_ceiling)
    // ADJUST    coherence applies to POST (synaptic component)
    coh = coherence_signal
    // BEHAVE    commit batches; spend tag/need as fuel
    if post_tag > tag_expiry:
        Δ = min(slot_batch, post_material, post_energy·f_cap)
        post_structure += Δ × coh;  post_material -= Δ;  post_energy -= Δ·assembly_cost
        post_tag -= Δ
    if post_endurance_need > endur_thr:
        Δ' = min(cap_batch, post_material·f_cap, post_energy·f_cap)
        post_budget_ceiling += Δ';  post_material -= Δ';  post_energy -= Δ'·biogenesis_cost
        post_endurance_need -= Δ'
    // EMIT      (none — spine is a leaf)
    // RECOVER   reclaim material from decayed ceilings
    post_material += post_ceiling_shrinkage·recycle        // energy NOT recovered
    // DECAY
    post_structure -= decay_rate·Δt_cycle;  post_budget_ceiling -= capacity_decay_rate·Δt_cycle
    post_structure += min(post_maint, maint_cost);  post_budget_ceiling += min(post_cap_maint, cap_cost)
    post_tag *= decay(slow);  post_endurance_need *= decay(slow)
```

---

## DEND

The dendritic branch is the postsynapse's supply line and the neuron's input integrator. It
carries the back-propagating spike out to its spines, integrates their voltages toward the
soma, and ships material and budget to the spines it supports. Its behavior unfolds across two
DAY contexts and the NIGHT scope.

**During DAY, during bAP — the branch propagates and integrates.** When the soma fires, the
branch propagates the back-propagating spike toward its spines, with a fidelity that attenuates
with distance (distal spines get weaker confirmation, are harder to potentiate). It deposits
branch calcium and integrates its spines' voltages into a single branch signal sent on to the
soma. A fuel shortfall that cuts propagation short while the branch was strongly active is
endurance evidence; propagation that simply attenuates with distance is a structural limit, not
endurance.

**During DAY, during NOT_bAP — the branch consolidates, supplies, and recovers.** It maintains
its tag toward consolidation, lowers its commit threshold under acetylcholine (attention),
ships budget down to its spines (demand-weighted by their tags), runs local translation if
tagged, refills its own budget from astrocytic lactate and somatic shipment, and lets its
traces decay.

**During NIGHT — the branch's ceilings are rewritten.** NIGHT raises **structure** (bAP
fidelity, translation capacity) where a validated tag accumulated and **budget capacity** where
fuel interrupted strong branch activity, both from the shared pool, both competing; unmaintained
ceilings drift down.

```
// PARAMETERS  prop_cost · branch_Ca_cost · integrate_cost · translate_cost · ACh_gain
// INTERFACE
//   EMIT      bAP_local → POST ; branch_Vm → SOMA ; dend_ship_post → POST
//   RECEIVE   (signals) SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
//   READ      SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
//   OWN       dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling
//   SUPPLY    astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT)
//   NOTE      DEND endurance fires only on FUEL-limited propagation, not structural attenuation;
//             own-state proxy (strong branch activity); no arrived feedback term.

DAY | bAP:
    // ADJUST    (propagation strength from structure — inside propagate())
    // BEHAVE    (propagate bAP; distinguish fuel-limited vs structure-limited shortfall)
    if dend_budget < prop_cost:
        // FUEL shortfall → endurance (branch was strongly active)
        if dend_fast_trace > traj_thr:
            dend_endurance_need += dend_fast_trace
        bAP_local, reached = propagate_partial(dend_budget)
    else:
        bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, geometry)
        // reached < full here is structural attenuation (distance), NOT endurance
    dend_budget -= prop_cost × reached
    // TRACE
    dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover();  dend_budget -= branch_Ca_cost
    // EMIT      (integrated voltage to soma ; propagated bAP already reached spines)
    branch_Vm = integrate(POST.Vm, spines);  dend_budget -= integrate_cost

DAY | NOT_bAP:
    // TRACE     (strength)
    if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace
    if dopamine > dop_thr and dend_possible_tag > tag_thr:
        dend_tag += dopamine × dend_possible_tag
    // ADJUST    (commit threshold lowered by attention)
    commit_threshold *= 1/(1 + ACh·ACh_gain)
    // BEHAVE    (local translation if tagged — fills dend capacity faster)
    if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost
    // EMIT      (ship budget to spines; demand = post tag)
    dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost)
    // RECOVER   (refill budget from contested supply)
    dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend))
    // DECAY
    //   FAST   (ms–s)
    dend_fast_trace *= decay(300ms)
    //   MEDIUM (s–min)
    dend_possible_tag *= decay(s);  dend_endurance_need *= decay(min)
    //   SLOW   (hr)
    dend_tag *= decay(hr)
    //   (PERSISTENT: dend_structure, dend_budget_ceiling — no DAY decay; NIGHT only)

NIGHT | cycle:                                             // intermediate node (relays down to POST)
    // RECEIVE   batch arrived from SOMA this cycle
    dend_material += transit(soma_material_to_dend, τ_transport_dend)
    dend_energy   += transit(soma_energy_to_dend,   τ_transport_dend)
    // TRACE     read standing demand (dend_tag → structure ; dend_endurance_need → budget_ceiling)
    // ADJUST    (no coherence — DEND is not a synaptic component)
    // BEHAVE    commit batches; spend tag/need as fuel
    if dend_tag > tag_expiry:
        Δ = min(slot_batch, dend_material, dend_energy·f_cap)
        dend_structure += Δ;  dend_material -= Δ;  dend_energy -= Δ·assembly_cost;  dend_tag -= Δ
    if dend_endurance_need > endur_thr:
        Δ' = min(cap_batch, dend_material·f_cap, dend_energy·f_cap)
        dend_budget_ceiling += Δ';  dend_material -= Δ';  dend_energy -= Δ'·biogenesis_cost
        dend_endurance_need -= Δ'
    // EMIT      ship remaining batch one hop down to POST (demand = post tag)
    post_material_ship += ship(dend_material, post_demand, f_spine, ship_cost)
    post_energy_ship   += ship(dend_energy,   post_demand, f_spine, ship_cost)
    // RECOVER   reclaim material from decayed ceilings
    dend_material += dend_ceiling_shrinkage·recycle        // energy NOT recovered
    // DECAY
    dend_structure -= decay_rate·Δt_cycle;  dend_budget_ceiling -= capacity_decay_rate·Δt_cycle
    dend_structure += min(dend_maint, maint_cost);  dend_budget_ceiling += min(dend_cap_maint, cap_cost)
    dend_tag *= decay(slow);  dend_endurance_need *= decay(slow)
```

---

## SOMA

The soma is the neuron's integrating center and the root of its structural material. It sums
the branch inputs, fires when they exceed a threshold it sets from its own adaptation and the
neuromodulators, and ships material and budget out to the dendrites and axon. Its timing —
refractoriness, adaptation, rhythm alignment — emerges bottom-up from local traces, never from
a represented clock. Its behavior unfolds across two DAY contexts and the NIGHT scope.

**During DAY, during AP — the soma integrates and fires.** It computes its firing threshold
from its baseline (structure), its accumulated adaptation, and the neuromodulators, and checks
its refractory state; if the integrated branch input clears the threshold and fuel allows, it
fires. One spike deposits three traces at three timescales — sodium inactivation (refractory),
slow-potassium adaptation (threshold rise), and nuclear calcium (toward CREB and the tag). A
fuel shortfall while nuclear calcium was climbing is endurance evidence; being refractory or
sub-threshold is a timing limit, not endurance.

**During DAY, during NOT_AP — the soma recovers, aligns, and supplies.** It self-replenishes
from its own mitochondria (its private root), integrates the latest branch inputs, deposits a
refractory-alignment trace when suprathreshold input arrived during its refractory period (so it
aligns to its input rhythm bottom-up), ships budget to dendrites and axon (demand-weighted by
their tags), recovers from refractoriness at a rate its alignment trace speeds up, and lets its
traces decay.

**During NIGHT — the soma's ceilings are rewritten, and it gates the whole neuron's material.**
NIGHT raises **structure** (excitability, synthesis capacity) and **budget capacity** from the
shared pool; crucially the soma's own tag gates CREB-driven synthesis, so how much material all
downstream components receive depends on the soma having been tagged.

```
// PARAMETERS  ap_cost · nuclear_cost · creb_cost · mito_output · inactivation · ap_amp · ap_contrib
//             base_recovery · τ_Na · τ_adapt · τ_nuclear · τ_align
// INTERFACE
//   EMIT      fired → AXON (propagate) + DEND (bAP) ; soma_ship_dend → DEND ; soma_ship_axon → AXON
//   RECEIVE   (signals) branch_Vm ← DEND ; dopamine ; NE ; ACh
//   READ      dopamine ; NE ; ACh
//   OWN       soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling
//   SUPPLY    self (mitochondria, ROOT — private)
//   NOTE      SOMA endurance fires only on FUEL shortfall (budget < ap_cost);
//             refractory / sub-threshold are timing limits, not endurance. Own-state proxy.

DAY | AP:
    // ADJUST    (threshold from structure + adaptation + neuromodulators ; refractory gate)
    threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh)
    can_fire  = soma_Na_inactivation < inactivation
    // BEHAVE    (fire if able)
    if branch_Vm > threshold and can_fire:
        if soma_budget < ap_cost:
            // FUEL shortfall → endurance (firing was approaching CREB)
            if soma_fast_trace > traj_thr and soma_fast_trace_rising:
                soma_endurance_need += soma_fast_trace
            exit
        // EMIT      (fired → AXON, DEND)
        fired = True;  soma_budget -= ap_cost
        // TRACE     (three traces from one AP — FAST nuclear-Ca, MEDIUM adaptation, refractory)
        soma_Na_inactivation += ap_amp                     // → refractory (emergent)
        soma_adaptation      += ap_contrib                 // → threshold rise
        soma_fast_trace      += nuclear_Ca();  soma_budget -= nuclear_cost
        // TRACE     (strength)
        if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace
        if dopamine > dop_thr and soma_possible_tag > tag_thr:
            soma_tag += dopamine × soma_possible_tag
        soma_budget -= creb_cost
        // EMIT      (soma emits its own activity; the NEURON sums it — soma does NOT aggregate the cell)
        soma_emitted_activity += 1;  soma_emitted_structure = soma_structure

DAY | NOT_AP:
    // RECEIVE   (integrate latest branch input — signal)
    branch_Vm = integrate(DEND.branch_Vm, branches)
    // TRACE     (bottom-up refractory alignment: suprathreshold input during refractory)
    if branch_Vm > threshold and soma_Na_inactivation > inactivation:
        soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation
    // EMIT      (ship downstream into transit; demand = propagated tags)
    soma_ship_dend = ship(soma_budget, dend_demand, dend_ship_frac, ship_cost)
    soma_ship_axon = ship(soma_budget, axon_demand, axon_ship_frac, ship_cost)
    // RECOVER   (self-replenish from private root ; inactivation recovery sped by alignment)
    soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
    recovery = base_recovery × (1 + soma_refractory_alignment)
    soma_Na_inactivation *= decay(τ_Na / recovery)
    // DECAY
    //   FAST   (ms–s) — refractory + nuclear-Ca + alignment (sub-second to seconds)
    soma_fast_trace *= decay(τ_nuclear);  soma_refractory_alignment *= decay(τ_align)  // self-limiting
    //   MEDIUM (s–min) — adaptation + tagging evidence
    soma_adaptation *= decay(τ_adapt)
    soma_possible_tag *= decay(s);  soma_endurance_need *= decay(min)
    //   SLOW   (hr)
    soma_tag *= decay(hr)
    //   (signals)
    dopamine *= decay(ms)
    //   (PERSISTENT: soma_structure, soma_budget_ceiling — no DAY decay; NIGHT only)

NIGHT | cycle:                                             // ROOT (neuronal material) — produces each cycle
    // RECEIVE   = PRODUCTION: synthesize this cycle's batch, gated by own tag, capped externally
    soma_material += CREB_synth(soma_tag)·Δt_cycle         // material — recoverable
    soma_energy   += mito_synth()·Δt_cycle                 // energy — NOT recoverable, bounded by night budget
    night_energy_spent += mito_synth()·Δt_cycle            // track against night supply ceiling
    // TRACE     read standing demand (soma_tag → structure ; soma_endurance_need → budget_ceiling)
    // ADJUST    (no coherence — SOMA is not a synaptic component)
    // BEHAVE    commit own batches
    if soma_tag > tag_expiry:
        Δ = min(slot_batch, soma_material, soma_energy·f_cap)
        soma_structure += Δ;  soma_material -= Δ;  soma_energy -= Δ·assembly_cost;  soma_tag -= Δ
    if soma_endurance_need > endur_thr:
        Δ' = min(cap_batch, soma_material·f_cap, soma_energy·f_cap)
        soma_budget_ceiling += Δ';  soma_material -= Δ';  soma_energy -= Δ'·biogenesis_cost
        soma_endurance_need -= Δ'
    // EMIT      ship batches one hop down to DEND and AXON (demand = propagated tags)
    soma_material_to_dend += ship(soma_material, dend_demand, f_dend, ship_cost)
    soma_material_to_axon += ship(soma_material, axon_demand, f_axon, ship_cost)
    soma_energy_to_dend   += ship(soma_energy,   dend_demand, f_dend, ship_cost)
    soma_energy_to_axon   += ship(soma_energy,   axon_demand, f_axon, ship_cost)
    // RECOVER   reclaim material from decayed ceilings (own + returned from downstream)
    soma_material += soma_ceiling_shrinkage·recycle
    // DECAY
    soma_structure -= decay_rate·Δt_cycle;  soma_budget_ceiling -= capacity_decay_rate·Δt_cycle
    soma_structure += min(soma_maint, maint_cost);  soma_budget_ceiling += min(soma_cap_maint, cap_cost)
    soma_tag *= decay(slow);  soma_endurance_need *= decay(slow)
```

---

## AXON

The axon carries the soma's spike out to its boutons and is the presynapse's supply line. It
propagates reliably or not depending on its myelination and its recent load, and ships material
and budget to the boutons. Its behavior unfolds across two DAY contexts and the NIGHT scope.

**During DAY, during AP — the axon propagates the spike.** Reliability is set by structure
(myelination) and degraded by recent high-frequency load (sodium inactivation at branch points —
axonal short-term depression). A fuel shortfall while carrying a strong train is endurance
evidence; load-driven failure is short-term depression, a consequence, not endurance.

**During DAY, during NOT_AP — the axon supplies and recovers.** It maintains its tag, ships
budget to its boutons (demand-weighted by their tags), refills its own budget from somatic
shipment and astrocytic lactate, and lets its traces decay.

**During NIGHT — the axon's ceilings are rewritten.** NIGHT raises **structure** (myelination,
transport capacity) and **budget capacity** from the shared pool, both competing; unmaintained
ceilings drift down.

```
// PARAMETERS  prop_cost · budget_factor
// INTERFACE
//   EMIT      APs_delivered → PRE (propagation) ; axon_ship_pre → PRE
//   RECEIVE   (signals) SOMA.fired ; dopamine
//   READ      SOMA.fired ; dopamine
//   OWN       axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling
//   SUPPLY    soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT)
//   NOTE      AXON endurance fires only on FUEL shortfall; load-driven failure fail(fast_trace)
//             is axonal STD (a consequence), not endurance. Own-state proxy.

DAY | AP:
    // ADJUST    (reliability from structure − load-driven failure)
    reliability = axon_structure.propagation × (1 - fail(axon_fast_trace))   // fail() = STD, not endurance
    // BEHAVE    (propagate; FUEL shortfall degrades + flags endurance)
    if axon_budget < prop_cost:
        reliability *= budget_factor
        if axon_fast_trace > traj_thr:                     // FUEL-limited → endurance
            axon_endurance_need += axon_fast_trace
    delivered = fired × reliability;  axon_budget -= prop_cost × delivered
    // EMIT      (delivered APs reach boutons)
    // TRACE
    axon_fast_trace += delivered;  axon_fast_trace *= decay(s)

DAY | NOT_AP:
    // TRACE     (strength)
    if axon_fast_trace > elig: axon_possible_tag += axon_fast_trace
    if dopamine > dop_thr and axon_possible_tag > tag_thr:
        axon_tag += dopamine × axon_possible_tag
    // EMIT      (ship to boutons; demand = pre tag)
    axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost)
    // RECOVER   (refill budget from contested supply)
    axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
    // DECAY
    //   FAST   (ms–s)
    axon_fast_trace *= decay(s)
    //   MEDIUM (s–min)
    axon_possible_tag *= decay(s);  axon_endurance_need *= decay(min)
    //   SLOW   (hr)
    axon_tag *= decay(hr)
    //   (PERSISTENT: axon_structure, axon_budget_ceiling — no DAY decay; NIGHT only)

NIGHT | cycle:                                             // intermediate node (relays down to PRE)
    // RECEIVE   batch arrived from SOMA this cycle
    axon_material += transit(soma_material_to_axon, τ_transport_dend)
    axon_energy   += transit(soma_energy_to_axon,   τ_transport_dend)
    // TRACE     read standing demand (axon_tag → structure ; axon_endurance_need → budget_ceiling)
    // ADJUST    (no coherence — AXON is not a synaptic component)
    // BEHAVE    commit batches; spend tag/need as fuel
    if axon_tag > tag_expiry:
        Δ = min(slot_batch, axon_material, axon_energy·f_cap)
        axon_structure += Δ;  axon_material -= Δ;  axon_energy -= Δ·assembly_cost;  axon_tag -= Δ
    if axon_endurance_need > endur_thr:
        Δ' = min(cap_batch, axon_material·f_cap, axon_energy·f_cap)
        axon_budget_ceiling += Δ';  axon_material -= Δ';  axon_energy -= Δ'·biogenesis_cost
        axon_endurance_need -= Δ'
    // EMIT      ship remaining batch one hop down to PRE (demand = pre tag)
    pre_material_ship += ship(axon_material, pre_demand, f_bouton, ship_cost)
    pre_energy_ship   += ship(axon_energy,   pre_demand, f_bouton, ship_cost)
    // RECOVER   reclaim material from decayed ceilings
    axon_material += axon_ceiling_shrinkage·recycle        // energy NOT recovered
    // DECAY
    axon_structure -= decay_rate·Δt_cycle;  axon_budget_ceiling -= capacity_decay_rate·Δt_cycle
    axon_structure += min(axon_maint, maint_cost);  axon_budget_ceiling += min(axon_cap_maint, cap_cost)
    axon_tag *= decay(slow);  axon_endurance_need *= decay(slow)
```

---

## ASTROSYNAPSE

> The astrosynapse is the perisynaptic astrocytic process — the LOCAL component at one synapse,
> the astroglial peer of pre/post and a constituent of the ASTROCYTE actor (which integrates
> across all of them, just as the NEURON integrates over the soma). The astrosynapse behaves
> locally here; the astrocyte integrates and broadcasts (see CELL ACTORS).

The astrosynapse is the synapse's gatekeeper and energy hub. It clears glutamate, supplies the
D-serine that gates postsynaptic NMDA, and distributes lactate across its territory by demand.
Unlike the others it runs in a single continuous context rather than spiking, and its structure
reshapes the synapse's operating point rather than just its range.

**During DAY, continuously — the astrosynapse clears, gates, and fuels.** It produces energy at
its cell body (glycolysis from glucose, the system's energy root), then allocates lactate across
its astrosynapses weighted by each one's clearance demand. At each astrosynapse it clears
spillover glutamate (EAAT) and supplies tonic D-serine; when spillover is high it adds a
demand-driven D-serine pulse, brakes nothing of the presynapse directly (the presynaptic brake
is PRE reading its own cleft), deposits its calcium trace, and accumulates a dopamine-gated tag.
A D-serine pulse cut short by low budget while demand was high is endurance evidence; one cut
short by precursor/material exhaustion is a material limit, not endurance. Excess overflow
triggers the protective shockwave lockdown.

**During NIGHT — the astrosynapse's ceilings are rewritten.** NIGHT raises **structure**
(perisynaptic wrap, EAAT density, tonic D-serine) where a validated tag accumulated and **budget
capacity** where budget-limited synthesis recurred; astro_structure is self-reinforcing in both
directions, so it amplifies whatever trajectory the synapse is already on.

```
// PARAMETERS  K_Dserine · Ds_max · Ds_frac · Ds_cost · EAAT_cost · lactate_cost · spillover · overload
// INTERFACE
//   EMIT      astro_lactate[i] → pre/post/dend budgets ; astro_Dserine[i] → POST (gate)
//   RECEIVE   (signals) glutamate ← PRE (clearance + spillover) ; dopamine
//   READ      glutamate ; dopamine
//   OWN       astro_structure{perisynaptic_distance⁻¹, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling
//   SUPPLY    glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT)
//   NOTE      ASTRO endurance fires on BUDGET-limited synthesis (got<want via low budget);
//             material/precursor-limited synthesis is a material limit, not endurance. Own-state proxy.
//   EMERGENCY emits shockwave_lockdown on overload

DAY | CONTINUOUS:                                          // per astrosynapse i
    // RECEIVE   (root production, capped by glucose)
    astro_central_budget += glycolysis(glucose)·Δt
    // ADJUST    (demand weights across territory)
    for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff
    for each i: astro_territory_demand[i] += demand[i]·Δt   // TRACE: territory-level aggregator (by DAY)
    factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε))
    // EMIT      (demand-weighted lactate to all components)
    for each i:
        astro_lactate[i] = demand[i] × factor;  astro_central_budget -= astro_lactate[i]·lactate_cost
    // BEHAVE    (clear glutamate ; supply tonic D-serine)
    glutamate[i] -= astro_structure[i].EAAT × glutamate[i]·Δt;  astro_central_budget -= clearance·EAAT_cost
    astro_Dserine[i] += astro_structure[i].Dserine_tonic·Δt
    if glutamate[i] > spillover:
        // TRACE
        astro_fast_trace[i] += mGluR_Ca();  astro_fast_trace[i] *= decay(s)
        // ADJUST    (D-serine demand from spillover)
        want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
        got  = min(want, astro_central_budget × Ds_frac)
        // BEHAVE + EMIT  (D-serine pulse to POST gate)
        astro_Dserine[i] += got;  astro_central_budget -= got·Ds_cost
        // TRACE     (endurance: BUDGET-limited synthesis under high own demand)
        if got < want and astro_central_budget low and astro_fast_trace[i] > traj_thr:
            astro_endurance_need[i] += (want - got)
        // TRACE     (strength)
        if astro_fast_trace[i] > elig: astro_possible_tag[i] += astro_fast_trace[i]
        if dopamine > dop_thr and astro_possible_tag[i] > tag_thr:
            astro_tag[i] += dopamine × astro_possible_tag[i]
    // DECAY
    //   FAST   (ms–s) — astro_fast_trace already decayed above (intra-step)
    //   MEDIUM (s–min)
    astro_possible_tag[i] *= decay(s);  astro_endurance_need[i] *= decay(min)
    //   SLOW   (hr)
    astro_tag[i] *= decay(hr)
    //   (PERSISTENT: astro_structure, astro_budget_ceiling — no DAY decay; NIGHT only)
    // EMERGENCY
    if astro_fast_trace[i] > overload: emit(shockwave_lockdown)

NIGHT | cycle:                                             // ROOT (synaptic energy + ECM) — produces each cycle
    // RECEIVE   = PRODUCTION: glycolysis + ECM synthesis this cycle, capped by glucose
    astro_central_energy   += overnight_glycolysis(glucose)·Δt_cycle    // energy — NOT recoverable
    astro_central_material += astro_cellbody_synth()·Δt_cycle           // material — recoverable
    night_energy_spent     += overnight_glycolysis(glucose)·Δt_cycle
    // ADJUST    tag-weighted shares across the territory
    W = Σ astro_tag[i] over astro_tag[i] > tag_expiry
    // EMIT      distribute this cycle's batch to astrosynapses (demand = own tag)
    for each i with astro_tag[i] > tag_expiry:
        w = astro_tag[i]/W
        astro_energy[i]   += astro_central_energy·w
        astro_material[i] += astro_central_material·w
    // BEHAVE    each astrosynapse commits; spend tag/need as fuel (coherence applies — synaptic)
    for each astrosynapse i:
        coh = coherence_signal[i]
        if astro_tag[i] > tag_expiry:
            Δ = min(slot_batch, astro_material[i], astro_energy[i]·f_cap)
            astro_structure[i] += Δ × coh                  // self-reinforcing both directions
            astro_material[i] -= Δ;  astro_energy[i] -= Δ·assembly_cost;  astro_tag[i] -= Δ
        if astro_endurance_need[i] > endur_thr:
            Δ' = min(cap_batch, astro_material[i]·f_cap, astro_energy[i]·f_cap)
            astro_budget_ceiling[i] += Δ';  astro_material[i] -= Δ'
            astro_energy[i] -= Δ'·biogenesis_cost;  astro_endurance_need[i] -= Δ'
    // RECOVER   reclaim material from decayed ceilings
    astro_central_material += astro_ceiling_shrinkage·recycle           // energy NOT recovered
    // DECAY
    for each i:
        astro_structure[i] -= decay_rate·Δt_cycle;  astro_budget_ceiling[i] -= capacity_decay_rate·Δt_cycle
        astro_structure[i] += min(astro_maint[i], maint_cost)
        astro_budget_ceiling[i] += min(astro_cap_maint[i], cap_cost)
        astro_tag[i] *= decay(slow);  astro_endurance_need[i] *= decay(slow)
```

---

## Special — Shockwave Lockdown

```
DAY or NIGHT | OVERLOAD:
    Vm = HYPERPOLARIZED;  AMPA_surface = mass_internalize() → post reserve
    axon_fast_trace += overdrive();  astro_central_budget -= emergency_cost
```

---
---
> NIGHT-BLOCK UNIFORMITY. PRE's `NIGHT | cycle` above is the worked exemplar. POST, DEND, SOMA,
> AXON, and ASTROSYNAPSE follow the identical pattern, shown in their blocks in abbreviated form:
> (a) all commits are gated by `rest_permission` (arrived from the cell actor); (b) on a
> DOWNSCALE-phase signal each self-resets its own occupancy (`*_occupancy *= occupancy_downscale`)
> and self-renormalizes its own structure (`*_structure *= renorm_signal`, emitting the freed
> material) — the cell actor only broadcasts, the component scales itself; (c) each emits its own
> fatigue upward. Roots (SOMA material, ASTROSYNAPSE/ASTROCYTE energy) additionally PRODUCE their
> batch each cycle and track `night_energy_spent`. Only the occupancy-holders (PRE: VGCC_active,
> POST: AMPA_surface) carry the self-downscale line; the rest carry only the structure renorm.

---
---
# CELL ACTORS — NEURON and ASTROCYTE
Two structurally identical peers. Each integrates its constituents' EMITTED activity by its DAY
(never reading their interiors), detects when its aggregate has gone quiet, and BROADCASTS the
restructuring window + renormalization/reallocation by its NIGHT. Each component then restructures
ITSELF in response. The cell actor's own DAY/NIGHT follows the same transition rule, on its own
aggregate activity.

## NEURON

The neuron is the whole-cell actor over soma, pre, post, dend, axon. It cannot fire or release —
it integrates what its components emit and grants them the restructuring window none of them can
grant itself. The soma is one of its constituents, a peer of the bouton; the neuron is not the soma.

```
// PARAMETERS  neuron_weight_ceiling · downscale_factor · early_phase_frac · rest_thr
// INTERFACE
//   EMIT      rest_permission, renorm_signal, occupancy_downscale → own components (broadcast)
//             neuron_fatigue → HYPOTHALAMUS
//   RECEIVE   (signals) component activity emissions (summed) ; sleep_pressure ← HYPOTHALAMUS
//             replay_reweight ← assembly/network (external)
//   OWN       neuron_activity · neuron_total_weight  (aggregates aggregated from emissions)
//   NOTE      never reads a component interior; sums emitted activity, broadcasts signals only.

DAY | active:                                              // (own_activity high → integrate only)
    // TRACE     integrate the cell's emitted activity + committed weight (aggregators)
    neuron_activity     += Σ component emitted_activity·Δt
    neuron_total_weight  = Σ component emitted_structure        // from emissions, not interiors
    // EMIT      fatigue upward (metabolic debt of the whole cell)
    neuron_fatigue = f(neuron_activity, unspent demand)
    // (no restructuring permission while the cell is active — components are busy)

NIGHT | cycle:                                             // (own_activity low AND sleep_pressure high)
    phase = (cycle ≤ early_phase_frac × est_cycles) ? DOWNSCALE : COMMIT
    // ADJUST    read replay (external) + own aggregate
    // EMIT (broadcast)  — the neuron acts ONLY by signalling; components scale themselves
    if phase == DOWNSCALE:
        occupancy_downscale = downscale_factor                 // → components reset own occupancy
        if neuron_total_weight > neuron_weight_ceiling:
            renorm_signal = neuron_weight_ceiling / neuron_total_weight   // → components scale own structure
    rest_permission = TRUE                                      // → components may restructure this cycle
    // RECOVER   reclaim material returned by components' renormalization (arrives as recycled pool)
    // DECAY     neuron_activity relaxes as the cell stays quiet

CODA | on waking (sleep_pressure < wake_thr):
    neuron_activity = 0;  neuron_total_weight = recomputed from surviving emissions
```

## ASTROCYTE

The astrocyte is the territory actor over its astrosynapses — the exact parallel of the neuron.
It integrates its astrosynapses' emitted demand/load, and reallocates its produced energy and
material across the territory. The astrosynapse is one of its constituents; the astrocyte is not
the astrosynapse.

```
// PARAMETERS  (territory reallocation) · early_phase_frac · rest_thr
// INTERFACE
//   EMIT      astro_alloc[·] (reallocation), rest_permission → own astrosynapses (broadcast)
//             astro_fatigue → HYPOTHALAMUS ; produced energy+material → territory (roots)
//   RECEIVE   (signals) astrosynapse demand emissions (summed) ; sleep_pressure ; replay_reweight
//   OWN       astro_territory_demand[·]  (aggregated from emissions) ; astro_central_{energy,material}
//   NOTE      ROOT of synaptic energy + ECM material; integrate-and-broadcast like the neuron.

DAY | active:
    // TRACE     integrate territory-wide emitted demand (aggregator)
    for each astrosynapse i: astro_territory_demand[i] += emitted_demand[i]·Δt
    // BEHAVE    DAY metabolic support already runs per-astrosynapse (lactate allocation, see ASTROSYNAPSE)
    // EMIT      fatigue upward
    astro_fatigue = f(territory load, unmet demand)

NIGHT | cycle:                                             // (territory quiet AND sleep_pressure high)
    // RECEIVE = PRODUCTION (root): this cycle's energy + ECM batch, capped by glucose
    astro_central_energy   += overnight_glycolysis(glucose)·Δt_cycle     // NOT recoverable
    astro_central_material += astro_cellbody_synth()·Δt_cycle            // recoverable
    night_energy_spent     += overnight_glycolysis(glucose)·Δt_cycle
    // ADJUST    reallocation weights across the territory (demand × replay)
    for each i: astro_alloc[i] = (astro_territory_demand[i] × replay_reweight[i])
                                 / Σ(astro_territory_demand × replay_reweight)
    // EMIT (broadcast)  distribute this cycle's batch + grant restructuring window
    for each i:
        astro_energy[i]   += astro_central_energy·astro_alloc[i]
        astro_material[i] += astro_central_material·astro_alloc[i]
    rest_permission[i] = TRUE                                  // → each astrosynapse commits itself
    // RECOVER   reclaim material from decayed astrosynapse ceilings (returned to central pool)
    astro_central_material += astro_ceiling_shrinkage·recycle

CODA | on waking:
    astro_territory_demand[·] = 0
```

## HYPOTHALAMUS

The system actor. Unlike every other actor it has NO night: it runs CONTINUOUS, always
integrating fatigue from all components and emitting the single sleep-pressure signal that opens
everyone else's restructuring window. It is the clock that never sleeps — if it stopped, nothing
would track fatigue and the system could never transition.

```
// PARAMETERS  fatigue_gain · pressure_decay · discharge_gain
// INTERFACE
//   EMIT      sleep_pressure → ALL actors (broadcast; the day/night signal)
//   RECEIVE   (signals) fatigue from all components + cell actors (summed)
//             discharge signal (restructuring done → fatigue falling)
//   OWN       sleep_pressure
//   NOTE      single fatigue channel up, single sleep_pressure channel down. No DAY/NIGHT of its own.

CONTINUOUS:                                                // spans every other actor's day and night
    // RECEIVE   integrate all incoming fatigue (rising with activity, falling with consolidation)
    total_fatigue = Σ component_fatigue + neuron_fatigue + astro_fatigue
    // TRACE     accumulate sleep pressure from fatigue; discharge as restructuring proceeds
    sleep_pressure += fatigue_gain × total_fatigue·Δt
    sleep_pressure -= discharge_gain × consolidation_progress·Δt
    sleep_pressure *= decay(pressure_decay)
    // EMIT      broadcast the current level — each actor reads it and sets its own DAY/NIGHT
    broadcast(sleep_pressure)
    // (rising pressure tips quiet components into NIGHT; falling pressure wakes them — emergently)
```

How it runs without a driver. There is no loop that orchestrates the actors. The hypothalamus
continuously emits sleep-pressure; each component and cell actor continuously reads it and its own
activity and sets its own DAY/NIGHT per the transition rule. As components quiet and cross into
NIGHT they restructure, which discharges fatigue, which lowers pressure, which eventually wakes
them. The "loop of NIGHT cycles" is simply what happens while a component remains in its NIGHT
state — it runs its `NIGHT | cycle` block repeatedly until its transition rule flips it back to
DAY. Termination (waking) is emergent from the fatigue loop, not a `break`: a rested system
discharges its fatigue and wakes; an overloaded one wakes with tags unspent (they carry forward).

---

## One-view summary

```
SEVEN-GROUP GRAMMAR · EIGHT ACTORS · ONE FATIGUE LOOP
  RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY

ACTORS local: soma·pre·post·dend·axon·astrosynapse   cell: neuron·astrocyte   system: hypothalamus
       same template; higher actors INTEGRATE constituents' emissions and BROADCAST — never reach in

DAY    (per-component state: own_activity high) behave locally, evidence ascends leaves→roots
       fast_trace + dopamine → tag (strength) ; FUEL shortfall + interrupted success → endurance_need
       emit fatigue upward as metabolic debt accumulates
NIGHT  (per-component state: own_activity low AND sleep_pressure high) restructure, capacity descends
       phased: early DOWNSCALE (self-reset occupancy + self-renorm structure on broadcast signals),
       late COMMIT (tag→structure, need→budget_ceiling, spend tag-as-fuel) — only with rest_permission
       what persists must EARN it: occupancy resets, only CEILINGS carry; unspent tags carry forward
LOOP   no driver/scheduler. HYPOTHALAMUS runs CONTINUOUS: integrates fatigue → emits sleep_pressure.
       activity→fatigue→pressure→quiet grants restructuring→discharge→pressure falls→wake. DAY/NIGHT
       are the two phases of one homeostatic loop the system runs on itself, per component (local sleep).
RULE   no actor authorizes its own restructuring — each is PUT IN POSITION by the actor above
       (which holds an aggregate it can't see, opens a window it can't open). Acts locally,
       consolidates hierarchically. Material recycles; ENERGY does not (the arrow of time).
```
FLOWS  every flow has a timescale; shipment is transit-delayed (distal fills over cycles)
LOCAL  every group uses only own state + arrived signals; RECEIVE/EMIT are the only crossings
```