v12

2026-06-22 11:48:40 +02:00
parent 49b9fa2830
commit d0f2cbab20
4 changed files with 1741 additions and 0 deletions
@@ -0,0 +1,339 @@
 # Tripartite Synapse — Biological Reference (companion to v12 pseudocode)
 > Companion to `tripartite_synapse_v12_pseudocode.md`. Explains the biology each variable and
 > behavior conflates. Variable meanings are unchanged; v12 only refined the pseudocode
 > grammar (SENSE→TRACE, new ADJUST group, EVALUATE reordered before ADJUST/DECAY, NIGHT
 > labeled with the same groups, aligned group headers). The ADJUST group makes explicit the
 > step where a component computes its operating parameters — release drive, firing threshold,
 > propagation reliability, lactate-allocation weights — from its structure, its current
 > traces, and arrived neuromodulators, before it acts.
 > conflates biologically. The pseudocode aggregates many molecular details into single
 > variables for clarity; here each aggregation is unpacked. Read the pseudocode for the
 > logic; read this when you need to know what a variable physically represents.
 ---
 ## The three synaptic components and their support structures
 A SYNAPSE is composed of three first-class components:
 - **PRE** — presynaptic bouton (the axon's terminal at this synapse)
 - **POST** — postsynaptic spine (the dendrite's terminal at this synapse)
 - **ASTRO** — astrosynapse, the perisynaptic astrocytic process (the astrocyte's terminal)
 Each has an upstream support structure that supplies it:
 - **AXON** supplies PRE (transmission + transport from soma)
 - **DEND** supplies POST (integration + transport from soma)
 - the **astrocyte cell body** supplies ASTRO (energy + ECM material)
 - **SOMA** is the integrating center and the root of neuronal material
 The compartment analogy: AXON:PRE = DEND:POST = astrocyte-body:ASTRO = supply line : terminal.
 ---
 ## Resource variables
 ### DAY budget (one per component)
 Aggregates fast energy AND fast consumables — everything needed to run moment-to-moment.
 - **pre_budget** — ATP for VGCC gating, vesicle fusion (SNARE), VATPase vesicle refill,
  plus fast consumables: vesicle membrane lipids, synaptotagmin recycling.
 - **post_budget** — ATP for the NaK pump (membrane reset after current), NMDA current
  handling, plus fast actin monomers for transient spine changes and receptor-recycling lipids.
 - **dend_budget** — ATP for bAP propagation (NaK reset along branch), local translation
  (ribosome running cost), SERCA Ca²⁺ resequestration, plus fast mRNA consumed by translation.
 - **soma_budget** — ATP for AP generation (Na⁺/K⁺ currents + NaK reset), CREB
  phosphorylation, nuclear Ca²⁺ handling, plus shipping running costs.
 - **axon_budget** — ATP for AP propagation at nodes of Ranvier, kinesin/dynein motor
  running cost, fast myelin maintenance.
 - **astro_central_budget** — ATP from glycolysis at the astrocyte cell body; funds EAAT
  clearance, serine→D-serine synthesis, lactate export, fast process motility.
 ### astro_lactate[i]
 Lactate exported from the astrocyte cell body to synapse i. Biologically: glucose →
 (glycolysis) → lactate, released into extracellular space, absorbed by neuronal MCT2
 transporters, converted to pyruvate → TCA → ATP in the neuron's mitochondria. The astrocyte
 is the primary fast-energy supplier to pre, post, and dend.
 ### NIGHT energy (one per component) — NOT recoverable
 ATP for structural assembly. Distinct from DAY budget because it is spent on building, and
 the work of assembly is thermodynamically gone once done (cannot be recovered by disassembly).
 - pre_energy: RIM/Munc13 incorporation, VGCC clustering.
 - post_energy: CaMKII anchoring, actin polymerization, PSD scaffold remodeling.
 - dend_energy: mitochondria incorporation, cytoskeletal reinforcement.
 - soma_energy: ribosome biogenesis, ion-channel incorporation.
 - axon_energy: myelination, microtubule stabilization.
 - astro_energy: process retraction, ECM secretion, racemase upregulation.
 ### NIGHT material (one per component) — RECOVERABLE
 Slow structural proteins. Recoverable because disassembly (LTD) returns the proteins to a
 reusable pool (ubiquitin-proteasome → amino acids; internalized receptors → endosomal reserve).
 - **soma_material** (root) — all neuronal structural proteins from CREB-driven synthesis:
  AMPA subunits, PSD scaffold, AZ scaffold, mRNA transcripts (Arc, BDNF), organelles.
 - **dend_material** — from soma: Arc/plasticity mRNA, mitochondria, cytoskeletal proteins,
  AMPA subunits in transit to spines.
 - **post_material** — from dend: AMPA receptor subunits (GluA1/2), PSD scaffold (PSD-95,
  SHANK, Homer), structural actin, CaMKII.
 - **axon_material** — from soma: kinesin/dynein motors, microtubule components, myelin proteins.
 - **pre_material** — from axon: RIM, Munc13, VGCC subunits, structural vesicle proteins.
 - **astro_material** (root: astrocyte cell body) — EAAT proteins, serine racemase, ECM
  proteins (Glypicans, Thrombospondins), process cytoskeleton.
 **Why energy and material are separate in NIGHT but combined in DAY:** during DAY both are
 fast consumables replenished on the same timescale, so one `budget` variable suffices. During
 NIGHT they diverge — material is recoverable after LTD, energy is not — so they must be two
 variables. This asymmetry (material returns to the pool, energy is gone) is what makes one
 synapse's depression genuinely fund another's potentiation.
 ---
 ## Structural variables (strength ceilings — written in NIGHT)
 Each aggregates several correlated structural properties into one capacity.
 - **pre_structure** — active zone capacity:
  slot_ceiling (number of vesicle docking slots) + VGCC_coupling (Ca²⁺-channel proximity to
  slots, sets release efficiency) + refill_ceiling (max RRP replenishment rate).
 - **post_structure** — spine sensitivity capacity:
  slot_ceiling (number of PSD anchoring slots for AMPA) + spine_volume (local reserve and
  actin machinery) + reserve_ceiling (endosomal AMPA pool size).
 - **dend_structure** — branch capacity:
  bAP_fidelity(position) (mitochondrial density sets propagation strength, attenuates with
  distance) + translation_ceiling (local mRNA capacity) + transport_speed (cytoskeletal integrity).
 - **soma_structure** — somatic output capacity:
  baseline_threshold (inverse: ion-channel density at axon initial segment) + AP_reliability
  (Na⁺ channel density) + synthesis_ceiling (ribosome density + CREB machinery).
 - **axon_structure** — axonal capacity:
  propagation reliability (myelination density) + transport_ceiling (motor density + microtubule
  integrity) + mitochondrial density.
 - **astro_structure** — astrosynaptic environmental capacity:
  perisynaptic_distance⁻¹ (wall proximity — closer = more glutamate contained) + EAAT_density
  (clearance ceiling) + Dserine_tonic (baseline co-agonist) + ECM_integrity.
  **Self-reinforcing both directions:** tighter wrap + more tonic D-serine make future
  potentiation easier; looser wrap + zero tonic D-serine make future depression easier.
 ---
 ## Budget ceilings (endurance ceilings — written in NIGHT)
 - **{component}_budget_ceiling** — the maximum fuel the component can hold / the maximum
  duration of sustained behavior. Biologically: mitochondrial density and local fuel-storage
  capacity. Built by activity-driven mitochondrial biogenesis; lost by mitophagy when idle.
  Parallel to structure: structure is strength capacity, budget_ceiling is endurance capacity.
 ---
 ## Trace variables
 ### fast_trace (one per component) — DAY only, decays automatically
 The local record of recent activity that biases the next behavior.
 - **pre_fast_trace** — residual presynaptic Ca²⁺ after spikes (τ≈100ms). Biases NT release
  (facilitation) and provides tagging eligibility.
 - **post_fast_trace** — spine Ca²⁺ amplitude × rise-speed (τ≈tens ms). Encodes the LTP-vs-LTD
  instruction (fast rise → CaMKII → potentiation; slow rise → phosphatase → depression).
 - **dend_fast_trace** — branch Ca²⁺ from bAP + spine spillover (τ≈300ms). Integrates branch co-activity.
 - **soma_fast_trace** — nuclear Ca²⁺ from each AP (τ≈seconds). Drives toward CREB activation.
 - **axon_fast_trace** — propagation load (τ≈seconds). High load → Na⁺ inactivation at branch
  points → propagation failure (this is axonal short-term depression).
 - **astro_fast_trace** — perisynaptic Ca²⁺ from mGluR5 activation by glutamate spillover
  (τ≈seconds). Drives D-serine release.
 ### soma timing traces (emergent refractory + adaptation + alignment)
 - **soma_Na_inactivation** (τ≈ms) — sodium-channel inactivation after an AP. Its recovery IS
  the refractory period (emergent, not a hardcoded timer). High → absolute refractory; decaying
  → relative refractory; recovered → normal.
 - **soma_adaptation** (τ≈100s of ms) — slow K⁺ channel (SK/M-type) activation accumulating
  over a spike train, raising threshold. This is spike-frequency adaptation.
 - **soma_refractory_alignment** — deposited when a suprathreshold input arrives during
  refractoriness (a missed coincidence). Speeds future recovery so the soma aligns to its input
  rhythm. Bottom-up: no rhythm is represented; alignment emerges from accumulated local
  mismatches and decays when mismatches stop (self-limiting).
 ### possible_tag (one per component) — intermediate, τ≈s–min
 Graded accumulation of tagging eligibility. For POST, this is the CANDIDATE tag lifetime.
 ### endurance_need (one per component) — intermediate, τ≈s–min
 Deposited when budget depletion interrupts a behavior that was on a LOCALLY successful
 trajectory. Records that fuel — not structure, not significance — was the binding constraint
 on a forming success. Requires NO dopamine (homeostatic, not associative).
 **Local success proxy per component** (each uses only its own state + arrived signals):
 - PRE: own fast_trace high (was releasing strongly), optionally amplified by retrograde
  messenger (endocannabinoid / NO / BDNF) that has arrived.
 - POST: own Ca²⁺ climbing toward tagging threshold (naturally local).
 - DEND: own branch strongly active (high branch voltage/Ca²⁺) when propagation fell short.
 - SOMA: own nuclear Ca²⁺ climbing toward CREB.
 - AXON: own propagation load high (was carrying a strong train).
 - ASTRO: own local glutamate/Ca²⁺ high (was under heavy clearance/D-serine demand).
 ### tag (one per component) — DAY→NIGHT bridge, τ≈hours
 The validated record of significance that survives to NIGHT and gates strength commits.
 Formed by coincidence of local eligibility + non-local validation (dopamine).
 **POST is special — two-phase, three coincidences:**
 - CANDIDATE: local Ca²⁺ above threshold + astrosynapse D-serine present (coincidence 1).
 - amplified when bAP confirms soma fired (coincidence 2).
 - STABLE: CANDIDATE + dopamine within stabilization window (coincidence 3).
 Biologically: early CaMKII creates a labile tag (early-LTP); PKA driven by dopamine via D1R
 stabilizes it (late-LTP). Without dopamine, the candidate degrades — early-LTP reverses.
 ---
 ## Behaviors — biological meaning
 ### PRE | AP — neurotransmitter release
 `NT_flux = RRP × sat(pre_fast_trace, K_release)` models continuous NT release proportional to
 the readily-releasable pool and a saturating Ca²⁺ drive (synaptotagmin's cooperative Ca²⁺
 sensitivity, simplified to a saturating curve). RRP depletes as released (short-term depression
 as a consequence) and refills via VATPase (energy-throttled, so low budget deepens depression).
 The mGluR2/3 brake is presynaptic autoinhibition by spillover (Gi → reduced VGCC opening).
 ### POST | NOT_bAP — three calcium sources, two plasticity cases
 - **Source 1 (AMPA):** glutamate opens AMPA → depolarizing current + small Ca²⁺; the
  depolarization begins ejecting the NMDA Mg²⁺ block.
 - **Source 2 (NMDA):** if depolarized enough (Mg²⁺ ejected) AND D-serine present (astrocyte
  co-agonist) AND glutamate bound → large Ca²⁺ influx. This is the coincidence detector.
 - **Source 3 (bAP, separate context):** back-propagating AP adds depolarization + Ca²⁺,
  amplifying an existing signal supralinearly.
 - **Case 1 (STP):** high Ca²⁺ drives AMPA receptors from the local reserve to the surface,
  bounded by the anchoring-slot ceiling. Fast, reversible, NO dopamine. When Ca²⁺ falls,
  receptors drift back — short-term depression as a passive consequence, never signaled.
 - **Case 2 (LTP tag):** high Ca²⁺ + (later) dopamine sets the tag that NIGHT uses to raise the
  slot ceiling. NIGHT builds slots; DAY fills them.
 ### DEND | bAP — bidirectional signaling
 Propagates the bAP from soma toward spines (fidelity attenuates with distance — distal spines
 get weaker confirmation, are harder to potentiate) and integrates spine signals toward the soma.
 ### SOMA | AP — integration, firing, emergent timing
 Fires when integrated branch input exceeds a threshold that is the baseline (from structure)
 raised by adaptation and modulated by neuromodulators, gated by the emergent refractory state.
 Each AP deposits three traces (inactivation → refractory, adaptation → threshold rise, nuclear
 Ca²⁺ → plasticity). The soma is the coincidence detector at the cellular scale (nuclear Ca²⁺ +
 dopamine → CREB), and the production bottleneck: its tag gates how much material all downstream
 components get in NIGHT.
 ### AXON | AP — reliable propagation with frequency-dependent failure
 Propagation reliability is set by myelination and degraded by high-frequency load (Na⁺
 inactivation at branch points = axonal STD). The axon also transports material to boutons and
 sets the timescale of presynaptic structural commits.
 ### ASTRO | CONTINUOUS — gatekeeper and energy hub
 Clears glutamate (EAAT), supplies D-serine (the NMDA co-agonist that gates postsynaptic LTP),
 and distributes lactate to the territory by demand-weighting (active synapses generating more
 clearance load pull more fuel; slow synapses get less). The same spillover that excites the
 astrocyte (mGluR5 → Ca²⁺ → D-serine) also brakes the presynapse (mGluR2/3 → Gi) — one signal,
 opposite effects via different receptors. The astrocyte is the energy root and the gain control
 of the whole synapse.
 ---
 ## NIGHT operations — biological meaning
 - **Step 1 (replenish/distribute):** overnight protein synthesis peaks (CREB-driven, gated by
  soma_tag — corresponds to slow-wave-sleep replay). Soma material flows to branches/axon then
  spines/boutons; astrocyte material flows to astrosynapses, tag-weighted.
 - **Step 2 (strength commits):** tagged components build structure — more slots, tighter
  coupling, tighter astrosynaptic wrap. Coherence bonus when pre+post+astro all tagged (the
  whole synapse agrees). astro_structure self-reinforces.
 - **Step 2b (endurance commits):** components with high endurance_need build budget_ceiling —
  mitochondrial biogenesis. Competes with step 2 for the same material/energy.
 - **Step 3 (passive decay):** both ceilings decay; maintenance from the remaining pool resists
  decay only where sufficient. Depotentiation and endurance-loss are both by neglect — no
  signal weakens anything; unmaintained capacity simply drifts down. Recovered material (not
  energy) returns to pools.
 - **Step 4 (homeostatic scaling):** if the soma fired too much overall, all synapses scale down
  proportionally (sleep-associated global downscaling), preserving relative differences.
 - **Step 5 (clear traces):** fast traces, possible tags, endurance needs, and soma timing traces
  reset; tags below expiry clear, above-expiry tags carry forward (multi-night consolidation);
  structure and budget_ceiling persist.
 ### Shockwave lockdown
 Emergency global astrocytic Ca²⁺ wave → GABA + ATP release → mass AMPA internalization and
 hyperpolarization. Bypasses budget gates. A circuit breaker against runaway excitation.
 ---
 ## Pool-filling: private reserve vs contested supply
 The pseudocode uses two filling primitives, distinguished by where the resource comes from.
 **`fill` (private reserve).** The pool is replenished from a source the component owns
 outright, uncontested by siblings, bounded by the component's own ceiling and a rate cap.
 - RRP refill — vesicles mobilized from the bouton's own reserve pool toward the docking-slot
  ceiling, rate-limited by VATPase. The reserve is private to the bouton.
 - SOMA self-replenish — the soma fuels itself from its own mitochondria toward its budget
  ceiling. No other component draws on it.
 **`refill` (contested supply).** The pool is replenished from a supply that multiple
 components compete for, rationed by demand (gap to ceiling).
 - pre/post/dend/axon budgets — drawn from astrocytic lactate (shared across all synapses the
  astrocyte wraps) plus shipment from soma/axon/dendrite (shared across downstream targets).
 **Neither primitive (their own forms).** Some inflows are not fills toward a ceiling:
 - AMPA surface insertion — Ca²⁺-driven rate from the spine's private endosomal reserve, with
  an explicit passive drift-back (short-term depression) when Ca²⁺ is low. Not a steady fill.
 - D-serine release — demand-driven (saturating in astro Ca²⁺) and budget-limited, like NT
  release; a release process, not a pool top-up.
 - Root productions — `glycolysis(glucose)` at the astrocyte and `CREB_synth(soma_tag)` at the
  soma are the system's energy and material roots: raw inflows capped only by the external
  vascular supply, not fills toward an internal ceiling.
 The distinction matters biologically: a private reserve guarantees a component some autonomy
 (the bouton can refill its RRP from its own vesicles even when lactate is scarce), while a
 contested supply couples a component's fate to its neighbours' demands (operational budget
 fails first where many active synapses compete for the same lactate).
 ---
 ## PRE ↔ POST interaction: local computation, message-only coupling
 The presynapse and postsynapse never read each other's internal state. They interact only
 by writing to and reading from shared cleft channels. Each side computes entirely locally on
 what it has: its own variables plus whatever signals have arrived in the cleft. This is the
 message-passing realization of the locality principle.
 **Forward channel — glutamate (PRE → POST and ASTRO).** The presynapse writes glutamate via
 NT_flux. The postsynapse reads it (AMPA, NMDA) and the astrosynapse reads it (clearance,
 mGluR5). The astrosynapse clears it. PRE never knows whether POST responded — it only emits.
 **Gate channel — astro_Dserine (ASTRO → POST).** The astrosynapse writes D-serine; the
 postsynapse reads it as the obligatory NMDA co-agonist. POST cannot open NMDA without this
 arrived signal, but it does not read the astrocyte's state — only the delivered D-serine.
 **Backward channel + — retro_NO (POST → PRE).** When the postsynapse's NMDA opens (Mg²⁺
 ejected, D-serine present, glutamate bound), nNOS — physically tethered to the NMDA receptor
 through PSD-95 — synthesises nitric oxide (and, on a slower timescale, BDNF is released).
 These diffuse retrogradely to the presynapse. Biologically this is the classic retrograde
 messenger of LTP: it tells the bouton that its release landed on a postsynapse that genuinely
 responded. In the model, POST emits `retro_NO` proportional to its own NMDA-driven calcium —
 computed purely from POST's local state — and PRE reads it as `retro_NO_local`.
  `retro_NO_local` is exactly the grounding of the presynaptic endurance signal. The
  presynapse's local success proxy is "I was releasing strongly" (`pre_fast_trace` high). On
  its own that only says the bouton was working hard, not that the work mattered. `retro_NO`
  adds the missing confirmation — that the postsynapse responded — without PRE ever reading
  POST's calcium. So PRE deposits endurance need as `pre_fast_trace × (1 + retro_NO_local)`:
  strong release that was confirmed effective makes the strongest claim that fuel, not
  futility, was what interrupted a forming success. retro_NO is short-lived (NO degrades and
  diffuses within seconds), so the channel decays fast — confirmation must be recent to count.
 **Backward channel − — retro_eCB (POST → PRE).** When the postsynapse is strongly
 depolarised, it synthesises endocannabinoids (2-AG, anandamide) that diffuse retrogradely and
 bind presynaptic CB1 receptors, suppressing release. This is depolarisation-induced
 suppression of excitation (DSE) — a homeostatic negative feedback: an over-driven postsynapse
 tells the presynapse to release less. In the model, POST emits `retro_eCB` from its own
 membrane potential, and PRE reads it as `retro_eCB_local`, which reduces the release drive
 `sat(...) × (1 - retro_eCB_local)`. Again POST computes from its own state; PRE adjusts from
 the arrived signal; neither reads the other's interior.
 The two backward channels are opposite-signed messages the postsynapse sends about its own
 condition: retro_NO says "your input was effective — worth sustaining," retro_eCB says "I am
 saturated — ease off." Together with the forward glutamate and the D-serine gate, they make
 the synapse a fully message-coupled system of locally-computing components.
 **Why RRP refill is in NOT_AP only.** During an AP the bouton releases — RRP depletes. Refill
 (VATPase reloading vesicles from the reserve pool) is a recovery process that proceeds between
 spikes. Placing `fill(RRP, ...)` only in the NOT_AP context makes the AP context pure
 depletion and the NOT_AP context pure recovery. A consequence falls out for free: during
 sustained high-frequency firing there are many AP steps and few NOT_AP steps, so RRP depletes
 faster than it recovers — short-term depression deepens with frequency, with no explicit
 depression rule. The release itself is throttled further when budget is low (VATPase refill
 is energy-limited), coupling metabolic state to the depth of depression.
@@ -0,0 +1,442 @@
 # Tripartite Synapse — Pseudocode v12
 > Companion: `tripartite_synapse_v12_biology.md`.
 > Changes from v11: SENSE renamed TRACE; new ADJUST group (compute local operating
 > parameters from structure + traces + modulators); reference order puts EVALUATE before
 > ADJUST and DECAY; NIGHT labeled with the same group grammar; all `// GROUP` headers sit
 > at one indentation column so they stand out.
 ---
 ## Functional groups (uniform grammar, applied within each context)
 ```
 RECEIVE   take in resources + signals that arrived from outside
 EVALUATE  judge behavior — strength (needs dopamine) + endurance (interrupted success)
 ADJUST    compute local operating parameters from structure + traces + modulators
 BEHAVE    the component's defining action, using the adjusted parameters
 EMIT      send out — signals (messages) and resources (shipments) across the boundary
 TRACE     deposit the fast trace that records the behavior
 RECOVER   refill own private pools consumed by behaving
 DECAY     let traces recede, closing their windows
 ```
 Groups sit inside the DAY contexts (Option A). Execution contexts (AP/bAP/CONTINUOUS) carry
 ADJUST/BEHAVE/EMIT/TRACE and endurance-EVALUATE; replenishment contexts (NOT_AP/NOT_bAP)
 carry RECEIVE/strength-EVALUATE/RECOVER/DECAY. Not every component uses every group. Group
 order within a context follows data dependencies (e.g. where a fast trace both drives a
 behavior and records it, TRACE precedes ADJUST). NIGHT runs the same grammar on ceilings.
 ---
 ## 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
  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
    amount = min(rate, ceiling - pool)·Δt;  budget -= amount·cost;  return amount
 refill(c from supply S) -> amount:                         // CONTESTED supply
    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:       // DIRECTED transfer
    amount = min(from_budget·frac, demand_sig);  from_budget -= amount·(1+cost);  return amount
 ```
 ---
 ## 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)
 decay_rate  capacity_decay_rate  recycle  homeostatic_ceiling
 coherence_factor  assembly_cost  biogenesis_cost  maint_cost
 ```
 ---
 ---
 # 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     (residual Ca²⁺ from this spike — also drives release)
    pre_fast_trace += spike_Ca(input_freq)
    // ADJUST    (release drive from trace + received DSE brake)
    drive = sat(pre_fast_trace, K_release) × (1 - retro_eCB_local)
    // BEHAVE    (release or fail)
    if pre_budget < release_cost:
        suppress(NT_flux)
        if pre_fast_trace > traj_thr:                      // EVALUATE (endurance): retro_NO-confirmed
            pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)
        exit
    if RRP > 0:
        NT_flux = RRP × drive;  RRP -= NT_flux·Δt;  pre_budget -= NT_flux·fusion_cost
        // EMIT
        glutamate += NT_flux·Δt
    if glutamate > spillover: drive *= brake               // own-cleft autobrake
 DAY | NOT_AP:
    // RECEIVE
    retro_NO_local = retro_NO;  retro_eCB_local = retro_eCB
    pre_budget += refill(pre from astro_lactate[syn] + axon_ship_pre)
    // EVALUATE  (strength)
    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)
    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
 DAY | NOT_bAP:
    // RECEIVE
    post_budget += refill(post from astro_lactate[syn] + dend_ship_post)
    // 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:
        AMPA_surface = min(AMPA_surface + Ca_insert(post_fast_trace), post_structure.slot_ceiling)
        post_budget -= traffic_cost
    else:
        AMPA_surface = max(AMPA_surface - drift·Δt, baseline)
    // EVALUATE  (endurance: own Ca was climbing toward a tag when fuel failed)
    if post_budget < req_cost and post_fast_trace > traj_thr and post_fast_trace_rising:
        post_endurance_need += post_fast_trace
    // EVALUATE  (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
 // 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
 DAY | bAP:
    // ADJUST    (propagation strength from structure)  -> inside propagate()
    // BEHAVE    (propagate bAP; may fall short if depleted)
    bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, dend_budget, geometry)
    dend_budget -= prop_cost × reached
    // EVALUATE  (endurance: propagation cut short while branch strongly active)
    if reached < full and dend_fast_trace > traj_thr:
        dend_endurance_need += dend_fast_trace
    // 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] + soma_ship_dend)
    // EVALUATE  (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·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
 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:
            if soma_fast_trace > traj_thr and soma_fast_trace_rising:    // EVALUATE (endurance)
                soma_endurance_need += soma_fast_trace
            exit
        fired = True;  soma_budget -= ap_cost              // EMIT: fired → AXON, DEND
        // TRACE     (three traces from one AP)
        soma_Na_inactivation += ap_amp                     // → refractory (emergent)
        soma_adaptation      += ap_contrib                 // → threshold rise
        soma_fast_trace      += nuclear_Ca();  soma_budget -= nuclear_cost
        // EVALUATE  (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)
    // BEHAVE    (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; 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
 DAY | AP:
    // ADJUST    (reliability from structure − load-driven failure)
    reliability = axon_structure.propagation × (1 - fail(axon_fast_trace))
    // BEHAVE    (propagate; degraded if depleted)
    if axon_budget < prop_cost:
        reliability *= budget_factor
        if axon_fast_trace > traj_thr:                     // EVALUATE (endurance)
            axon_endurance_need += axon_fast_trace
    delivered = fired × reliability;  axon_budget -= prop_cost × delivered   // EMIT → 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])
    // EVALUATE  (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
 //   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)
        // BEHAVE + EMIT  (D-serine pulse: demand-driven, budget-limited)
        want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
        got  = min(want, astro_central_budget × Ds_frac)
        astro_Dserine[i] += got;  astro_central_budget -= got·Ds_cost
        // EVALUATE  (endurance: ran out of synthesis under high own demand)
        if got < want and astro_fast_trace[i] > traj_thr:
            astro_endurance_need[i] += (want - got)
        // EVALUATE  (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
 The same grammar on ceilings: RECEIVE production, EVALUATE/ADJUST the commits, BEHAVE
 (build ceilings), DECAY (unmaintained ceilings recede). Runs once per cycle, not per spike.
 ```
 NIGHT | 1  RECEIVE + EMIT  (replenish and distribute)
    astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt        // RECEIVE
    soma_{budget,energy} += overnight_*()·Δt ; soma_material += CREB_synth(soma_tag)·Δt  // RECEIVE (bottleneck)
    for each i with astro_tag[i] > tag_expiry:  w = astro_tag[i]/Σastro_tag      // ADJUST (weights)
        astro_energy[i] += astro_central_energy·w;  astro_material[i] += astro_central_material·w  // EMIT
    dend_material += soma_material·f_dend ; axon_material += soma_material·f_axon ; soma_material -= … // EMIT
    post_material += dend_material·f_spine ; pre_material += axon_material·f_bouton                    // EMIT
    {pre,post,dend,axon}_energy += soma_energy·f[·] ; {…}_budget += astro_lactate_reserve·f[·]·Δt
 NIGHT | 2  EVALUATE + BEHAVE  (strength commits → raise structure)
    coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1   // ADJUST
    for each c with c_tag > tag_expiry:                                                    // EVALUATE
        Δ = min(slot_cost, c_material, c_energy·f)                                          // BEHAVE
        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 EVALUATE + BEHAVE  (endurance commits → raise budget_ceiling ; no dopamine ; competes w/ 2)
    for each c with c_endurance_need > endur_thr:                                           // EVALUATE
        Δ = min(cap_cost, c_material·f_cap, c_energy·f_cap)                                 // BEHAVE
        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
 ```
 DAY    per context: RECEIVE → EVALUATE → ADJUST → BEHAVE/EMIT/TRACE → RECOVER → DECAY
       behavior runs within structure (strength) and budget_ceiling (endurance),
       both filled competitively (refill = contested, fill = private, ship = directed)
       fast_trace + dopamine        → tag            (strength evidence)
       depletion + interrupted LOCAL success → endurance_need (endurance evidence)
 NIGHT  same grammar on ceilings: tag → structure ; endurance_need → budget_ceiling
       both draw one pool (compete) ; unmaintained ceilings decay → freed material recycles
 LOCAL  every evaluation uses only own state + arrived signals; coupling is via channels.
 ```
@@ -0,0 +1,480 @@
 # Tripartite Synapse — Pseudocode v11
 > Companion: `tripartite_synapse_v11_biology.md` explains the biology of every variable.
 > Changes from v10: each component now carries its own PARAMETERS and EXTERNAL INTERFACE
 > blocks; behaviors are organized into functional groups within each context; pool-filling
 > primitives return their increment (applied by the caller); the astrocyte no longer writes
 > PRE's drive (the spillover brake is PRE reading its own cleft).
 ---
 ## Functional groups (the uniform template, applied within each context)
 ```
 RECEIVE   take in resources + signals that arrived from outside
 BEHAVE    the component's defining action
 EMIT      send out — signals (messages) and resources (shipments) across the boundary
 SENSE     deposit the fast trace that records the behavior
 RECOVER   refill own private pools consumed by behaving
 EVALUATE  judge the behavior — strength (needs dopamine) + endurance (interrupted success)
 DECAY     let traces recede, closing their windows
 ```
 Groups sit inside the DAY contexts (Option A): execution contexts (AP/bAP/CONTINUOUS) carry
 BEHAVE/EMIT/SENSE/endurance-EVALUATE; replenishment contexts (NOT_AP/NOT_bAP) carry
 RECEIVE/RECOVER/strength-EVALUATE/DECAY. Not every component uses every group.
 ---
 ## 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 (each component writes, others read)
  glutamate     PRE → POST, ASTRO     forward transmitter; ASTRO clears it
  astro_Dserine ASTRO → POST          NMDA co-agonist gate
  retro_NO      POST → PRE  (+)        "release reached a responsive target"
  retro_eCB     POST → PRE  (−)        DSE: "over-driven, release less"
 SHIPMENT CHANNELS (source writes, target reads in its RECEIVE)
  soma_ship_dend SOMA→DEND   soma_ship_axon SOMA→AXON
  dend_ship_post DEND→POST   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
    amount  = min(rate, ceiling - pool)·Δt
    budget -= amount·cost                                  // intrinsic refill cost
    return amount
 refill(c from supply S) -> amount:                         // CONTESTED supply
    demand  = c.budget_ceiling - c.budget
    factor  = min(1, S / (Σ demand over components on S + ε))
    S      -= demand·factor                                // consumes shared supply
    return demand·factor
 ship(from_budget, demand_sig, frac, cost) -> amount:       // DIRECTED transfer
    amount       = min(from_budget·frac, demand_sig)       // demand_sig = propagated tag
    from_budget -= amount·(1 + cost)
    return amount                                          // caller writes shipment channel
 ```
 ---
 ## SHARED parameters (organism / physical / universal plasticity machinery)
 ```
 // organism broadcasts (external; arrive as local levels)
 dopamine  NE  ACh
 // physical (external)
 glucose            // vascular energy ceiling — root
 geometry           // dendritic topology — bAP attenuation
 // universal plasticity gates (same mechanism in every component)
 elig  dop_thr  tag_thr  tag_expiry          // strength: eligibility → tag
 traj_thr  endur_thr                         // endurance: interrupted-success → need
 // universal NIGHT
 decay_rate  capacity_decay_rate  recycle
 homeostatic_ceiling  coherence_factor  assembly_cost  biogenesis_cost  maint_cost
 // decay-time convention: each *= decay(τ) means relax toward 0 with time-constant τ
 ```
 ---
 ---
 # DAY
 ---
 ## PRE
 ```
 // PARAMETERS (pre)
 //   K_release   half-max Ca²⁺ for release      release_cost  gate to release
 //   fusion_cost per unit NT_flux               vatpase_cost  per unit RRP refilled
 //   spillover   cleft level for autobrake      brake         autoreceptor factor
 //
 // EXTERNAL INTERFACE
 //   EMIT     glutamate → POST, ASTRO
 //   RECEIVE  astro_lactate[syn] ← ASTRO (primary fuel) ; axon_ship_pre ← AXON (fuel)
 //            retro_NO, retro_eCB ← POST (backward messages)
 //            pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT)
 //   READ     glutamate (own cleft, autobrake) ; dopamine (VTA, gates tag)
 //   OWN      pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling
 //   EMERGENCY shockwave_lockdown ← ASTRO
 DAY | AP:
    // SENSE
    pre_fast_trace += spike_Ca(input_freq)
    // BEHAVE — release or fail
    if pre_budget < release_cost:
        suppress(NT_flux)
        // EVALUATE (endurance) — interrupted local success, confirmed by retro_NO
        if pre_fast_trace > traj_thr:
            pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)
        exit
    drive = sat(pre_fast_trace, K_release) × (1 - retro_eCB_local)
    if RRP > 0:
        NT_flux = RRP × drive
        // EMIT
        glutamate += NT_flux·Δt
        RRP -= NT_flux·Δt;  pre_budget -= NT_flux·fusion_cost
    if glutamate > spillover: drive *= brake               // own-cleft autobrake
 DAY | NOT_AP:
    // RECEIVE
    retro_NO_local = retro_NO;  retro_eCB_local = retro_eCB
    pre_budget += refill(pre from astro_lactate[syn] + axon_ship_pre)
    // RECOVER
    RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
    // EVALUATE (strength)
    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
    // 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 (post)
 //   K_AMPA      half-max glu for AMPA          AMPA_Ca   Ca fraction via AMPA
 //   AMPA_cost  NMDA_cost  bAP_cost  pka_cost   traffic_cost  req_cost
 //   Mg_eject   Vm to eject Mg block            Dserine_thr  NMDA co-agonist gate
 //   Ca_STP     fill-slots threshold           Ca_TAG    tagging threshold
 //   eCB_thr    Vm for endocannabinoid (DSE)    drift  baseline  (STD relaxation)
 //   NO_synth_cost  eCB_synth_cost
 //
 // EXTERNAL 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 (via dend_structure.bAP_fidelity)
 //            dopamine (VTA, stabilizes tag)
 //   OWN      post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling
 //   EMERGENCY shockwave_lockdown ← ASTRO
 DAY | NOT_bAP:
    // RECEIVE
    post_budget += refill(post from astro_lactate[syn] + dend_ship_post)
    // BEHAVE + SENSE — three Ca sources feed post_fast_trace
    a = sat(glutamate, K_AMPA)                              // SOURCE 1: AMPA
    AMPA_current = a × AMPA_surface;  Vm += AMPA_current
    post_fast_trace += AMPA_Ca·AMPA_current;  post_budget -= AMPA_cost
    if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0:   // SOURCE 2: NMDA
        post_fast_trace += NMDA_Ca(glutamate)·rise_speed();  post_budget -= NMDA_cost
        // EMIT (+)
        retro_NO += NO_emit(post_fast_trace);  post_budget -= NO_synth_cost
    // EMIT (−)
    if Vm > eCB_thr: retro_eCB += eCB_emit(Vm);  post_budget -= eCB_synth_cost
    post_fast_trace *= decay(ms)
    // BEHAVE — STP fill slots (Ca-driven, private reserve); else STD drift (consequence)
    if post_fast_trace > Ca_STP:
        AMPA_surface = min(AMPA_surface + Ca_insert(post_fast_trace), post_structure.slot_ceiling)
        post_budget -= traffic_cost
    else:
        AMPA_surface = max(AMPA_surface - drift·Δt, baseline)
    // EVALUATE (endurance) — interrupted local success (own Ca climbing toward tag)
    if post_budget < req_cost and post_fast_trace > traj_thr and post_fast_trace_rising:
        post_endurance_need += post_fast_trace
    // EVALUATE (strength) — CANDIDATE then STABLE (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 + SENSE — SOURCE 3: bAP amplifies an existing signal
    Vm += bAP_depol × dend_structure.bAP_fidelity;  post_budget -= bAP_cost
    if post_possible_tag > Ca_TAG: post_fast_trace += bAP_Ca_boost()
 ```
 ---
 ## DEND
 ```
 // PARAMETERS (dend)
 //   prop_cost  branch_Ca_cost  integrate_cost  translate_cost
 //
 // EXTERNAL 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 (bAP trigger) ; POST.Vm + spine spillover (to integrate)
 //            dopamine ; ACh (commit-threshold context)
 //   OWN      dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling
 DAY | bAP:
    // BEHAVE — propagate bAP (may fall short if depleted), integrate spines
    bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, dend_budget, geometry)
    dend_budget -= prop_cost × reached
    // EVALUATE (endurance) — propagation cut short while branch strongly active (LOCAL)
    if reached < full and dend_fast_trace > traj_thr:
        dend_endurance_need += dend_fast_trace
    // SENSE
    dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover();  dend_budget -= branch_Ca_cost
    // EMIT — propagated bAP to spines; integrated voltage to soma
    branch_Vm = integrate(POST.Vm, spines);  dend_budget -= integrate_cost
 DAY | NOT_bAP:
    // RECEIVE
    dend_budget += refill(dend from astro_lactate[branch] + soma_ship_dend)
    // EMIT — ship budget downstream to spines (demand = post tag)
    dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost)
    // EVALUATE (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
    // BEHAVE — local translation if tagged (fills dend capacity faster)
    if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost
    commit_threshold *= 1/(1 + ACh·gain)
    // DECAY
    dend_fast_trace *= decay(300ms);  dend_possible_tag *= decay(s)
    dend_endurance_need *= decay(min);  dend_tag *= decay(hr)
 ```
 ---
 ## SOMA
 ```
 // PARAMETERS (soma)
 //   ap_cost  nuclear_cost  creb_cost            mito_output  (self-fuel rate)
 //   inactivation  ap_amp  ap_contrib            base_recovery
 //   τ_Na  τ_adapt  τ_nuclear  τ_align
 //
 // EXTERNAL 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
 DAY | AP:
    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:
            // EVALUATE (endurance) — fuel cut a firing train approaching CREB (LOCAL)
            if soma_fast_trace > traj_thr and soma_fast_trace_rising:
                soma_endurance_need += soma_fast_trace
            exit
        fired = True;  soma_budget -= ap_cost              // EMIT: fired → AXON, DEND
        // SENSE — three traces from one AP
        soma_Na_inactivation += ap_amp                     // → refractory (emergent)
        soma_adaptation      += ap_contrib                 // → threshold rise
        soma_fast_trace      += nuclear_Ca();  soma_budget -= nuclear_cost
        // EVALUATE (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:
    // BEHAVE — 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
    // RECOVER — recovery rate sped by alignment trace
    recovery = base_recovery × (1 + soma_refractory_alignment)
    soma_Na_inactivation *= decay(τ_Na / recovery)
    // RECEIVE — self-replenish (private root) + integrate input
    soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
    branch_Vm = integrate(DEND.branch_Vm, branches)
    // EMIT — ship downstream (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)
    // 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 (axon)
 //   prop_cost  budget_factor  (depleted-propagation penalty)
 //
 // EXTERNAL 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
 DAY | AP:
    reliability = axon_structure.propagation × (1 - fail(axon_fast_trace))
    // BEHAVE — propagate (degraded if depleted)
    if axon_budget < prop_cost:
        reliability *= budget_factor
        // EVALUATE (endurance) — propagating a strong train when fuel failed (LOCAL)
        if axon_fast_trace > traj_thr: axon_endurance_need += axon_fast_trace
    delivered = fired × reliability;  axon_budget -= prop_cost × delivered
    // EMIT — delivered APs reach boutons
    // SENSE
    axon_fast_trace += delivered;  axon_fast_trace *= decay(s)
 DAY | NOT_AP:
    // RECEIVE
    axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
    // EMIT — ship budget to boutons (demand = pre tag)
    axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost)
    // EVALUATE (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
    // DECAY
    axon_fast_trace *= decay(s);  axon_possible_tag *= decay(s)
    axon_endurance_need *= decay(min);  axon_tag *= decay(hr)
 ```
 ---
 ## ASTRO
 ```
 // PARAMETERS (astro)
 //   K_Dserine  half-max Ca for D-serine        Ds_max  Ds_frac  Ds_cost
 //   EAAT_cost  per unit glutamate cleared       lactate_cost  per unit exported
 //   spillover  overflow threshold               overload  lockdown threshold
 //
 // EXTERNAL 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
 //   EMERGENCY emits shockwave_lockdown on overload
 DAY | CONTINUOUS:                                          // per astrosynapse i
    // RECEIVE — root production, capped by glucose
    astro_central_budget += glycolysis(glucose)·Δt
    // EMIT — demand-weighted lactate allocation across territory
    for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff
    factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε))
    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:
        // SENSE
        astro_fast_trace[i] += mGluR_Ca();  astro_fast_trace[i] *= decay(s)
        // BEHAVE + EMIT — D-serine pulse (demand-driven, budget-limited)
        want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
        got  = min(want, astro_central_budget × Ds_frac)
        astro_Dserine[i] += got;  astro_central_budget -= got·Ds_cost
        // EVALUATE (endurance) — ran out of synthesis under high own demand (LOCAL)
        if got < want and astro_fast_trace[i] > traj_thr:
            astro_endurance_need[i] += (want - got)
        // EVALUATE (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
 System-wide consolidation (not a per-component DAY cycle). Build ceilings from DAY evidence.
 ```
 NIGHT | 1  REPLENISH & DISTRIBUTE
    // energy economy: astrocyte central → astrosynapses (astro_tag-weighted)
    astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt
    for each i with astro_tag[i] > tag_expiry:  w = astro_tag[i]/Σastro_tag
        astro_energy[i] += astro_central_energy·w;  astro_material[i] += astro_central_material·w
    // material economy: soma → branch/axon → spine/bouton
    soma_budget += overnight_mito()·Δt;  soma_energy += overnight_soma_energy()·Δt
    soma_material += CREB_synth(soma_tag)·Δt                // bottleneck
    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·f[·]
    {pre,post,dend,axon}_budget += astro_lactate_reserve·f[·]·Δt
 NIGHT | 2  STRENGTH COMMITS (raise structure)
    coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1
    for each c with c_tag > tag_expiry:
        Δ = min(slot_cost, c_material, c_energy·f)
        c_structure += Δ × (coherence if c in {pre,post,astro} else 1)
        c_material -= Δ;  c_energy -= Δ·assembly_cost
        if Δ < slot_cost: queue(c_strength_deficit → next NIGHT)
 NIGHT | 2b ENDURANCE COMMITS (raise budget_ceiling) — no dopamine; competes with step 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(c_endurance_deficit → next NIGHT)
 NIGHT | 3  PASSIVE DECAY (both ceilings, by neglect)
    maint = (total_material - consumed) × maint_frac / synapse_count
    for each synapse:
        {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:                  // material recovered, energy not
        {pre,post,astro}_material += |net_change|·recycle·frac
 NIGHT | 4  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  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
 ```
 DAY    per context, per component: RECEIVE → BEHAVE/EMIT/SENSE → RECOVER → EVALUATE → DECAY
       behavior runs within structure (strength) and budget_ceiling (endurance),
       both filled by competition (refill = contested, fill = private, ship = directed)
       fast_trace + dopamine coincidence  → tag            (strength evidence)
       depletion + interrupted LOCAL success → endurance_need (endurance evidence)
 NIGHT  tag → structure ; endurance_need → budget_ceiling ; both draw one pool (compete)
       unmaintained ceilings decay → freed material funds the rest
 LOCAL  every evaluation uses only own state + arrived signals; coupling is via channels.
 ```
@@ -0,0 +1,480 @@
 # Tripartite Synapse — Pseudocode v11
 > Companion: `tripartite_synapse_v11_biology.md` explains the biology of every variable.
 > Changes from v10: each component now carries its own PARAMETERS and EXTERNAL INTERFACE
 > blocks; behaviors are organized into functional groups within each context; pool-filling
 > primitives return their increment (applied by the caller); the astrocyte no longer writes
 > PRE's drive (the spillover brake is PRE reading its own cleft).
 ---
 ## Functional groups (the uniform template, applied within each context)
 ```
 RECEIVE   take in resources + signals that arrived from outside
 BEHAVE    the component's defining action
 EMIT      send out — signals (messages) and resources (shipments) across the boundary
 SENSE     deposit the fast trace that records the behavior
 RECOVER   refill own private pools consumed by behaving
 EVALUATE  judge the behavior — strength (needs dopamine) + endurance (interrupted success)
 DECAY     let traces recede, closing their windows
 ```
 Groups sit inside the DAY contexts (Option A): execution contexts (AP/bAP/CONTINUOUS) carry
 BEHAVE/EMIT/SENSE/endurance-EVALUATE; replenishment contexts (NOT_AP/NOT_bAP) carry
 RECEIVE/RECOVER/strength-EVALUATE/DECAY. Not every component uses every group.
 ---
 ## 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 (each component writes, others read)
  glutamate     PRE → POST, ASTRO     forward transmitter; ASTRO clears it
  astro_Dserine ASTRO → POST          NMDA co-agonist gate
  retro_NO      POST → PRE  (+)        "release reached a responsive target"
  retro_eCB     POST → PRE  (−)        DSE: "over-driven, release less"
 SHIPMENT CHANNELS (source writes, target reads in its RECEIVE)
  soma_ship_dend SOMA→DEND   soma_ship_axon SOMA→AXON
  dend_ship_post DEND→POST   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
    amount  = min(rate, ceiling - pool)·Δt
    budget -= amount·cost                                  // intrinsic refill cost
    return amount
 refill(c from supply S) -> amount:                         // CONTESTED supply
    demand  = c.budget_ceiling - c.budget
    factor  = min(1, S / (Σ demand over components on S + ε))
    S      -= demand·factor                                // consumes shared supply
    return demand·factor
 ship(from_budget, demand_sig, frac, cost) -> amount:       // DIRECTED transfer
    amount       = min(from_budget·frac, demand_sig)       // demand_sig = propagated tag
    from_budget -= amount·(1 + cost)
    return amount                                          // caller writes shipment channel
 ```
 ---
 ## SHARED parameters (organism / physical / universal plasticity machinery)
 ```
 // organism broadcasts (external; arrive as local levels)
 dopamine  NE  ACh
 // physical (external)
 glucose            // vascular energy ceiling — root
 geometry           // dendritic topology — bAP attenuation
 // universal plasticity gates (same mechanism in every component)
 elig  dop_thr  tag_thr  tag_expiry          // strength: eligibility → tag
 traj_thr  endur_thr                         // endurance: interrupted-success → need
 // universal NIGHT
 decay_rate  capacity_decay_rate  recycle
 homeostatic_ceiling  coherence_factor  assembly_cost  biogenesis_cost  maint_cost
 // decay-time convention: each *= decay(τ) means relax toward 0 with time-constant τ
 ```
 ---
 ---
 # DAY
 ---
 ## PRE
 ```
 // PARAMETERS (pre)
 //   K_release   half-max Ca²⁺ for release      release_cost  gate to release
 //   fusion_cost per unit NT_flux               vatpase_cost  per unit RRP refilled
 //   spillover   cleft level for autobrake      brake         autoreceptor factor
 //
 // EXTERNAL INTERFACE
 //   EMIT     glutamate → POST, ASTRO
 //   RECEIVE  astro_lactate[syn] ← ASTRO (primary fuel) ; axon_ship_pre ← AXON (fuel)
 //            retro_NO, retro_eCB ← POST (backward messages)
 //            pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT)
 //   READ     glutamate (own cleft, autobrake) ; dopamine (VTA, gates tag)
 //   OWN      pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling
 //   EMERGENCY shockwave_lockdown ← ASTRO
 DAY | AP:
    // SENSE
    pre_fast_trace += spike_Ca(input_freq)
    // BEHAVE — release or fail
    if pre_budget < release_cost:
        suppress(NT_flux)
        // EVALUATE (endurance) — interrupted local success, confirmed by retro_NO
        if pre_fast_trace > traj_thr:
            pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)
        exit
    drive = sat(pre_fast_trace, K_release) × (1 - retro_eCB_local)
    if RRP > 0:
        NT_flux = RRP × drive
        // EMIT
        glutamate += NT_flux·Δt
        RRP -= NT_flux·Δt;  pre_budget -= NT_flux·fusion_cost
    if glutamate > spillover: drive *= brake               // own-cleft autobrake
 DAY | NOT_AP:
    // RECEIVE
    retro_NO_local = retro_NO;  retro_eCB_local = retro_eCB
    pre_budget += refill(pre from astro_lactate[syn] + axon_ship_pre)
    // RECOVER
    RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
    // EVALUATE (strength)
    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
    // 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 (post)
 //   K_AMPA      half-max glu for AMPA          AMPA_Ca   Ca fraction via AMPA
 //   AMPA_cost  NMDA_cost  bAP_cost  pka_cost   traffic_cost  req_cost
 //   Mg_eject   Vm to eject Mg block            Dserine_thr  NMDA co-agonist gate
 //   Ca_STP     fill-slots threshold           Ca_TAG    tagging threshold
 //   eCB_thr    Vm for endocannabinoid (DSE)    drift  baseline  (STD relaxation)
 //   NO_synth_cost  eCB_synth_cost
 //
 // EXTERNAL 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 (via dend_structure.bAP_fidelity)
 //            dopamine (VTA, stabilizes tag)
 //   OWN      post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling
 //   EMERGENCY shockwave_lockdown ← ASTRO
 DAY | NOT_bAP:
    // RECEIVE
    post_budget += refill(post from astro_lactate[syn] + dend_ship_post)
    // BEHAVE + SENSE — three Ca sources feed post_fast_trace
    a = sat(glutamate, K_AMPA)                              // SOURCE 1: AMPA
    AMPA_current = a × AMPA_surface;  Vm += AMPA_current
    post_fast_trace += AMPA_Ca·AMPA_current;  post_budget -= AMPA_cost
    if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0:   // SOURCE 2: NMDA
        post_fast_trace += NMDA_Ca(glutamate)·rise_speed();  post_budget -= NMDA_cost
        // EMIT (+)
        retro_NO += NO_emit(post_fast_trace);  post_budget -= NO_synth_cost
    // EMIT (−)
    if Vm > eCB_thr: retro_eCB += eCB_emit(Vm);  post_budget -= eCB_synth_cost
    post_fast_trace *= decay(ms)
    // BEHAVE — STP fill slots (Ca-driven, private reserve); else STD drift (consequence)
    if post_fast_trace > Ca_STP:
        AMPA_surface = min(AMPA_surface + Ca_insert(post_fast_trace), post_structure.slot_ceiling)
        post_budget -= traffic_cost
    else:
        AMPA_surface = max(AMPA_surface - drift·Δt, baseline)
    // EVALUATE (endurance) — interrupted local success (own Ca climbing toward tag)
    if post_budget < req_cost and post_fast_trace > traj_thr and post_fast_trace_rising:
        post_endurance_need += post_fast_trace
    // EVALUATE (strength) — CANDIDATE then STABLE (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 + SENSE — SOURCE 3: bAP amplifies an existing signal
    Vm += bAP_depol × dend_structure.bAP_fidelity;  post_budget -= bAP_cost
    if post_possible_tag > Ca_TAG: post_fast_trace += bAP_Ca_boost()
 ```
 ---
 ## DEND
 ```
 // PARAMETERS (dend)
 //   prop_cost  branch_Ca_cost  integrate_cost  translate_cost
 //
 // EXTERNAL 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 (bAP trigger) ; POST.Vm + spine spillover (to integrate)
 //            dopamine ; ACh (commit-threshold context)
 //   OWN      dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling
 DAY | bAP:
    // BEHAVE — propagate bAP (may fall short if depleted), integrate spines
    bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, dend_budget, geometry)
    dend_budget -= prop_cost × reached
    // EVALUATE (endurance) — propagation cut short while branch strongly active (LOCAL)
    if reached < full and dend_fast_trace > traj_thr:
        dend_endurance_need += dend_fast_trace
    // SENSE
    dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover();  dend_budget -= branch_Ca_cost
    // EMIT — propagated bAP to spines; integrated voltage to soma
    branch_Vm = integrate(POST.Vm, spines);  dend_budget -= integrate_cost
 DAY | NOT_bAP:
    // RECEIVE
    dend_budget += refill(dend from astro_lactate[branch] + soma_ship_dend)
    // EMIT — ship budget downstream to spines (demand = post tag)
    dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost)
    // EVALUATE (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
    // BEHAVE — local translation if tagged (fills dend capacity faster)
    if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost
    commit_threshold *= 1/(1 + ACh·gain)
    // DECAY
    dend_fast_trace *= decay(300ms);  dend_possible_tag *= decay(s)
    dend_endurance_need *= decay(min);  dend_tag *= decay(hr)
 ```
 ---
 ## SOMA
 ```
 // PARAMETERS (soma)
 //   ap_cost  nuclear_cost  creb_cost            mito_output  (self-fuel rate)
 //   inactivation  ap_amp  ap_contrib            base_recovery
 //   τ_Na  τ_adapt  τ_nuclear  τ_align
 //
 // EXTERNAL 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
 DAY | AP:
    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:
            // EVALUATE (endurance) — fuel cut a firing train approaching CREB (LOCAL)
            if soma_fast_trace > traj_thr and soma_fast_trace_rising:
                soma_endurance_need += soma_fast_trace
            exit
        fired = True;  soma_budget -= ap_cost              // EMIT: fired → AXON, DEND
        // SENSE — three traces from one AP
        soma_Na_inactivation += ap_amp                     // → refractory (emergent)
        soma_adaptation      += ap_contrib                 // → threshold rise
        soma_fast_trace      += nuclear_Ca();  soma_budget -= nuclear_cost
        // EVALUATE (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:
    // BEHAVE — 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
    // RECOVER — recovery rate sped by alignment trace
    recovery = base_recovery × (1 + soma_refractory_alignment)
    soma_Na_inactivation *= decay(τ_Na / recovery)
    // RECEIVE — self-replenish (private root) + integrate input
    soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
    branch_Vm = integrate(DEND.branch_Vm, branches)
    // EMIT — ship downstream (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)
    // 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 (axon)
 //   prop_cost  budget_factor  (depleted-propagation penalty)
 //
 // EXTERNAL 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
 DAY | AP:
    reliability = axon_structure.propagation × (1 - fail(axon_fast_trace))
    // BEHAVE — propagate (degraded if depleted)
    if axon_budget < prop_cost:
        reliability *= budget_factor
        // EVALUATE (endurance) — propagating a strong train when fuel failed (LOCAL)
        if axon_fast_trace > traj_thr: axon_endurance_need += axon_fast_trace
    delivered = fired × reliability;  axon_budget -= prop_cost × delivered
    // EMIT — delivered APs reach boutons
    // SENSE
    axon_fast_trace += delivered;  axon_fast_trace *= decay(s)
 DAY | NOT_AP:
    // RECEIVE
    axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
    // EMIT — ship budget to boutons (demand = pre tag)
    axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost)
    // EVALUATE (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
    // DECAY
    axon_fast_trace *= decay(s);  axon_possible_tag *= decay(s)
    axon_endurance_need *= decay(min);  axon_tag *= decay(hr)
 ```
 ---
 ## ASTRO
 ```
 // PARAMETERS (astro)
 //   K_Dserine  half-max Ca for D-serine        Ds_max  Ds_frac  Ds_cost
 //   EAAT_cost  per unit glutamate cleared       lactate_cost  per unit exported
 //   spillover  overflow threshold               overload  lockdown threshold
 //
 // EXTERNAL 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
 //   EMERGENCY emits shockwave_lockdown on overload
 DAY | CONTINUOUS:                                          // per astrosynapse i
    // RECEIVE — root production, capped by glucose
    astro_central_budget += glycolysis(glucose)·Δt
    // EMIT — demand-weighted lactate allocation across territory
    for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff
    factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε))
    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:
        // SENSE
        astro_fast_trace[i] += mGluR_Ca();  astro_fast_trace[i] *= decay(s)
        // BEHAVE + EMIT — D-serine pulse (demand-driven, budget-limited)
        want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
        got  = min(want, astro_central_budget × Ds_frac)
        astro_Dserine[i] += got;  astro_central_budget -= got·Ds_cost
        // EVALUATE (endurance) — ran out of synthesis under high own demand (LOCAL)
        if got < want and astro_fast_trace[i] > traj_thr:
            astro_endurance_need[i] += (want - got)
        // EVALUATE (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
 System-wide consolidation (not a per-component DAY cycle). Build ceilings from DAY evidence.
 ```
 NIGHT | 1  REPLENISH & DISTRIBUTE
    // energy economy: astrocyte central → astrosynapses (astro_tag-weighted)
    astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt
    for each i with astro_tag[i] > tag_expiry:  w = astro_tag[i]/Σastro_tag
        astro_energy[i] += astro_central_energy·w;  astro_material[i] += astro_central_material·w
    // material economy: soma → branch/axon → spine/bouton
    soma_budget += overnight_mito()·Δt;  soma_energy += overnight_soma_energy()·Δt
    soma_material += CREB_synth(soma_tag)·Δt                // bottleneck
    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·f[·]
    {pre,post,dend,axon}_budget += astro_lactate_reserve·f[·]·Δt
 NIGHT | 2  STRENGTH COMMITS (raise structure)
    coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1
    for each c with c_tag > tag_expiry:
        Δ = min(slot_cost, c_material, c_energy·f)
        c_structure += Δ × (coherence if c in {pre,post,astro} else 1)
        c_material -= Δ;  c_energy -= Δ·assembly_cost
        if Δ < slot_cost: queue(c_strength_deficit → next NIGHT)
 NIGHT | 2b ENDURANCE COMMITS (raise budget_ceiling) — no dopamine; competes with step 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(c_endurance_deficit → next NIGHT)
 NIGHT | 3  PASSIVE DECAY (both ceilings, by neglect)
    maint = (total_material - consumed) × maint_frac / synapse_count
    for each synapse:
        {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:                  // material recovered, energy not
        {pre,post,astro}_material += |net_change|·recycle·frac
 NIGHT | 4  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  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
 ```
 DAY    per context, per component: RECEIVE → BEHAVE/EMIT/SENSE → RECOVER → EVALUATE → DECAY
       behavior runs within structure (strength) and budget_ceiling (endurance),
       both filled by competition (refill = contested, fill = private, ship = directed)
       fast_trace + dopamine coincidence  → tag            (strength evidence)
       depletion + interrupted LOCAL success → endurance_need (endurance evidence)
 NIGHT  tag → structure ; endurance_need → budget_ceiling ; both draw one pool (compete)
       unmaintained ceilings decay → freed material funds the rest
 LOCAL  every evaluation uses only own state + arrived signals; coupling is via channels.
 ```