organism/elements/neuron/appunti/2026-06-22-tripartite-synapse_v12.md

# Tripartite Synapse — Pseudocode v13

> Companion: `tripartite_synapse_v13_biology.md`.
> Changes from v12:
>  (1) per-spike calcium deposit (frequency stays emergent, not a parameter)
>  (2) BEHAVE splits FUEL shortfall (→ endurance) from OCCUPANCY shortfall (→ STD)
>  (3) endurance feedback term only where a retrograde signal actually arrives
>  (4) TRACE absorbs EVALUATE → seven-group grammar
>  (5) parameter declarations completed (ship_cost, ACh_gain, NIGHT block)
>  (6) shipment is a transit-delayed flow; every flow has a timescale
>  (7) all group labels are standalone headers at one column

---

## 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`).

---

## Conventions

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

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)
glucose  geometry                         // physical (external)
elig  dop_thr  tag_thr  tag_expiry        // strength gates (universal)
traj_thr  endur_thr                       // endurance gates (universal)
ship_cost                                 // transport overhead (all shipments)
τ_transport_{dend,axon,spine,bouton}      // shipment transit times (distance-dependent)
ε
```

## NIGHT parameters (consolidation only)

```
slot_cost  cap_cost  f_cap                // commit sizes / endurance fraction
maint_frac  cap_frac                      // maintenance allocation
decay_rate  capacity_decay_rate  recycle  // passive decay + recovery
homeostatic_ceiling  coherence_factor  assembly_cost  biogenesis_cost  maint_cost
f_dend  f_axon  f_spine  f_bouton         // material distribution fractions
{dend,axon,pre,post}_ship_frac            // DAY shipment fractions
{dend,axon,pre,post}_energy_frac          // energy distribution fractions
```

---
---
# DAY
---

## PRE

```
// PARAMETERS  K_release · release_cost · fusion_cost · vatpase_cost · spillover · brake
// INTERFACE
//   EMIT      glutamate → POST, ASTRO
//   RECEIVE   astro_lactate[syn] ← ASTRO ; axon_ship_pre ← AXON ; retro_NO, retro_eCB ← POST
//             pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT)
//   READ      glutamate (own cleft, autobrake) ; dopamine (gates tag)
//   OWN       pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling
//   EMERGENCY shockwave_lockdown ← ASTRO

DAY | AP:
    // TRACE     (Ca²⁺ bolus from THIS spike — also drives release; frequency is emergent)
    pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)
    // ADJUST    (release drive from residual Ca²⁺ + received DSE brake)
    drive = sat(pre_fast_trace, K_release) × (1 - retro_eCB_local)
    // BEHAVE    (release; two distinct failure modes)
    if pre_budget < release_cost:
        // FUEL shortfall → endurance evidence (retro_NO-confirmed local success)
        suppress(NT_flux)
        if pre_fast_trace > traj_thr:
            pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)
        exit
    if RRP == 0:
        // OCCUPANCY shortfall → short-term depression (NOT endurance; fuel was fine)
        suppress(NT_flux)
        exit
    NT_flux = RRP × drive;  RRP -= NT_flux·Δt;  pre_budget -= NT_flux·fusion_cost
    // EMIT      (glutamate into cleft)
    glutamate += NT_flux·Δt
    if glutamate > spillover: drive *= brake               // own-cleft autobrake

DAY | NOT_AP:
    // RECEIVE   (latch backward messages ; replenish budget from contested supply)
    retro_NO_local = retro_NO;  retro_eCB_local = retro_eCB
    pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton))
    // TRACE     (strength: eligibility → tag via dopamine)
    if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace
    if dopamine > dop_thr and pre_possible_tag > tag_thr:
        pre_tag += dopamine × pre_possible_tag
    // RECOVER   (RRP from private reserve toward its ceiling)
    RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
    // DECAY
    pre_fast_trace *= decay(100ms);  pre_possible_tag *= decay(s)
    pre_endurance_need *= decay(min);  pre_tag *= decay(hr)
    dopamine *= decay(ms);  retro_NO *= decay(s);  retro_eCB *= decay(s)
```

---

## POST

```
// 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   astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND ; post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
//   READ      glutamate ← PRE ; astro_Dserine ← ASTRO ; bAP (dend_structure.bAP_fidelity) ; dopamine
//   OWN       post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling
//   EMERGENCY shockwave_lockdown ← ASTRO
// NOTE      POST endurance is own-state only (own Ca climbing); no arrived feedback term.

DAY | NOT_bAP:
    // RECEIVE
    post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine))
    // 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
    // DECAY
    post_possible_tag *= decay(min);  post_endurance_need *= decay(min)
    post_tag *= decay(hr);  dopamine *= decay(ms)

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()
```

---

## DEND

```
// 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   astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT)
//   READ      SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
//   OWN       dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling
//   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:
    // RECEIVE
    dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend))
    // 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)
    // EMIT      (ship budget to spines; demand = post tag)
    dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost)
    // BEHAVE    (local translation if tagged — fills dend capacity faster)
    if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost
    // DECAY
    dend_fast_trace *= decay(300ms);  dend_possible_tag *= decay(s)
    dend_endurance_need *= decay(min);  dend_tag *= decay(hr)
```

---

## SOMA

```
// 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   self (mitochondria, ROOT) ; branch_Vm ← DEND
//   READ      dopamine ; NE ; ACh
//   OWN       soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling
//   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 — all timescales)
        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

DAY | NOT_AP:
    // RECEIVE   (self-replenish from private root ; integrate input)
    soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
    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   (inactivation recovery sped by alignment trace → emergent refractory)
    recovery = base_recovery × (1 + soma_refractory_alignment)
    soma_Na_inactivation *= decay(τ_Na / recovery)
    // DECAY
    soma_adaptation *= decay(τ_adapt);  soma_fast_trace *= decay(τ_nuclear)
    soma_refractory_alignment *= decay(τ_align)            // self-limiting
    soma_possible_tag *= decay(s);  soma_endurance_need *= decay(min)
    soma_tag *= decay(hr);  dopamine *= decay(ms)
```

---

## AXON

```
// PARAMETERS  prop_cost · budget_factor
// INTERFACE
//   EMIT      APs_delivered → PRE (propagation) ; axon_ship_pre → PRE
//   RECEIVE   soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT)
//   READ      SOMA.fired ; dopamine
//   OWN       axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling
//   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:
    // RECEIVE
    axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
    // 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)
    // DECAY
    axon_fast_trace *= decay(s);  axon_possible_tag *= decay(s)
    axon_endurance_need *= decay(min);  axon_tag *= decay(hr)
```

---

## ASTRO

```
// 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   glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT)
//   READ      glutamate ← PRE (clearance + spillover) ; dopamine
//   OWN       astro_structure{perisynaptic_distance⁻¹, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling
//   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
    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
    astro_possible_tag[i] *= decay(s);  astro_endurance_need[i] *= decay(min);  astro_tag[i] *= decay(hr)
    // EMERGENCY
    if astro_fast_trace[i] > overload: emit(shockwave_lockdown)
```

---

## 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
Same grammar on ceilings, once per cycle.

```
NIGHT | 1  RECEIVE + ADJUST + EMIT  (replenish, weight, distribute)
    // RECEIVE  overnight production at roots (capped by glucose; gated by soma_tag)
    astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt
    soma_{budget,energy} += overnight_*()·Δt ; soma_material += CREB_synth(soma_tag)·Δt
    // ADJUST   tag-weighted shares
    for each i with astro_tag[i] > tag_expiry:  w = astro_tag[i]/Σastro_tag
    // EMIT     distribute material + energy down the supply chains
        astro_energy[i] += astro_central_energy·w;  astro_material[i] += astro_central_material·w
    dend_material += soma_material·f_dend ; axon_material += soma_material·f_axon ; soma_material -= …
    post_material += dend_material·f_spine ; pre_material += axon_material·f_bouton
    {pre,post,dend,axon}_energy += soma_energy·{·}_energy_frac
    {pre,post,dend,axon}_budget += astro_lactate_reserve·{·}_frac·Δt

NIGHT | 2  TRACE + BEHAVE  (strength commits → raise structure)
    // ADJUST   coherence bonus when pre, post, astro tags align
    coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1
    // TRACE+BEHAVE  build structure for tagged components
    for each c with c_tag > tag_expiry:
        Δ = min(slot_cost, c_material, c_energy·f_cap)
        c_structure += Δ × (coherence if c in {pre,post,astro} else 1)
        c_material -= Δ;  c_energy -= Δ·assembly_cost;  if Δ < slot_cost: queue(→ next NIGHT)

NIGHT | 2b TRACE + BEHAVE  (endurance commits → raise budget_ceiling ; no dopamine ; competes w/ 2)
    for each c with c_endurance_need > endur_thr:
        Δ = min(cap_cost, c_material·f_cap, c_energy·f_cap)
        c_budget_ceiling += Δ;  c_material -= Δ;  c_energy -= Δ·biogenesis_cost;  if Δ<cap_cost: queue

NIGHT | 3  DECAY + RECOVER  (both ceilings decay by neglect ; material recovered)
    maint = (total_material - consumed) × maint_frac / synapse_count
    for each synapse:                                                                   // DECAY
        {pre,post,dend,astro}_structure      -= decay_rate·Δt
        {pre,post,dend,astro}_budget_ceiling -= capacity_decay_rate·Δt
        if maint ≥ maint_cost: structure += full_maint ; budget_ceiling += full_cap_maint
        else:                  structure += maint·frac ; budget_ceiling += maint·cap_frac
    for each synapse with net_change < 0:                                               // RECOVER
        {pre,post,astro}_material += |net_change|·recycle·frac          // material recovered, energy not

NIGHT | 4  BEHAVE  (homeostatic scaling)
    if soma_tag > homeostatic_ceiling:
        s = homeostatic_ceiling / soma_tag
        for each synapse: post_structure.slot_ceiling *= s ; pre_structure.slot_ceiling *= s
        soma_material += Σ reduction·recycle

NIGHT | 5  DECAY  (clear traces)
    all fast_trace, possible_tag, endurance_need = 0
    soma_Na_inactivation = soma_adaptation = soma_refractory_alignment = 0
    for each tag: if tag < tag_expiry: tag = 0             // else carry forward
    // structure and budget_ceiling PERSIST
```

---

## One-view summary

```
SEVEN-GROUP GRAMMAR, TWO TIMESCALES
  RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY

DAY    grammar on OCCUPANCY within two ceilings (structure=strength, budget_ceiling=endurance)
       TRACE yields two evidence streams from local state + arrived signals:
         fast_trace + dopamine             → tag            (strength)
         FUEL shortfall + interrupted LOCAL success → endurance_need (endurance)
       OCCUPANCY/structure/timing shortfalls → short-term depression (NOT endurance)
NIGHT  same grammar on the CEILINGS:
         tag → structure ; endurance_need → budget_ceiling ; both draw one pool (compete)
       unmaintained ceilings decay → recovered material funds the rest
FLOWS  every flow has a timescale: decay relaxes toward 0 over τ, arrival toward a target
       over τ; shipment is transit-delayed; rate-limited inflows carry τ implicitly.
LOCAL  every group uses only own state + arrived signals; RECEIVE/EMIT are the only crossings.
```