Update elements/neuron/postsynapse.md

elements/neuron/appunti/2026-07-06-logic-principles-of-the-expresion_v5.md

@@ -0,0 +1,634 @@
+# The Logic of the Tripartite Synapse Model — v5
+
+*A synthesis of the principles the pseudocode enacts. The document is ordered why → what → how: it
+opens with why this is a different kind of object than an ordinary model (Part I), states the single
+principle its content obeys (Part II), then descends through seven categories that specialize that
+principle (Part III). The why comes first because it is the reason everything else matters — without
+it, a reader could take the categories for a description of a synapse and miss that they describe a
+physics that writes itself.*
+
+*What changed in v5. The old "evaluation" phase is retired — it was always preparation aimed at
+the other scope. The ring is recut into three categories: ACTION, RECOVERY, PREPARATION. The
+obsolete subject-mapping (lateral/local/vertical) is dropped. New findings are folded in: the
+rhythm is (ACTION ⇄ RECOVERY) × many, then PREPARATION; every category spans all timescales; night
+PREPARATION replays the day ACTION with the same machinery; build and release compete within a
+component while material competes between components; there are two independent forgettings;
+collaboration by day versus competition by night follows from the rivalry of each scope's currency;
+behavior is legible and meaning is assigned by the reader not the signal; and the three categories
+are the three modulable dimensions of behavior. Nine categories are consolidated to six, a seventh
+is added (the four operations), and — new in this revision — the "why" (formerly a closing note) is
+corrected and promoted to the front as Part I.*
+
+---
+
+# PART I — Why This Is Not a Model but a Way of Making Models
+
+Before the principles, one question: *what kind of object is this?* The answer is unusual, and it
+governs everything that follows. This is not a model you can write down and run. It is a **generator
+of models** — a rule that turns each history into a different fixed model, and only once that history
+has been lived. History is not a variable inside the model; history *is* the model. This part earns
+that claim, because stated cold it sounds like mysticism, and it is not — it is a checkable fact
+about what the coupled components do.
+
+**The pseudocode is a physics written in the grammar of an algorithm.** The companion pseudocode
+reads like a program — assignments, conditionals, loops — but every line leans on something code
+cannot supply. Its primitives — the calcium influxes, the fluctuations, the clearances — name
+*physical processes*, not computations; `mini_Ca()` is a placeholder for "whatever the matter does
+here." Every `·Δt` is a differential equation in disguise: the discrete step is our notation, the
+thing itself is continuous. And every coincidence — the three-way gate, the tag, the build — assumes
+its inputs are *present at the same instant at the same place*, which the physical cleft supplies for
+free by diffusion but which an `if` can only presuppose. The imperative grammar is a transcription;
+the content is a dynamical system. The pseudocode is faithful to the model exactly where it is
+unfaithful to computation.
+
+**The natural objection: surely it can still be simulated.** Nothing here is non-computable in
+principle. The dynamics are differential equations with thresholds, which computers integrate
+routinely. If "implement" means "numerically approximate a trajectory," computation suffices. This
+objection is correct as far as it goes — so the question is what happens when you try to act on it.
+
+**A first answer that is true but philosophical: the simulator occupies the vantage the model
+denies.** The model's content is that there is no global state — no component reads another's
+interior, no place holds the whole, holism is enacted and never encoded. But to compute the system
+you must hold every component's state in one memory and step them in one loop: the simulator *is* the
+forbidden global observer. To order the updates it needs a scheduler (a central order-giver) or a
+synchronous clock ticking all components together — the "command from above" that "causation
+circulates, command nowhere" denies. And it must *count* time as a variable, where the model insists
+time is *suffered* — read off the decay of stores, kept by forgetting. So a computed simulation gets
+the trajectory right and the ontology backwards. This is real, but on its own it can be waved away as
+metaphysics. The decisive answer is concrete.
+
+**The decisive answer: there is no one model to simulate — only a way of making models.** Compare two
+cases.
+
+Where simulation *works* — pricing a financial option. You have **one fixed model**: a stochastic
+equation with fixed parameters, the same rule on day 1 and day 200. You run 100,000 random price
+paths through that same equation. Each path differs, but all are **samples of one stationary object**
+— the fixed distribution the equation defines. Average the payoff over them and it **converges**:
+100,000 paths give a good estimate, 200,000 barely move it. It works because the paths are variations
+on a single system — noise around a stable structure. History matters *within* a path but never
+changes *the model*; every path runs the same equation. The model is one object; the paths are its
+samples.
+
+Where the same recipe breaks — this model. Take the four steps in turn. **(1) There is no one fixed
+model.** The equation is not the same on day 1 and day 200: night 1 rewrites it into a new equation,
+night 2 rewrites that. Each path runs a *different, self-modified* equation by day 10 — there is no
+fixed rule to sample from. **(2) The paths are not variations on one system; they are different
+systems.** In option pricing, two paths are the same stock behaving differently. Here, the path where
+synapse X won an early material competition and grew, and the path where its neighbour Y won instead,
+have *physically different structures* — different synapses exist. They are not two runs of one model
+but two different models a shared early history produced. **(3) There is no center to converge to.**
+The average final price is a real thing; the "average" of *X exists, Y pruned* and *Y exists, X
+pruned* is not a valid configuration — it is a blend of two incompatible circuits, corresponding to
+no possible state. **(4) More samples stabilize nothing.** More option paths tighten the estimate;
+more runs here yield *more distinct circuits*, never a better estimate of one, because there is
+nothing for them to estimate.
+
+In one line: in Monte Carlo, history varies *within* a fixed model, so samples estimate the model;
+here history *is* the model — each history builds a different system — so there is nothing the
+samples jointly estimate. That is the precise content of "there is no one model, only a way of making
+models." The pseudocode is not a model you sample; it is a *generator* of models, one per history,
+knowable only once the history is complete.
+
+**And Monte Carlo is not the only rescue that fails — every acceleration method fails, for the same
+reason.** Each general way to compute a system faster than living it out relies on some *stable
+invariant* to exploit, and this model, by construction, holds none.
+- *Closed-form solution* needs the future to be a computable function of **time**; here it is a
+  function of the whole **history** — no formula takes a path as input and skips it.
+- *Coarse-graining / renormalization* (physics' strongest tool, and tempting given the fast-day /
+  slow-night split) needs the fast variables to settle, at fixed slow parameters, to a **stationary
+  average** the slow dynamics can see. But the day's dynamics never settle history-independently —
+  *which patterns can fire* depends on structure built by every prior night — and the coupling is
+  bidirectional and same-order: the slow change *is made of* specific fast events (which pattern
+  replayed), not their average. Coarse-graining discards exactly the individuating detail the model
+  consolidates. The micro-detail here is the signal, not the noise.
+- *Dynamic programming / memoization* needs **state recurrence** to cache and reuse; irreversible
+  ratcheting (energy spent, structure pruned) means no configuration is ever revisited —
+  nothing repeats, so nothing can be cached.
+- *Surrogate / learned models* need **cross-history regularity** to generalize; the histories are
+  incommensurable individuals with no shared structure, so there is nothing to learn that is cheaper
+  than running the history.
+
+Every method needs one of: time-parametrizability, scale separation with stationary fast statistics,
+state recurrence, or cross-history regularity. This model has none — it is history-parametrized, its
+fast and slow are same-order coupled, it never recurs (irreversible ratchet), and its histories are
+incommensurable. The methods do not fail by bad luck; each needs the stable, reusable structure that
+"the specification is continuously rewritten by its own running" abolishes.
+
+**And here the exponential appears — not as the obstruction, but as its price.** Suppose you refuse
+all of the above and insist on simulating anyway. To simulate *is* to fix a structure: a simulation
+is a set of variables updated by fixed rules, and you cannot write the loop without committing to
+what the variables are. But the real structure changes every night. So you face a forced choice.
+Freeze *one* structure and you have committed to a single branch — one accidental history, a
+measure-zero sample of a thing that is not a distribution. Stay faithful while keeping a fixed
+substrate and you must instead carry *every* structure the system might occupy as an enumerated set —
+and that set multiplies each night, growing exponentially in the number of nights, of changing
+dimension, non-factorable. This exponential is not a property of the model; the model never
+enumerates, it simply becomes one structure. The exponential is the shadow the fluid, self-rewriting
+model casts on a fixed substrate — it arises *if and only if* you demand the stable structure that
+simulation requires. The need for stable structure is what converts self-rewriting into
+exponential enumeration; drop the demand and the exponential vanishes, leaving only a physics living
+one history.
+
+**Three concrete faces of the obstruction.** *The foreclosed synapse:* a synapse pruned on night 3
+is gone; a pattern that would have used it on night 50 breaks at that link and cannot replay, so its
+downstream components lose participation and drift toward pruning too — one cheap early pruning
+deterministically forecloses a family of patterns fifty nights later, and you cannot know night 50's
+structure without having run nights 3–49 in order. *The two histories that never reconcile:* run from
+the same start twice; because material is conserved and structure capped, X-growing starves Y, and by
+night 20 the runs have disjoint sets of synapses — not noisy versions of one answer but two
+incompatible circuits with no meaningful average. *No shortcut:* because each night's structural
+change feeds the next day's dynamics feeds the next night's change, with no scale separation to
+exploit and no recurrence to cache, the one honest trajectory must be computed night by night, in
+order, in full — it is its own shortest description. The only way to know the state at night N is to
+run all N nights.
+
+**Why this is one insight, not several.** The deep cause is that the model **abolishes the separation
+between program and data.** Structure (the equations) is built from the accumulated traces of
+behavior; behavior runs on structure. Night turns data into program; day turns program into data.
+There is no stable specification anywhere, because the specification is continuously rewritten by its
+own running — which is just "holism enacted, not encoded" and "no global state," seen over time. A
+computation *requires* the split: the program is, by definition, the stable part. A thing with no
+stable program cannot be captured by one.
+
+**What the physics does instead — and why the synapse is its own faithful implementation.** The
+physical synapse escapes all of this not by being non-computable but by never needing an invariant.
+It does not compute which structure obtains tomorrow; it *becomes* it, by undergoing its night. It
+realizes exactly one history in real time — the *real* one, not a sampled one — needing no global
+memory (each component holds only its own state), no scheduler (time sequences everything at once,
+everywhere, for free), no counted clock (its stores keep time by decaying). So the faithful
+implementation of this model is not a program but a *material*: something that, by its own
+constitution, undergoes these dynamics with locality, simultaneity, continuity, and suffered time,
+without a controller. You can compute *a* life — one honest history, in full, in order,
+incompressibly — but never *the* model, because there is no "the model": there is a rule that makes
+one model from each history, and the synapse is the matter that runs that rule by being it.
+
+*Two honest limits. This says faithful **acceleration** is impossible, not that useful
+**approximation** is — a coarse model can teach you things, it just would not be this model. And it
+holds for the model as specified (irreversible, non-recurring, individuating); whether real neural
+tissue is secretly more regular, with statistics one could exploit, is an open empirical question,
+not something these principles can foreclose.*
+
+**The same no-privileged-vantage principle has a second face, in description rather than simulation.**
+The first face is simulative: there is no fixed model, only histories. The second is descriptive:
+there is no privileged object, only *cuts*. Nothing in the system is a bounded, persisting object one
+could isolate and make the whole story — the synapse is part of a neuron, the neuron of an assembly,
+the assembly of an organ, with no top and no bottom, only nested aligning projects. To describe it at
+all, an observer must *choose a cut*: a boundary, a timescale, and a scope, treating what is inside as
+the object and everything larger and smaller as context appearing at the boundary. Every cut is
+partial by necessity; none is the whole, for the same reason no computation is the model — there is no
+privileged, bounded, stable thing to be the whole. This is orthogonal to the reductive default of
+classical physics, which cuts at *static object-boundaries* and explains by *cause and effect between
+persisting objects*. Here the objects are active alignments continuously re-achieved, not persisting
+substances; the cut is a chosen boundary × timescale × scope, not a given; and the relations that
+matter are *constitution across cuts* (parts constitute an object; a level constrains the one below,
+emerges into the one above), not efficient causation between objects at one level. Within a single cut
+at a single timescale, ordinary cause and effect still works (this release causes that response); it
+is the *objects of interest* — synapse, alignment, assembly — that live at the intersection of cuts,
+where between-object causation is not the operative relation. There are affinities here with the
+scale-relative parts of modern physics — the renormalization group, non-equilibrium thermodynamics,
+effective field theory, all of which make descriptions depend on the scale of the cut — but those do
+not *solve* this system (see the acceleration survey: they lack the invariants it refuses to hold);
+they only point in the right *direction*, toward descriptions that are cut-relative rather than
+absolute. The descriptive consequence — that each real object is an object-under-a-cut, partial by
+construction — is developed in the companion document on the unexpressed objects.
+
+Everything below is what this self-writing physics *is* (Part II) and how it works, category by
+category (Part III).
+
+---
+
+# PART II — The Unifying Principle
+
+Watch one presynaptic bouton for a day and a night. By day it releases neurotransmitter, restocks
+its vesicles so it can release again, and — in the quiet after a burst — stocks a trace that records
+how much this release mattered. By night it does the same three things at a slower tempo: it changes
+its structure, restocks the material to change again, and replays the release as a probe to measure
+whether the change is still warranted. Nothing supervises it. It reads only its own state and the
+signals that reach it. What we call the synapse, the neuron, the memory, the organism is nowhere
+inside the bouton — it is only the name we give to many such boutons, coupled.
+
+That is the whole model in one instance. Stated generally:
+
+> **There is only the local component and its one repeating act. Everything we call a system — the
+> synapse, the neuron, the assembly, the organism — is that act, multiplied and coupled, and
+> described from outside. The act has one shape (act, recover, prepare) run in two directions
+> (outward by day, inward by night), and the relations between components are set by what is scarce.
+> Holism is real, but it is enacted by the coupling, never encoded in any part.**
+
+This is why the model is a generator rather than a fixed object (Part I): because the specification
+is never encoded in any part but enacted by the running, it is rewritten by that running, so no fixed
+model exists — only the rule and the history.
+
+Every category in Part III is this principle, turned to face one question: *What is a component?*
+(locality), *What is its act?* (the ring), *What are its two directions?* (the two turnings), *At
+what speeds does it act?* (the ladder), *How do components relate?* (scarcity), *Who is in charge?*
+(causation — no one), and *By what operations is the local multiplied and coupled into a describable
+whole?* (the four operations). None adds a new assumption; each specializes the one above.
+
+A note on language. This document does not say "the system." There is no system — only local
+components, contextualized by their neighbors. Where the phrase appears, it is inside quotation
+marks, naming the thing we are denying: an actor that stands above the parts, holds the whole, and
+acts on it. No such actor exists here.
+
+---
+
+# PART III — What the Physics Is, and How It Works
+
+---
+
+## 1. Locality — The Only Thing That Exists Is a Local Component
+
+Everything the model contains is a local component: the bouton, the spine, the astrocytic process,
+the dendrite, the soma, the axon. The actors we call higher — neuron, astrocyte, organism — are not
+additional things. They are descriptions of many components' coupled activity, spoken from outside.
+This is the direct reading of the unifying principle, and the rest of the category is its mechanics.
+
+**A component reads only its own state and the signals that arrive.** It cannot read another
+component's interior, and it cannot read "the whole." When the bouton needs to know whether its
+release reached a responsive target, it does not inspect the spine; it waits for a retrograde signal
+the spine emitted. Coordination is never achieved by a component consulting a global state, because
+there is no global state to consult. It is achieved by signals crossing between components, each
+read locally and made to mean something by the local context that receives it.
+
+**Everything emits; nothing is a pure sink.** A component that only consumed would be invisible to
+the rest and could not participate in coordination. Even the leaves of the daytime chain — the
+bouton, the spine — emit: by day they emit fatigue upward and retrograde messages laterally; by
+night they emit freed material into the shared pool and demand upward. To exist in the model is to
+be readable, and to be readable is to emit.
+
+**Behavior is legible: acting leaves a readable mark, sent or not.** What a component emits is not
+always an intended message. Some emissions are *signals* — sent to be read (glutamate, the
+retrograde messages, D-serine). Others are *traces* — the physical residue of acting, read by
+others though never "sent": spillover glutamate is the consequence of a bouton releasing more than
+the cleft can clear, and that overrun is itself information about the bouton's power. There are no
+silent acts. Acting and informing are inseparable, because behavior displaces the shared medium and
+the displacement is readable. This is why coordination needs no broadcast of intent: a component
+that simply behaves is already legible to whoever shares its medium.
+
+**Meaning is assigned by the reader, not carried by the signal.** A signal is a physical fact — a
+molecule, a voltage, an overrun. It has no intrinsic meaning; its meaning is fixed by the local
+context that reads it. The same endocannabinoid is a *brake* to the bouton (reduce release) and a
+report of *postsynaptic excess* to the astrocytic process (a pressure cue for its own structural
+control). The same nitric oxide is *confirmation to strengthen* for the bouton and *this coincidence
+was real, keep the capacity* for the astrocyte. The same spillover is *lost transmitter* to no one
+and *my presynapse has outgrown my volume* to the astrocyte. One emission, many readers, many
+meanings — and none of the readers consults the others to agree on the meaning. This is the locality
+principle at the level of semantics: because no component can read another's interior, all it ever
+has is the shared physical facts, which it must interpret unilaterally. Coordination is achieved
+without shared meaning — each component reads the common medium and assigns its own.
+
+**Coupling is openness, and openness is bounded.** A component is open — it takes in signals and
+supply, gives out signals and product — but its openness is bounded by what it can physically
+reach: its own cleft, its own supply lines, the neighbors it is wired to. It is neither sealed (that
+would make coordination impossible) nor unbounded (that would make it the whole). The bounded
+openness is what lets many local components compose into something we can describe as a whole
+without any of them being that whole.
+
+**Holism is real but only described.** The re-evoked pattern at night, the neuron's total activity,
+the memory a synapse carries — these are real. But they are not stored anywhere. The pattern is not
+in any component; it is what happens when many primed components ignite each other. The neuron's
+"excitability" is not computed by anyone; it is the coincidence of many components' own lowered
+thresholds. Holism is enacted by the coupling and read off by us as observers — it is never encoded
+in a part, because if it were, that part would be the system, and there is no system.
+
+---
+
+## 2. The Ring — One Act in Three Phases
+
+The local component's act has one shape, and it is the same shape everywhere: **ACTION, RECOVERY,
+PREPARATION.** This is the specialization of the principle to the question *what is the act?*
+
+**The three phases.**
+- **ACTION** is the component's defining deed — the thing that makes it the component it is. The
+  bouton releases; the soma fires; the spine responds; the axon and dendrite propagate. Action is
+  the only phase that spends irreversibly and reaches outside the component.
+- **RECOVERY** is the fast alter-ego of action: it restores the capacity to act again. Vesicles
+  refill, sodium channels de-inactivate, calcium clears. Recovery undoes the local depletion the
+  action caused, so a next action is possible. It looks backward — it repairs what was just spent.
+- **PREPARATION** shapes what comes next. It faces two futures at once: the next action in this same
+  scope, and the action of the *other* scope. Setting the release machinery for the next spike is
+  preparation for this scope; stocking the tag that the night will spend is preparation for the
+  other. Preparation is provisioning, not judging — which is why the old "evaluation" phase was a
+  misnomer and has been retired. Depositing a trace does not render a verdict; it lays down a
+  provision that a later phase may or may not draw on. What we once called evaluation was always
+  preparation aimed at the other scope.
+
+**The rhythm is (ACTION ⇄ RECOVERY) × many, then PREPARATION — then again.** The act is not one pass
+through three phases. Action and recovery alternate rapidly — a tight inner loop, release-and-restock
+many times over — and only when that alternation subsides does preparation run, punctuating the
+bout and setting up the next. A spike train is exactly this: release ⇄ refill, release ⇄ refill,
+then, in the sustained quiet, the preparation that stocks the tag and tunes the next train. The
+inner loop is fast; preparation is the slower punctuation.
+
+**Every category spans all three timescales.** The three phases are not three speeds. Each phase is
+a kind of work — deed, restore-capacity, provision — and each kind happens fast, medium, and slow.
+Preparation especially is multi-timescale: it contains a fast loop (probe and restock), a medium
+adjustment (tuning the release machinery from the tag), and a slow settling. A category names *what
+kind* of work, never *how fast*.
+
+**Action is always local; recovery and preparation may be contextual.** A component necessarily has
+its own action — the deed just is the local event occurring in it, and it cannot be performed on
+another's behalf (that would be signalling, not acting). But the recovery and preparation of an
+action can live in other components. A calcium channel's action is letting calcium in; its
+recovery-and-preparation live in the presynapse and above. So the ring is a property of *coupled
+components*, not of the individual: **the ring must close — every action recovered from and prepared
+for — but no single component need run all three phases itself.** What is necessary is the closing
+of the ring, not its co-location.
+
+**The three categories are the three modulable dimensions of behavior — which is why the synapse has
+three parts.** Ask what about a behavior can be changed, and there are exactly three answers: *how
+hard* (intensity), *how soon again* (timing), and *where* (spatial extent — which connections exist,
+how isolated they are). These are not an arbitrary list; they are the three categories seen from
+outside. Intensity is the magnitude of the ACTION — a bigger release is a bigger deed. Timing is set
+by RECOVERY — how fast the capacity to act is restored *is* the temporal window and the readiness
+for the next deed. Space is set by PREPARATION — which structure is built or pruned is the
+configuration future action will run on. To modulate a dimension is to modulate the corresponding
+phase; there is nothing to change about a behavior except its three phases, so there are exactly
+three dimensions, in one-to-one correspondence.
+
+This is why the synapse is tripartite and not bipartite. Three separable dimensions want three
+independent controllers, and the parties divide them: the presynapse owns the clean intensity knob
+(how much it releases), the postsynapse owns sensitivity (how strongly it responds), and the
+astrocytic process owns timing and space (its clearance sets how fast transmitter is cleared —
+shorter dwell, sharper temporal window — and its coverage sets spillover and isolation). A
+two-party synapse could set intensity but could not independently sharpen timing or bound space;
+the third party exists precisely to control the dimensions the two coinciding parties cannot. In the
+category language, the astrocytic process is the *recovery-and-preparation* specialist of the synapse
+— it owns how-soon and where — while the pre and post are *action* specialists — they own how-hard.
+The tripartite structure and the three-phase act are therefore two expressions of one three-way
+partition: three phases of the deed, three dimensions of what can be changed, three parties to
+change them.
+
+The correspondence is not perfectly symmetric, and the asymmetry is instructive. Intensity and
+timing each have a *live* mode — they are modulated moment to moment by the action and the recovery —
+and also a *provisioned* mode, the persistent ceiling on them, set slowly. Space has no live mode: a
+connection cannot be added mid-behavior; spatial structure is inherently slow. So preparation owns
+space outright and also sets the ceilings for intensity and timing, while action and recovery hold
+the live knobs. This is why "evaluation" was never a fourth category — there is no fourth dimension
+for it to modulate. Behavior has three modulable dimensions; the act has three phases; a would-be
+fourth phase would have nothing to change, which is exactly why it collapsed into preparation.
+
+---
+
+## 3. The Two Turnings — Day and Night
+
+The one ring is turned in two directions. This specializes the principle to *what are the
+component's two scopes?* — and it is where the model's deepest duality lives.
+
+**Two contextualizations, two currencies.** By day the component faces outward, against the world
+(the cleft); its currency is information — cheap, gathered passively, and non-rival (see category 5).
+By night it faces inward, against the economy; its currency is material and energy — scarce,
+conserved, and rival. The component does not know it is in "day" or "night" as a global state; each
+turning simply runs against whatever environment is present, and the environment differs.
+
+**The rotation: the same physical event is a different phase in each scope.** This is the sharpest
+form of the duality. Neurotransmitter release is the day's ACTION — the outward deed. The *same
+release*, run at night, is PREPARATION: the component releases not to transmit but as a probe, to
+replay a behavior and measure how much it participates in the re-evoked pattern. And the structural
+change, which the day can only *mark* (the tag is an inert claim pointing at a restructuring that
+never happens by day), is the night's ACTION — its irreversible defining deed. So the defining act
+of one scope is the measuring-instrument of the other: release is day-action / night-preparation;
+restructuring is night-action / day-inert-mark. The scopes do not merely run the ring in two
+directions — they swap which event is the deed and which is the provisioning. Because it is a ring,
+each scope simply enters at a different phase.
+
+**Night PREPARATION replays the day ACTION — the same machinery.** Because preparation-at-night is a
+*replay* of the behavior, it runs the very code the day action runs: the same release, the same
+capacity and vesicle checks, the same endurance deposit into the *same* trace. Endurance discovered
+in replay is as real as endurance discovered in behaving. Only two things differ: there is no
+dopamine (significance is already settled), and the released transmitter is a probe — it carries the
+pattern onward to the next component and its own trace is read as participation. The action machinery
+is written once and serves as the deed by day and the measurement by night.
+
+**The tag is the payload that crosses between the turnings; the fatigue loop is the switch.** Each
+scope's PREPARATION mints what the other scope will consume. Day-preparation mints the tag — a
+token of confirmed significance — which the night spends on structure. Night-preparation measures
+participation, which gates that spending. The tag is one token with three roles: by day it is the
+significance bridge; at night it lowers the component's own threshold so its pattern can re-ignite,
+and it funds the build, a slice at a time. Distinct from this payload handoff is the *switch* — the
+fatigue loop that decides *when* a component crosses between scopes. Activity accrues fatigue; a
+single continuous integrator (the one actor that never sleeps) reads the aggregate fatigue and emits
+a pressure; when a component's own activity falls and pressure is high, it crosses into night; when
+pressure discharges, it crosses back. No scheduler; no clock. The switch says *when* to turn; the
+tag says *what* crosses when it turns. One ring, two turnings, stitched by the tag and switched by
+fatigue.
+
+**Two independent forgettings.** Because night ACTION is build ⇄ release (category 5), two distinct
+things can be lost, by two distinct mechanisms. *Structural pruning* sheds built structure a
+component no longer uses — driven by low participation, regardless of any tag it holds. *Intention
+decay* is the tag itself decaying unspent — a planned strengthening that never found the
+participation to license it. The tag is patient: it is sliced by building and never touched by
+releasing, so it survives across non-participating cycles and cashes in when its pattern finally
+re-evokes. Disuse prunes structure; unspent intention fades on its own slow clock. The two are
+independent, and both are forgetting.
+
+---
+
+## 4. The Timescale Ladder
+
+Orthogonal to the ring is the ladder of timescales. This specializes the principle to *at what
+speeds does the component act?* The ring says *what kind* of work; the ladder says *how fast*; they
+compose — every phase of the ring occurs at every rung of the ladder.
+
+**The rungs.** FAST (milliseconds to seconds): the immediate trace a single action leaves. MEDIUM
+(seconds to minutes): occupancy and evidence — the running average of fast traces, and the
+eligibility climbing toward a tag. SLOW (hours): the tag, the consolidation bridge. PERSISTENT
+(written only at night): the structural ceilings, and the two conserved stocks — energy, which does
+not return, and material, which does.
+
+**A tier's timescale is set by both its creation and its decay.** A fast trace is deposited as a
+point event and relaxes in milliseconds. A medium trace ramps while a condition holds and settles
+over minutes. The timescale is not a label attached to a variable; it is the joint consequence of
+how the variable is written and how it fades. This is why the same climb appears in every component:
+each action leaves a fast trace; the average of fast traces over seconds fills occupancy (short-term
+strength); the average of that average over minutes, gated by dopamine, raises the tag. Occupancy is
+the fast-and-medium memory of participation; the tag is its slow, validated distillate.
+
+**Evidence ascends the ladder; capacity descends it.** By day, information climbs from fast trace to
+tag — evidence accumulating upward. By night, capacity is written downward from the tag into
+persistent structure. Each rung also has its own failure meaning, set by its timescale: a fast pool
+running dry is transient depression; a medium pool constrained is a standing endurance need; a
+persistent ceiling reached is a structural limit. Depletion and recovery at each rung mirror the
+creation and decay of its trace — the same timescale governs both the evidence and the capacity at
+that level.
+
+---
+
+## 5. Scarcity Decides — Collaboration by Day, Competition by Night
+
+How components relate to one another is not an independent fact; it follows from what is scarce.
+This specializes the principle to *how do components relate?* — and it unifies conservation,
+selection, and the collaboration/competition character of the two scopes into one causal chain.
+
+**Two conserved currencies, two rules of flow.** Energy ratchets: it is spent irreversibly, the
+arrow of time in the model — a component that burns energy into structure cannot get it back.
+Material circulates: it is freed by one component and reclaimed by another, conserved as it moves.
+Scarcity of both forces choice — two ceilings (structure and endurance) compete for one finite
+night pool, and what is not maintained drifts back down.
+
+**Rivalry of the currency sets the relation.** By day the currency is information, which is
+*non-rival*: a bouton releasing glutamate does not use up the spine's ability to receive it; a trace
+here does not deplete a trace there. When producing for others costs nothing, the natural relation
+is **collaboration** — and the day is exactly that: each component acts so the next can act, releasing,
+integrating, clearing, passing activity along the chain, co-producing the pattern and the tags. By
+night the currency is material and energy, which are *rival and conserved*: every unit one component
+builds into its structure is a unit another cannot have, and the total is capped. When what one takes
+another loses, the natural relation is **competition** — and the night is exactly that: components
+contend for the shared pool, build what they win, and free what they shed back into contention.
+
+**But night's competition is adjudicated by collaboration.** The relation is subtler than "day
+collaborate, night compete." The replay that arbitrates the night's competition is itself a
+collaborative act: a pattern re-evokes only if every component along its loop is primed and ignites
+the next — mechanical coherence, a collaboration all the way around, one un-primed link breaking it.
+Participation — the measure that gates who gets to build — *is* a measure of successful collaboration
+in that re-enactment. So a component earns its share of the scarce material in proportion to how well
+it collaborated in replaying the pattern. Collaboration is primary in both scopes: by day it
+*produces* the shared, non-rival good; by night it *adjudicates* the competition for the rival one.
+The register is economic, not martial — components do not fight; they contend for a conserved
+resource, and the contention is settled fairly by a collaborative criterion.
+
+**Two competitions at two loci.** Within the night, competition appears twice, cleanly separated.
+*Within* a component, build and release contend over its own structure, arbitrated by participation:
+high participation builds (funded by the tag, a slice per cycle), low participation releases (freeing
+material, the tag untouched), and in between the component holds. *Between* components, this one and
+its peers contend for the shared material and energy during recovery. The internal tension (grow or
+shrink?) is settled by the replayed pattern; the external tension (can I get material?) is settled by
+contention with neighbors. Selection under scarcity is the sum of these: what survives a night has
+both earned its tag by day and won its material by night, and what neither participates nor is
+maintained returns to the pool. Selection is not a judge's verdict; it is what scarcity leaves
+standing.
+
+---
+
+## 6. Causation Circulates — Emergence Up, Constraint Down, Command Nowhere
+
+The final category specializes the principle to *who is in charge?* — and the answer is no one.
+Causation moves in two directions across the coupling, and neither is command.
+
+**Emergence ascends; constraint descends.** By day, evidence and activity emerge upward: components
+act locally, and their emitted activity is what a higher description (the neuron, the assembly) is
+*made of*. Nothing reaches down to make them act. By night, constraint descends: a higher actor
+broadcasts a bound — a renormalization target, a downscale factor — but it does not reach in. It
+emits a signal; each component reads that signal and scales *itself*. The neuron never edits a
+synapse; it announces a total, and the synapses each renormalize their own structure against it.
+
+**No actor authorizes its own restructuring.** A component cannot open its own night. It is *put in
+position* by the actor above — which holds an aggregate the component cannot see and opens a window
+the component cannot open — and then, within that window, the component acts locally on its own
+state. The soma cannot decide within the soma which of its synapses matter; the synapses decide that
+locally, by their own thresholds. And the synapses cannot ignite their pattern alone; the soma's
+firing does that. Each is put in position by the other; neither reads the other's interior. This is
+the recursive grant: act locally, be enabled hierarchically.
+
+**Command is nowhere.** There is no actor that both holds the whole and acts on it — that would be
+the system, and there is no system. What looks like top-down control is always a broadcast constraint
+scaled locally; what looks like bottom-up assembly is always local emission summed from outside. The
+neuron that "renormalizes" only announces a number. The assembly that "replays" is only coincident
+local thresholds propagating through coupling. Causation circulates — up as emergence, down as
+constraint — but it never concentrates into command. This is the unifying principle in its final
+form: because there is only the local component and its one act, there is no one to be in charge, and
+the whole is enacted by the parts, never encoded above them.
+
+---
+
+## 7. The Four Operations — How the Local Is Multiplied Into a Whole
+
+The six categories describe what a component is and does. This one is a different cut: it asks by
+what *operations* the local is coupled into something we can describe as a whole. There are four —
+integrate, coincide, broadcast, inject — and together they are the entire vocabulary by which scale
+is crossed. The previous category named the two *directions* of causation; this one names the
+*mechanisms*, and adds the two the directional view misses.
+
+**Integrate — make the distributed present.** A quantity spread over time or space has no
+instantaneous local existence. Flow is nowhere emitted; it is the accumulation of many releases
+across a duration. Frequency is not present at any instant — a single spike has no rate; rate lives
+only in the relation between events separated in time. Total activity is not held by any component;
+it is the sum over many. The system reads none of these directly — it *cannot*, because they are not
+anywhere. It reads them by **transducing the distributed into a store whose instantaneous level is
+the quantity's present shadow.** The fast trace is the device: each event deposits a quantum, the
+store leaks, and its standing level encodes recent frequency — high when deposits outran decay, low
+when they did not. Spatial integration does the same across space: the dendrite summing its spines,
+the soma summing its dendrites, the astrocyte summing its processes each make a spatially-distributed
+quantity locally present at one site. This is how a distributed system verifies what is expressed
+nowhere and by no one: it never reads the quantity, it reads the store the quantity filled. And it is
+how the whole "knows" what no part knows — not by computing, but by *being the place where the parts
+accumulate*.
+
+Time itself is read this way. The system has no clock; it does not count duration. Time enters only
+as the *decay* of stores — "how long ago" is how far a trace has fallen, "how fast" is how high it
+stands against its leak. Time is not represented; it is suffered, and the store's level is the
+readout. Every leaky store is a little clock that keeps time by forgetting rather than by counting.
+
+**Coincide — read several present-made stores at one site, and get an event.** Integration produces
+quantities; coincidence produces *events* — the meaningful happenings the components act on. And nothing
+significant is caused by a single signal: significance is always the co-occurrence of several. The
+postsynaptic calcium event requires glutamate and depolarization and the astrocytic gain together;
+the tag requires accumulated eligibility and validation together; the night's build requires a
+standing tag and confirmed participation together; the astrocytic spike requires many processes'
+calcium together. A coincidence is *two or more stores being high at the same instant* — which can
+only be read where all of them are present. So every coincidence needs a **meeting-site that owns
+none of the signals it compares**: the site where the transduced-present stores overlap. This is why
+the synapse is tripartite (the coincidence detector needs a third input neither coinciding party
+owns), and the pattern recurs at every level — each has its coincidence and its meeting-site.
+Integration makes the distributed present; coincidence reads several presences together. They are one
+mechanism in two steps: transduce, then compare.
+
+**Broadcast — distribute one state to many, without addresses.** The third operation sends a single
+state outward to a whole population at once: the back-propagating spike to all a soma's spines, the
+action potential to all its boutons, the renormalization to all a neuron's synapses, the priming
+field and the calcium spike to all an astrocyte's processes. Broadcast is the descending partner of
+integration, and like integration it is *addressless* — integration destroys location by summing
+(the sum does not say which input), broadcast destroys it by spraying (the signal does not select
+which target). Neither is a message from one component to another specific component; there is no
+addressed communication across scale, only summation up and spraying down. Crucially, almost every
+broadcast is **endogenous and reflective**: it carries a quantity integrated from the components' own
+locals and sends back down. The back-propagating spike carries "the soma fired," which is the
+integral of dendritic input, reflected to the spines. The renormalization carries the integrated
+total weight. These are top-down in delivery but bottom-up in origin — the components talking to themselves
+across scales, closing the loop that integration opened.
+
+**Inject — import the one thing that cannot be built from within.** Reward is different, and the
+difference is not its direction. It, too, descends as a broadcast, like the spike and the
+renormalization — so top-down delivery is not what sets it apart. What sets it apart is its *origin*:
+every other broadcast reflects a quantity assembled from the components' own activity, but no amount
+of integrating the components' own activity can produce whether the behavior was *good for the organism in
+its world*. That fact is exogenous — it comes from outside the components' own self-talk, from the
+organism's encounter with its environment. Reward is the single channel by which information that
+could not have been integrated from below enters the coupling at all. This is the precise sense in
+which it is the opposite of integration: not top-down versus bottom-up, but **exogenous versus
+endogenous** — a global that is *irreducible to* the locals, against a global that is *made of* them.
+And it is necessary, because significance is defined at the organism's scale: locality can compute
+what happened (activity, load, coincidence) but never whether it mattered, so that verdict must be
+injected. The tag is exactly the meeting-site where endogenous evidence (eligibility, built from
+local activity) coincides with this exogenous value — consolidation is the marriage of the components'
+self-knowledge to the world's verdict, and it is the one place the model reaches outside itself.
+
+So four operations, and they divide cleanly: integration makes *quantities* (by transducing the
+distributed into present stores, time included, as decay); coincidence makes *events* (by reading
+several such stores at a site that owns none of them); broadcast *distributes* (mostly the components'
+own integrated state, reflected back down, addresslessly); injection *imports* the one global —
+organism-in-world value — that no integration could produce. The first two build meaning from the
+inside; the third circulates it; the fourth admits the one thing meaning cannot be built from within.
+
+---
+
+## Coda — The Seven as One, and the Why Beneath Them
+
+Read downward, the seven categories are one principle refracted seven ways. A component is local
+(1); its act has one shape, the ring (2); the ring turns in two directions, day and night (3), at
+every rung of the timescale ladder (4); the relations between components are set by what is scarce,
+collaborative where the currency is free and competitive where it is conserved (5); causation
+circulates between components without ever concentrating into command (6); and the local is
+multiplied into a describable whole by four operations — integrate, coincide, broadcast, inject —
+none of which is a component reading another's interior (7). Remove any one and the principle loses a
+facet; none stands apart from it.
+
+And all seven serve the why of Part I. Each is a way the specification refuses to sit still in any
+part: locality forbids a global copy; the ring builds structure from behavior and behavior from
+structure; the two turnings make the night rewrite what the day runs; scarcity makes the rewriting
+irreversible and history-locked; causation-without-command leaves no controller to hold a fixed
+program; the four operations cross scale only by summing and spraying, never by encoding the whole
+anywhere. Together they are why there is no fixed model to run — only the rule and the history. There
+is only the local component and its one repeating act; everything else is that act, multiplied,
+coupled, and described from outside — and because it is only ever *enacted*, never *encoded*, it must
+be lived to be known.

elements/neuron/appunti/2026-07-08-limitations-traditional-simulation.md

@@ -0,0 +1,55 @@
+## First, name what you actually need
+
+The obstruction was specific: no global state, no scheduler, no counted time, and — the decisive one — *the structure rewrites itself, so there's no fixed program*. So a helpful physical framework must give you a substrate where (a) dynamics run without a central updater, (b) the parameters of the dynamics are themselves physical variables that evolve, and (c) time and simultaneity come for free. That's the spec. Now let's see what physics has.
+
+## 1. Analog / continuous-time physical computation (the most direct help, and real)
+
+The cleanest fit is the oldest idea: **don't simulate the dynamics, build a device whose native physics *is* the dynamics.** This is analog computation, and it's not a metaphor — it's a tradition.
+
+- **Neuromorphic hardware** (memristor crossbars, analog VLSI) is built exactly for this. A memristor's conductance *is* a physical synaptic weight that changes as a continuous function of the current through it — the structure variable is a material property, updated by the physics of the device, not by a CPU writing to memory. No scheduler: every device updates simultaneously and continuously because they're all just obeying their I-V physics at once. No counted clock: the dynamics evolve in real physical time. This directly answers (a) and (c), and *partially* (b) — the weights evolve physically.
+
+Where it helps: this genuinely removes the global state, the scheduler, and the counted clock. A memristor crossbar undergoing your day-dynamics is doing coincidence-detection and integration *as physics*, for free, in parallel, in real time. This is not speculative — it exists.
+
+Where it stops: standard neuromorphic hardware changes *weights*, but your model changes *structure* — it prunes and grows synapses, changing the *dimension* and *connectivity*, not just the values. Memristor arrays have fixed topology. So analog hardware solves the "no scheduler / no clock / continuous" problem but not yet the "self-rewriting dimension" problem. That's the frontier — and there is work on structurally reconfigurable and self-organizing neuromorphic substrates, but it's much less mature. So: real help, incomplete.
+
+## 2. Self-organizing / dissipative systems (help for the self-rewriting part)
+
+The part physics helps *most* with conceptually is the thing you found hardest: a system whose own structure is built by its own running. This is the domain of **non-equilibrium thermodynamics and dissipative structures** (Prigogine), and more broadly self-organization.
+
+The key idea you can borrow: **structure that is maintained by dissipation.** A dissipative structure (a convection cell, a chemical pattern, a flame) is not a fixed object — it is a *pattern held in place by a continuous flow of energy through the system*. Cut the flow and it vanishes. This is *exactly* your model's structure: coverage, active-zone capacity, receptor slots are all maintained by ongoing metabolic flow (energy that ratchets, material that circulates), and decay without maintenance. Your "structure builds where flow sustains it, releases where it doesn't" is a dissipative-structure principle almost verbatim.
+
+Why this helps: it tells you the self-rewriting isn't mysterious or unphysical — physics has a whole theory of *systems whose organization is a dynamic steady state of matter/energy flow, not a fixed configuration.* The equations of your model are the local rules; the structure is the emergent dissipative pattern. You don't implement the structure directly — you implement the *flows and the local rules*, and let the structure be what the flows sustain. That reframes your implementation problem: **don't try to represent the changing program; implement the flows whose sustained patterns *are* the program.** The structure stops being something you update and becomes something that persists only while used — which is what the model already says.
+
+Where it stops: dissipative-structure theory is strong on *pattern formation and maintenance* but weak on *the specific, addressed, memory-like structures* your model builds (this synapse, not that one). Convection cells are generic; your synapses are individuated by history. Bridging generic self-organization to individuated, history-dependent memory is not solved. So it gives you the right *category* of physics but not a ready equation.
+
+## 3. Field theory / continuum descriptions (help for "no global state, yet coordinated")
+
+Your worry about simultaneity and no-global-state is, in physics, the ordinary situation of a **field**. A field has no global controller — each point evolves by local rules (the field equations) reading only its immediate neighborhood, yet the whole exhibits coordinated, coherent behavior (waves, coherence, propagation) with no scheduler. Simultaneity is not imposed; it's what "the field at time t" means, and locality is built in (nothing propagates faster than the field's characteristic speed).
+
+Why this helps: it's a proof-of-concept that *"purely local rules, no global state, no controller, yet globally coordinated behavior"* is not only possible but is how most of physics already works. Your replay-coherence (a pattern carries only where every link is primed) is a *propagation* phenomenon — it's a field/excitable-medium concept. **Excitable media** (the theory behind waves in heart tissue, the Belousov-Zhabotinsky reaction, forest-fire models) are the precise physics of "a disturbance propagates only where the medium is primed, and dies at unprimed gaps." That is your night replay, exactly. So excitable-media math (reaction-diffusion, wave propagation in heterogeneous media) is a directly applicable tool for the coherence-is-mechanical claim.
+
+Where it stops: fields are usually *fixed-parameter* (the medium's properties don't change as the wave passes). Your medium rewrites itself. So you'd need an excitable medium *with plastic parameters* — reaction-diffusion where the diffusion constants and reaction rates are themselves slow dynamical variables driven by the fast activity. This exists in pockets (adaptive reaction-diffusion, self-modifying excitable media) but is not standard. Again: the right tool, needing an extension.
+
+## 4. The honest synthesis — what I think your implementation actually is
+
+Putting these together, here's the shape of an answer, and it's neither "just simulate it" nor "impossible":
+
+**Your model is a plastic excitable medium maintained as a dissipative structure, and its faithful implementation is a physical (analog) substrate with three coupled timescales of its own material dynamics.** Concretely, the implementation you're looking for is not a program but a specification of:
+
+- a **fast** excitable dynamics (the day: propagation, coincidence, integration) running on a medium,
+- whose **parameters are slow physical variables** (the structure) that evolve by their own dynamics (the night: build/release as a dissipative steady state of material flow),
+- **coupled** so that the fast activity drives the slow parameter change and vice versa,
+- realized on a substrate (analog/neuromorphic) where all of this is *material behavior in continuous time*, not represented state updated by a clock.
+
+The mathematics for this is **slow-fast coupled dynamical systems** (singular perturbation theory, adiabatic elimination) — the branch of dynamical-systems theory built precisely for "fast variables running on a landscape that slow variables reshape." That's the formal home of your day/night structure. It won't let you *escape* the exponential-branching intractability of *simulating* it — but it's the right language to *specify* it, and analog substrates are how you'd *instantiate* it without simulating.
+
+## The one caveat I owe you
+
+I want to be straight about the limit. None of this makes the *simulation* tractable — the exponential-branching argument stands. What physics offers is a different move: **stop trying to simulate, and instead specify-and-instantiate.** Slow-fast dynamical systems + excitable media + dissipative structures give you the *language to specify* the model as a physics; analog/neuromorphic substrates give you a way to *instantiate* it as matter that runs itself. The gap that remains — the genuinely unsolved part — is *structural* self-modification (changing dimension/topology, not just parameters) in a physical substrate. That's a real research frontier, not a solved problem. So you're not stuck, but the path is "build/specify a self-modifying analog dynamics," and the last mile (physical substrates that grow and prune their own topology) is open.
+
+Two directions to pursue depending on what you want:
+
+- If you want to **understand and specify**: slow-fast dynamical systems and excitable-media/reaction-diffusion are the math to write your model in — they'll turn the pseudocode into actual (continuous, local, controller-free) equations.
+- If you want to **instantiate**: neuromorphic/memristive analog computing is the substrate tradition, with structural plasticity as the open extension.
+
+Would it be useful if I took *one* component — say the astrosynapse, since it's the cleanest controller (spillover-error → coverage) — and tried to rewrite its day/night pseudocode as an actual slow-fast dynamical system (fast clearance dynamics, slow coverage as the drifting parameter, coupled)? That would be a concrete test of whether the "specify as physics" path actually works on this model, or whether something resists — and it's the honest way to find out if physics really helps here or just sounds like it should.

elements/neuron/appunti/2026-07-08-the-unexpressed-objects.md

@@ -0,0 +1,209 @@
+# The Unexpressed Objects — v1
+
+*The objects the mechanism implies but never expresses. The pseudocode has PRE, POST,
+ASTROSYNAPSE — three components, each running its own local loop. It has no `synapse`: no variable
+holds one, no line makes one act. Yet we speak of the synapse constantly. This document is about what
+kind of thing "the synapse" is, given that it is nowhere in the mechanism — and the answer, worked
+out below, is that an object is a name we lay over an aggregation of behaviours, each behaviour read
+at a chosen cut.*
+
+## The machinery — expression, cut, behaviours, and the name
+
+Three things, in a fixed relation:
+
+**The expression is possibility.** The components express the *possibility* of verifying behaviours
+in time, space, and quantity. Nowhere is a frequency, a flow, a duration expressed directly — only
+the latent possibility of reading them. Time, space, and quantity are never *in* the expression; they
+become readable only when we cut.
+
+**A cut is a choice of level.** To read anything, we choose a level on each axis — time (ms · sec ·
+min · hr), space (channel · synapse · branch · cell · territory), quantity (single quantum · occupancy
+· total) — plus a scope (day · night). The cut is the grain at which we verify; nothing more. It is
+what makes behaviours *actually* verifiable, out of the possibility the expression laid down.
+
+**Behaviours are what a cut lets us read.** Put the expression through a cut and you get behaviours —
+just behaviours, read at that level. This is the whole verification act:
+
+```
+expression → cut → behaviours
+```
+
+and it runs once per cut. The same expression, through a different cut, yields different behaviours.
+
+**An object is a name over a set of these results.** "The synapse" is not a step in the chain, not an
+input, not an output. It is the name we lay over a *collection* of chains —
+
+```
+  the synapse  =  name over  { expression→cut₁→behaviours A,
+                               expression→cut₂→behaviours B,
+                               expression→cut₃→behaviours C, ... }
+```
+
+— a grouping we perform across many cuts and label with one stable word. The object contributes
+nothing to what is read; behaviours are all there is on the mechanism's side. "Synapse" adds no
+behaviour and no verification — it adds only a grouping in our account. This is the cleanest form of
+*verified but not expressed*: the object is not even verified; **behaviours** are verified, at cuts,
+and the object is just the name over a chosen set of them. An object is therefore *not constituted by
+components* — it is not built out of parts. It is a name over behaviours. Dopamine, the retrograde
+messengers, the astrocytic spike, the shipment lines all enter the behaviours we call "the synapse";
+listing three "constituents" would draw a false boundary and reimport the classical picture (object =
+sum of parts) we are leaving behind.
+
+**Components are objects too — there is no privileged level.** It is tempting to think the *components*
+(PRE, POST, ASTROSYNAPSE) are the real objects and the synapse an emergent name over them. They are
+not. A component is itself only a name over the behaviours readable at the **finest grain** — "PRE" is
+the name over the ms-emission cut, the recovery cut, the tag cut, and so on, all read at the
+single-component space level. So "PRE" and "the synapse" and "the assembly" are the *same kind of
+thing* — names over collections of cut-behaviours — differing only in which cuts they gather (finer or
+coarser). None is the bedrock the others are built from. The only bedrock is the expression as
+possibility; everything above it, component included, is a name over cuts. The pseudocode's `pre_*`
+variables are not "PRE the object" — they are the possibility of cutting behaviours at the finest
+grain, which we name "PRE" for convenience.
+
+**The name is one; the cuts are many.** Because "synapse" names the collection, it stays fixed
+whichever cuts the collection gathers — synapse at ms, synapse at night, synapse as third party to
+pre and post. These are not different objects; they are the same name, read at different cuts. It is
+*always the synapse* — but always the synapse *at a cut*. The name gives stability (we can speak of
+one thing across contexts); the cut gives specificity (we know which of its behaviours are in view).
+Neither alone suffices: a name with no cut is vague (which behaviours?), a cut with no name is
+unanchored (behaviours of what?).
+
+## Orthogonal to classical reduction
+
+This runs perpendicular to the habit classical physics trained into us. The reductive default
+isolates a system at a **static object-boundary** — this mass, that charge, this cell — treats the
+object as a persisting thing with fixed identity, and explains behaviour by **cause and effect
+between such objects**: A strikes B, B moves. The object comes first and is real; behaviours are its
+properties; causation runs between objects.
+
+Here the order is inverted. **Behaviours come first** — read at cuts — and the object comes last, as
+a name over some of them. There is no privileged object, not because we must choose among many
+objects, but because objects were never on the mechanism's side at all: only behaviours are, and
+"object" is our bookkeeping. Ask "what is the neuron trying to achieve," and any answer is partial —
+the neuron is part of an assembly it cannot see, part of an organ, part of an organism, with no top
+where the question closes, and made of synapses and channels, with no bottom either. The question
+presumes a privileged object; there is none. This is the descriptive face of the model's founding
+principle (logic_principles, Part I): as there is no global state and no privileged actor *inside*
+the system, there is no privileged *object* from which to *describe* it. A name-over-cuts is to
+description what one history is to simulation — the only tractable thing, necessarily partial,
+honestly chosen.
+
+Two riders. First, ordinary cause and effect still holds *within a single cut* (at the ms synapse
+cut, this release causes that response); what has no clean analogue is cause/effect *between the
+named objects* — the synapse does not cause anything and is caused by nothing, because it is not a
+thing in the mechanism; it is a name over behaviours. Second,
+the useful cuts are not arbitrary: they fall at the **joints**, where the system's own coupling is
+denser inside than across (the behaviours we gather as one synapse couple more tightly to each other
+than to those of the next synapse). We prefer these because they carve where the coupling already is
+— but they remain cuts, still level-choices, still partial. There are affinities here with the
+scale-relative frontier of physics — the renormalization group, non-equilibrium thermodynamics —
+which also make description depend on the scale of the cut; but as the simulation argument showed,
+those point in the direction without solving this system. They tell us cut-relative description is
+legitimate physics; they do not hand us the object.
+
+*The pseudocode is itself the finest cut* — it reads behaviours at the single-component level and
+treats every larger whole as context arriving at the boundary (dopamine, the day/night context, the
+renormalization are the organism and the hypothalamus reduced to inputs). This document lays names
+over *coarser* collections of cuts in the same web.
+
+## How each object is written
+
+Given the machinery, each object below has one shape: **the name, then a series of `cut → behaviours`
+entries, then the note that the name is simply the collection.** The compound observables — a
+**frequency** (events per time), a **flow** (quantity per time), an **elapsed interval**, an **amount
+at a moment**, a **spatial extent**, a **coincidence** — are just behaviours read along one or more
+axes at a stated cut. Each entry names its cut (the levels on time, space, quantity, and the scope)
+and reads the behaviours that cut makes verifiable. The object is nothing over and above the set.
+
+---
+
+## Object 1 — The Synapse
+
+"The synapse" is a name over the behaviours read across the cuts below. Each cut names its levels —
+time, space, quantity, scope — and reads what becomes verifiable there. None of these is more "the
+synapse" than another; the word is the collection. Note in passing how much *one* observable, say
+frequency, fractures across cuts: frequency of what, at what grain, in which scope — each a different
+behaviour, all called "the synapse's."
+
+**Cut — ms · single-component space · per-quantum · day.** At the finest time grain, cutting the
+space at one component and the quantity at single events, the readable behaviours are the raw rates:
+the **frequency of NT emission** (PRE's release events, read as PRE's fast-trace level), the
+**frequency of channel opening** in POST (its fast trace), the **elapsed interval** since the last
+release (how far a trace has decayed), the **quantity** of a single release (occupancy × drive). Each
+is one component's behaviour; nothing joint yet.
+
+**Cut — ms · cleft space · concentration · day.** Widen the spatial level from one component to the
+cleft, keep time at ms. Now the readable behaviour is the **flow of NT out of the cleft** and its
+**persistence** — the dwell time, set by the astrosynapse's clearance. This is a behaviour no single
+component has; it lives at the cleft level, and the astrosynapse is where its shadow is held. "How
+long transmitter stays" is a synapse behaviour only at *this* cut.
+
+**Cut — ms · three-component space · joint · day (the third-party cut).** Cut the space to include
+all three components at once and read their *joint* behaviour. Now a new behaviour is verifiable that
+none of the previous cuts could reach: the **coincidence** — glutamate and depolarisation and
+D-serine present together — read at POST's NMDA, which holds none of the three inputs but is where
+their shadows overlap. At this cut the three axes have three owners (PRE: quantity; astrosynapse:
+timing and space; POST: recombination), so the coincidence reads as *how much, how sharply timed, how
+contained*. This is the cut at which "the synapse detects coincidence" is true — and it is true only
+here, because coincidence is a joint behaviour and only a three-component space cut makes it
+verifiable. (This is the tripartite decomposition of logic_principles §2, now located as one cut
+among the synapse's many.)
+
+**Cut — tens-to-hundreds of ms · three-component space · burst · day.** Coarsen the time level from
+single spikes to bursts. The readable behaviour is now **train-to-train alignment** — does PRE's
+*burst* fall in POST's depolarised *window* — and the **frequency of pre-post coincidence over a
+train**, not spike by spike. Short-term plasticity is the synapse's behaviour at this cut: the gain
+adjusting so the next burst lands better. Synchronisation here is over multiples of spikes; the
+single-spike cut could not see it.
+
+**Cut — minutes · three-component space · running average · day.** Coarsen time further. The
+behaviour is **participation** — is this synapse consistently in the co-active set — read as the
+occupancy and tag trajectories accumulating. "Is this synapse reliably aligned" is verifiable only at
+the minutes cut; below it there are only instantaneous events, no reliability.
+
+**Cut — overnight · three-component space · structural · night.** Switch scope to night and the time
+level to the consolidation cycle. The behaviours are **build ⇄ release of structure** — PRE's active
+zone, POST's receptor field, the astrosynapse's coverage — read against the tag and the replayed
+participation. "The synapse consolidates" or "is pruned" is a behaviour of this cut alone: the same
+name, now naming an overnight restructuring rather than a millisecond coincidence.
+
+**One cut worth dwelling on — the alignment reading (any of the day cuts, read as motion).** Read the
+day cuts not as snapshots but as a process, and a single compound behaviour appears across them: the
+synapse **aligning along three axes** — PRE and POST tuning the quantity match, the astrosynapse
+tuning the timing and space match — and doing so never bilaterally, since each party belongs to a
+larger whole (PRE's neuron, POST's neuron, the astrocyte's territory). At this reading the synapse
+verifies the *discovered compatibility of three larger rhythms* in when, how much, and where. And
+because alignment costs fuel, it carries two success-conditions at once — **precision** (did the
+alignment land: the strength tag) and **stamina** (could it be held: the endurance need) — the two
+consolidation pathways seen as the two dimensions of one project: be good at coincidence, for as long
+as it takes. This is not a different object; it is the day cuts read as a sustained project rather
+than a series of instants.
+
+**The name is the collection.** Synapse-at-ms, synapse-at-the-cleft, synapse-as-third-party,
+synapse-over-a-train, synapse-at-participation, synapse-at-night, synapse-as-alignment — these are
+not different objects, and none is the real one. They are one name laid over behaviours read at
+different cuts. It is always the synapse; it is always the synapse *at a cut*. What the word buys us
+is the ability to move between these cuts without losing the thread — to say "the synapse" and then
+choose, by the cut, which of its behaviours we mean.
+
+---
+
+## The queue — objects still to build
+
+- **The dendritic branch** (the name over cuts read at the branch's spatial grain, DEND). The
+  clearest spatial integrator: how behaviours read at branch-level space — the summed spine input —
+  become verifiable there; how attention (ACh) reweights that spatial read; what is readable at the
+  branch grain that no finer cut reaches.
+- **The neuron's decision** (the name over cuts read at the whole-cell grain, SOMA). Where the
+  neuron's own **frequency** (its firing rate) and **flow** (summed input) become verifiable; the
+  cut at which continuous integration reads out as a discrete event.
+- **The astrocytic territory** (the name over cuts read at the territory grain, ASTROCYTE).
+  Coincidence one scale up — synapse-synapse-synapse co-activity, not pre-post — readable at the
+  territory grain where the regenerative spike integrates local calcium and broadcasts it back.
+- **The pathway loop / assembly** (PRE→POST→DEND→SOMA→AXON→PRE). The largest unexpressed object: how
+  a recurrent loop verifies flow and timing around itself, and how the night's replay reads the whole
+  loop's coherence as mechanical all-or-nothing (every link primed or the pattern breaks). The
+  assembly is the object most purely unexpressed — it is nothing but the coincidence of many primed
+  thresholds.
+- **The rhythm** (cross-cutting). Frequency and phase as objects in their own right — what it means
+  for the system to verify and align to a rhythm (alpha, the day/night switch) that no component holds.

elements/neuron/appunti/old/2026-06-19-abstract-pattern-expression.md

@@ -1,187 +1,278 @@
 # The Abstract Pattern
 
-A component operates within two ceilings set by the previous NIGHT: a **structure** that bounds how strongly each behavior can act, and a **budget capacity** that bounds how much fuel the component can hold. Both ceilings bound an active, competitive DAY process — structure bounds how far behavior strength can be filled toward its maximum, budget capacity bounds how far fuel can be replenished toward its maximum — and in both cases the filling competes against other components for a shared resource. During DAY, in each context, the component executes behaviors that draw on budget and deposit fast traces. Two kinds of evidence accumulate: a **tag**, when a local eligibility signal coincides with non-local validation, driving *strength*; and an **endurance need**, when budget depletion interrupts a behavior on a successful trajectory, driving *endurance*. At NIGHT, tags raise structure and endurance needs raise budget capacity, both proportional to available material and energy, both drawing from the same finite pool, so that strength and endurance compete. What is not committed decays for lack of maintenance, and the resources freed partially fund what was.
+A component operates within two ceilings set by the previous NIGHT: a **structure** that
+bounds how strongly each behavior can act, and a **budget capacity** that bounds how much fuel
+it can hold. Both ceilings bound an active, competitive DAY process and are raised at NIGHT by
+two kinds of evidence — a **tag** (local eligibility coinciding with non-local validation,
+driving strength) and an **endurance need** (a *fuel* shortfall interrupting a locally
+successful trajectory, driving endurance). Strength and endurance draw on the same finite
+material and energy, so they compete; what is not committed decays for lack of maintenance,
+and the freed material partially funds what was.
+
+Everything a component does — in DAY and in NIGHT alike — is an instance of one grammar of
+seven functional groups. This is the common template. Components differ only in how they fill
+the groups, never in their structure.
 
 ---
 
-## DAY — The General Form
-
-Every DAY behavior runs within two ceilings and competes for two shared resources.
+## The Grammar
 
 ```
-given:   STRUCTURE         // bounds behavior strength (ceiling from NIGHT)
-         BUDGET_CEILING    // bounds fuel capacity (ceiling from NIGHT)
-in:      CONTEXT           // local or global triggering condition
-if:      BUDGET >= cost    // operational fuel available
-then:    behavior executes, strength bounded by STRUCTURE
-         BUDGET     -= cost
-         FAST_TRACE += f(behavior)               // local record deposited
-else:    behavior suppressed                     // fuel was the limit
-         if behavior was ON A SUCCESSFUL TRAJECTORY:
-             ENDURANCE_NEED += g(trajectory)      // fuel interrupted a forming success
+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
 ```
 
-Two competitive DAY processes fill the two ceilings:
+**TRACE absorbs evaluation.** Judging a behavior is always maintaining a trace — whether or
+not a trace is written — so the two evidence streams (strength, endurance) live inside TRACE
+alongside the fast-trace deposit. TRACE spans all timescales: the soma's inactivation,
+adaptation, and nuclear-calcium deposits are all TRACE, three records of one firing.
 
-**Strength filling (bounded by STRUCTURE).** Behavior strength rises toward the structural ceiling by competing for local occupancy resources — receptors at the postsynapse, vesicles at the presynapse. A behavior cannot act more strongly than its structure permits, because the occupancy it draws on is itself bounded by the structure.
+**BEHAVE and EMIT stay separate.** EMIT is the output half of the locality interface. RECEIVE
+and EMIT are the *only* boundary crossings; every other group is strictly local. Keeping EMIT
+named makes the boundary auditable — sometimes EMIT coincides with the behavior (presynaptic
+release, somatic firing), often it is a separable consequence (postsynaptic retrograde
+messages) or a different operation entirely (resource shipments).
 
-**Fuel replenishment (bounded by BUDGET_CEILING).** Fuel rises toward the budget ceiling by competing for shared upstream supply — astrocyte lactate, soma shipment. Each component's claim is the gap between its current budget and its ceiling; the shared supply is rationed by these claims:
+The grammar runs at two timescales. In **DAY** it operates on occupancy *within* the ceilings
+(fast traces, budgets, behaviors). In **NIGHT** it operates on the *ceilings themselves*
+(material, energy, structure, budget capacity). Same seven groups, two scopes — the
+capacity-versus-occupancy principle written into the shape of the process.
 
-```
-// competitive replenishment — the ceiling bounds the process via the demand
-c_demand          = BUDGET_CEILING - BUDGET           // gap below ceiling = claim on supply
-total_demand      = sum(c_demand for components on shared supply S)
-allocation_factor = min(1, S / (total_demand + ε))
-replenishment     = c_demand × allocation_factor      // rationed share
-BUDGET           += replenishment                      // never exceeds ceiling (demand was the gap)
-S                -= replenishment
-```
+**Every flow has a timescale.** Decay relaxes a quantity toward 0 over τ; creation and arrival
+relax it toward a target over τ — the same first-order operator, differing only in the target.
+A within-step write is the special case τ ≪ Δt. Rate-limited inflows (private refill, contested
+replenishment, flux × Δt) carry their τ implicitly; shipment carries an explicit transit delay,
+so distal targets receive later and more spread out than near ones.
 
-Neither ceiling is applied as a clamp. Each bounds its process from within: structure is the thing being filled with occupancy, budget_ceiling is the target the replenishment demand reaches toward. A high budget_ceiling is not free even during DAY — it makes a large standing claim on shared fuel, and the component reaches it only if the supply can satisfy that claim against competing claims.
-
-The fast trace drives two parallel processes; depletion drives a third.
-
-**Within the same context** — the fast trace biases the next execution of the same behavior. Short-term modulation. Local, no external signal.
-
-**Across contexts** — the fast trace accumulates into `possible_tagging` above the eligibility threshold. The bridge toward strength. Requires the trace to survive into a NOT/CONTINUOUS context.
-
-**On depletion** — when budget gates a behavior that was succeeding, `endurance_need` accumulates. The bridge toward endurance. Requires the depletion to have interrupted something valuable, not merely to have occurred.
+**Strict locality.** Every group uses only the component's own state and signals that have
+physically arrived. No component reads another's interior. All cross-compartment influence
+enters through RECEIVE and leaves through EMIT.
 
 ---
 
-### Tag Formation — Non-Local Coincidence (drives STRENGTH)
+## DAY — The Grammar on Occupancy
 
-Strength is associative. The tag requires local eligibility plus non-local validation, the number of coincidences set by the component's spatial scale.
+### RECEIVE — what arrived becomes local
+
+Resources arrive by three disciplines, each bounded by a ceiling through the *gap* it leaves,
+never by a post-hoc clamp:
 
-**PRE, DEND, SOMA, AXON, ASTRO — one non-local coincidence:**
 ```
-if FAST_TRACE > eligibility and dopamine > threshold:
-    TAG += dopamine × possible_tagging
+// CONTESTED supply (astrocyte lactate, arrived shipments) — rationed by competing demands
+demand = BUDGET_CEILING - BUDGET                       // the gap is the claim
+factor = min(1, S / (Σ demand on S + ε))
+BUDGET += demand × factor;  S -= demand × factor       // never exceeds the ceiling
+
+// PRIVATE reserve (own vesicle pool, own mitochondria) — uncontested, rate-limited
+POOL += min(rate, CEILING - POOL) × Δt
+
+// TRANSIT (shipment arriving from upstream) — delivered over a transport time
+BUDGET += transit(shipment_channel, τ_transport)       // fraction of in-flight cargo lands
 ```
 
-**POST — three coincidences (astrosynapse, soma, organism):**
+Signals arrive as channel reads — forward transmitter, the co-agonist gate, retrograde
+messengers, neuromodulatory broadcast — latched into a local copy while the channel decays. A
+high budget ceiling is not free even in DAY: it makes a large standing claim on contested
+supply, satisfiable only by out-competing neighbours.
+
+### TRACE — maintain the record hierarchy (and the two evidence streams)
+
+One group deposits and updates every trace, on every timescale.
+
+**Deposit** the fast trace from the behavior (and, for components with multi-timescale
+dynamics, the slower records too — soma inactivation and adaptation alongside nuclear calcium).
+Where a fast trace both *drives* and *records* a behavior (residual calcium at the presynapse),
+the deposit precedes ADJUST; elsewhere it follows BEHAVE.
+
+**Strength evidence (associative, needs dopamine).** A tag forms when local eligibility
+coincides with non-local validation; the number of coincidences set by the component's spatial
+scale.
+
 ```
-// 1. NOT_bAP: local Ca²⁺ + astrosynapse D-serine → CANDIDATE
-if FAST_TRACE > Ca_TAG_threshold and D-serine > threshold:
-    post_possible_tagging += FAST_TRACE
-// 2. bAP: CANDIDATE + soma fired → amplified above Ca_HIGH
-if post_possible_tagging > threshold and bAP arrives:
-    FAST_TRACE += bAP_boost
-// 3. any context: CANDIDATE + dopamine → STABLE
-if post_possible_tagging > threshold and dopamine > threshold:
-    TAG += dopamine × post_possible_tagging
+// most components — one non-local coincidence
+if FAST_TRACE > elig and dopamine > dop_thr:
+    TAG += dopamine × possible_tag
+
+// POST — three coincidences (astrosynapse gate, soma bAP, organism dopamine)
+if FAST_TRACE > Ca_TAG and astro_Dserine > thr: possible_tag += FAST_TRACE   // CANDIDATE
+if possible_tag > thr and bAP arrives:          FAST_TRACE  += bAP_boost      // confirm
+if possible_tag > thr and dopamine > dop_thr:   TAG         += dopamine × possible_tag  // STABLE
 ```
 
+**Endurance evidence (homeostatic, no dopamine).** A need forms only when a **fuel** shortfall
+interrupts a *locally* successful trajectory. The success proxy is the component's own state,
+amplified by a retrograde signal *only where one actually arrives*.
+
+```
+if BUDGET < cost and LOCAL_SUCCESS_PROXY > traj_thr:
+    ENDURANCE_NEED += LOCAL_SUCCESS_PROXY × (1 + arrived_feedback)   // feedback only if it arrived
+```
+
+Local proxies (own-state): PRE — own strong release (amplified by retrograde NO that POST
+emitted, the one component with arrived feedback); POST — own calcium climbing toward the tag;
+DEND — own branch strongly active when propagation fell short; SOMA — own nuclear calcium
+approaching CREB; AXON — own strong propagation load; ASTRO — own high clearance demand when
+synthesis ran short of budget. Same shape everywhere — fuel ran out at the verge of the
+component's *own* success — only the proxy differs.
+
+### ADJUST — set the operating parameters
+
+From structure (the ceiling), the current traces, and arrived modulators, compute the
+parameters that govern this step's behavior:
+
+```
+parameter = f(STRUCTURE, FAST_TRACE, modulators, arrived_signals)
+```
+
+PRE — release drive from residual calcium and the received DSE brake; POST — AMPA drive from
+arrived glutamate; SOMA — firing threshold from baseline × adaptation × neuromodulators, plus
+the refractory gate; AXON — propagation reliability from structure minus load-driven failure;
+ASTRO — lactate-allocation weights across the territory. ADJUST is where the NIGHT-built ceiling
+silently shapes the moment: the same structure that bounds the maximum also tunes the transfer
+function.
+
+### BEHAVE — the defining action, within both ceilings, with two failure modes
+
+```
+if BUDGET < cost:
+    suppress behavior
+    // FUEL shortfall → endurance evidence (handled in TRACE, if the trajectory was succeeding)
+else if OCCUPANCY/STRUCTURE exhausted:        // pool empty, surface already at ceiling, refractory
+    suppress behavior
+    // → short-term depression, or a structural/timing limit — NOT endurance (more fuel wouldn't help)
+else:
+    behavior executes, strength bounded by STRUCTURE;  BUDGET -= cost
+```
+
+The two failure modes are kept distinct because they point to two different ceilings. A *fuel*
+shortfall is endurance evidence — more budget capacity would have let the behavior proceed. An
+*occupancy* shortfall (empty vesicle pool, surface saturated, refractory soma) is short-term
+depression or a structural limit — endurance cannot fix it; it is a consequence to be allowed.
+Conflating them would build the wrong capacity. Behavior fills occupancy toward the structural
+ceiling; when the driving trace decays, occupancy passively drifts back — short-term depression
+is the *absence* of drive, never a signalled act.
+
+### EMIT — send signals and resources outward
+
+The component writes its outputs into shared channels: the forward transmitter into the cleft,
+retrograde messages back, integrated voltage onward, and shipments into transit toward
+downstream pools (rationed by the downstream component's propagated demand, delivered over
+τ_transport). EMIT and RECEIVE are the only boundary crossings; together they make
+locally-computing components into a communicating whole.
+
+### RECOVER — refill private pools
+
+Pools consumed by behaving are refilled from the component's own reserve toward their ceiling,
+rate-limited and budget-costed (the presynaptic RRP from the reserve vesicle pool; the soma's
+budget from its own mitochondria). Private recovery grants a component autonomy that contested
+supply does not.
+
+### DECAY — let the windows close
+
+```
+FAST_TRACE     *= decay(τ_fast)      // ms–s   — closes the eligibility window
+possible_tag   *= decay(τ_mid)       // s–min  — closes the tagging window
+ENDURANCE_NEED *= decay(τ_mid)       // s–min  — closes the endurance window
+TAG            *= decay(τ_slow)      // hours  — closes the commitment window
+arrived channels *= decay            // received signals fade
+```
+
+Decay is the passive relaxation that enforces every time window without a clock: a coincidence
+must complete, and a fuel shortfall must interrupt a success, while the relevant trace is still
+elevated. Timing is the competition between accumulation and decay.
+
 ---
 
-### Endurance Formation — Interrupted Success (drives ENDURANCE)
+## NIGHT — The Same Grammar on Ceilings
 
-Endurance is homeostatic, not associative. It requires depletion plus a successful trajectory, the meaning of "successful" set by the component's local function. **No dopamine.**
+NIGHT runs once per cycle and applies the identical grammar to the slow variables.
+
+**RECEIVE** — overnight production at the roots (astrocyte glycolysis, soma CREB synthesis,
+soma mitochondria), capped externally by the vascular supply and gated by `soma_tag`.
+
+**TRACE + ADJUST** — read the accumulated tags and endurance needs; compute the commit weights
+(the coherence bonus when pre, post and astro tags align; the tag-weighted shares for
+distributing material and energy to competing astrosynapses, spines, and boutons).
+
+**EMIT** — distribute produced material and energy down the supply chains, into transit
+(soma → branch/axon → spine/bouton; astrocyte body → astrosynapses).
+
+**BEHAVE** — the two commits, drawing on the same finite pool so they compete:
 
 ```
-if BUDGET < cost and trajectory_was_succeeding:
-    ENDURANCE_NEED += g(trajectory)    // graded by closeness to success
+// STRENGTH — driven by tag (validated coincidence)
+if TAG > tag_expiry:
+    Δ = min(slot_cost, MATERIAL, ENERGY × f)
+    STRUCTURE += Δ × coherence;  MATERIAL -= Δ;  ENERGY -= Δ × assembly_cost
+
+// ENDURANCE — driven by endurance need (interrupted success); no dopamine, no coherence
+if ENDURANCE_NEED > endur_thr:
+    Δ = min(cap_cost, MATERIAL × f, ENERGY × f)
+    BUDGET_CEILING += Δ;  MATERIAL -= Δ;  ENERGY -= Δ × biogenesis_cost
 ```
 
-Per-component definition of *succeeding*:
-- **PRE** — release was driving rising postsynaptic engagement
-- **POST** — calcium was climbing toward the tagging threshold
-- **DEND** — active spines existed distal to where propagation died
-- **SOMA** — nuclear calcium was approaching CREB, or firing was recruiting downstream
-- **AXON** — propagation failed to engaged boutons, not idle ones
-- **ASTRO** — the postsynapse was depolarized and waiting for D-serine when synthesis ran out
+A component both significant and fuel-limited demands both commits and is the strongest
+claimant on the pool, potentially forcing decay elsewhere.
 
-The signal shape is identical everywhere — fuel ran out at the verge of a valuable outcome — only the local definition of "verge" varies.
-
----
-
-### Trace Recession — The Temporal Behavior
-
-In every NOT/CONTINUOUS context, all traces decay:
+**RECOVER + DECAY** — both ceilings decay by neglect; maintenance from the remaining pool
+resists decay only where sufficient. What shrinks returns its **material** (not its energy) to
+the pool, partially funding the commits above:
 
 ```
-FAST_TRACE       *= decay(τ_fast)      // ms–s   — closes eligibility window
-possible_tagging *= decay(τ_mid)       // s–min  — closes tagging window
-ENDURANCE_NEED   *= decay(τ_mid)       // s–min  — closes endurance window
-TAG              *= decay(τ_slow)      // hours  — closes commitment window
+STRUCTURE      -= decay_rate × Δt;          STRUCTURE      += min(maint, maint_cost)
+BUDGET_CEILING -= capacity_decay_rate × Δt; BUDGET_CEILING += min(cap_maint, cap_cost)
+// shortfall → depotentiation by neglect (structure) / mitophagy of idle capacity (budget)
+MATERIAL += shrinkage × recycle             // energy is gone — not recoverable
 ```
 
-Decay is not a separate behavior — it is the passive consequence of molecular processes. It enforces time windows without any clock: a coincidence must complete, and a depletion must interrupt a success, while the relevant trace is still elevated. Timing is the competition between accumulation and decay.
-
----
-
-## NIGHT — The General Form
-
-NIGHT raises two ceilings from two kinds of evidence, both drawing on the same finite material and energy.
-
-**Strength commit — driven by tag (validated coincidence):**
-```
-if TAG > threshold:
-    Δstructure = min(expansion_cost, MATERIAL, ENERGY × fraction)
-    STRUCTURE += Δstructure × coherence_bonus    // raises the strength ceiling
-    MATERIAL  -= Δstructure                       // RECOVERABLE
-    ENERGY    -= Δstructure × ATP_cost             // NOT recoverable
-```
-Coherence bonus when pre, post, and astro tags are all set together — the three synaptic components independently gathered evidence for the same change.
-
-**Endurance commit — driven by endurance need (interrupted success):**
-```
-if ENDURANCE_NEED > threshold:
-    Δcap = min(capacity_cost, MATERIAL, ENERGY × fraction)
-    BUDGET_CEILING += Δcap                         // raises the endurance ceiling
-    MATERIAL       -= Δcap                          // RECOVERABLE (mitochondria recyclable)
-    ENERGY         -= Δcap × biogenesis_cost         // NOT recoverable
-// no coherence bonus, no dopamine — endurance is per-component homeostatic
-```
-
-The two commits compete for the same material and energy: building endurance somewhere cannot strengthen elsewhere. A component both significant and fuel-limited demands both and is the strongest claimant, potentially forcing decay elsewhere.
-
-**What is not committed decays — by neglect, for both ceilings:**
-```
-STRUCTURE      -= decay_rate × Δt_night
-STRUCTURE      += min(structure_maintenance, maintenance_cost)
-BUDGET_CEILING -= capacity_decay_rate × Δt_night
-BUDGET_CEILING += min(capacity_maintenance, capacity_cost)
-// if maintenance < decay: the ceiling drifts down
-//   structure → depotentiation by neglect
-//   budget_ceiling → loss of endurance (mitophagy of idle capacity)
-// recovered material partially funds the commits above
-```
+**DECAY (clear)** — fast traces, possible tags, endurance needs, and the soma timing traces
+reset; tags below expiry clear, above-expiry tags carry forward for multi-night consolidation;
+structure and budget capacity persist as the ceilings the next DAY will operate within.
 
 ---
 
 ## The Pattern in One View
 
 ```
-TWO CEILINGS, each bounding a competitive DAY process and raised by NIGHT evidence:
+ONE GRAMMAR, SEVEN GROUPS, TWO TIMESCALES
 
-  STRUCTURE (strength)         bounds behavior strength;
-                               filled in DAY by competing for occupancy;
-                               raised in NIGHT by TAG (validated coincidence)
+  RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY
 
-  BUDGET_CEILING (endurance)   bounds fuel capacity;
-                               filled in DAY by competing for shared supply;
-                               raised in NIGHT by ENDURANCE_NEED (interrupted success)
+DAY    runs the grammar on OCCUPANCY within two ceilings:
+         STRUCTURE (strength)        filled by competing for occupancy
+         BUDGET_CEILING (endurance)  filled by competing for shared fuel
+       TRACE yields two evidence streams from local state + arrived signals:
+         fast_trace + dopamine coincidence       → TAG            (strength)
+         FUEL shortfall + interrupted LOCAL success → ENDURANCE_NEED (endurance)
+       OCCUPANCY/structure/timing shortfalls → short-term depression (NOT endurance)
 
-DAY   behavior runs within both ceilings, both filled competitively
-      consumes budget, deposits fast trace
-      fast trace + non-local coincidence → TAG            (evidence for strength)
-      depletion + interrupted success    → ENDURANCE_NEED  (evidence for endurance)
-      traces decay in NOT/CONTINUOUS contexts — windows close
+NIGHT  runs the SAME grammar on the CEILINGS:
+         TAG            → raise STRUCTURE        (per-event power)
+         ENDURANCE_NEED → raise BUDGET_CEILING   (sustainable duration)
+       both draw the SAME material + energy → strength and endurance compete
+       unmaintained ceilings decay → recovered material funds the rest
 
-NIGHT TAG            → raise STRUCTURE       (per-event power)
-      ENDURANCE_NEED → raise BUDGET_CEILING  (sustainable duration)
-      both draw the SAME material + energy → strength and endurance compete
-      unmaintained ceilings of either kind decay → freed material funds the rest
+FLOWS  every flow has a timescale: decay → 0 over τ, arrival → target over τ;
+       shipment is transit-delayed; rate-limited inflows carry τ implicitly.
 
-A high ceiling of either kind is never free: structure must be filled by winning
-occupancy, budget capacity must be filled by winning shared fuel — both against
-competing components, every DAY. The system invests STRENGTH where a valuable
-coincidence completed and was validated, and ENDURANCE where fuel — not structure,
-not significance — was what stood between activity and success. To be both effective
-and sustainable, a connection must win on both, at both timescales, against all
-others drawing from the same finite pools.
+LOCAL  every group uses only own state + arrived signals;
+       RECEIVE and EMIT are the only boundary crossings.
+
+A high ceiling of either kind is never free: structure must be filled by winning occupancy,
+budget capacity by winning shared fuel — both against competing components, every DAY. The
+system invests STRENGTH where a validated coincidence completed, and ENDURANCE where fuel —
+not structure, not significance — was what stood between a component's own activity and its
+own success. To be both effective and sustainable, a connection must win on both, at both
+timescales, against all others drawing from the same finite pools.
 ```
+
+
 # More details
 
 ## SOMA

elements/neuron/appunti/old/2026-06-19-biological-reference-v10.md

@@ -274,3 +274,60 @@ The distinction matters biologically: a private reserve guarantees a component s
 (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.

elements/neuron/appunti/old/2026-06-19-tripartite-synapse_v10.md

@@ -30,6 +30,13 @@ NIGHT variables
 LOCALITY RULE
   every evaluation uses only local state + signals that have arrived.
   no component reads another compartment's internal state.
+
+CLEFT MESSAGE CHANNELS (the only PRE/POST/ASTRO interaction — each writes, others read)
+  glutamate     PRE → POST, ASTRO     (forward transmitter; cleared by ASTRO)
+  astro_Dserine ASTRO → POST          (NMDA co-agonist gate)
+  retro_NO      POST → PRE  (+)       (NO/BDNF: "release reached a responsive target")
+  retro_eCB     POST → PRE  (−)       (endocannabinoid: "over-driven, suppress release" = DSE)
+  Each channel decays/clears; a component reads a channel into a local copy and computes locally.
 ```
 
 ---
@@ -46,7 +53,7 @@ sat(x, K) = x / (K + x)
 
 ```
 K_release  K_AMPA  K_Dserine
-Mg_eject   Ca_STP   Ca_TAG
+Mg_eject   Ca_STP   Ca_TAG   eCB_thr
 elig       dop_thr  tag_thr  tag_expiry
 traj_thr   endur_thr
 spillover  inactivation  overload
@@ -96,29 +103,81 @@ that neighbours compete for.
 ## PRE
 
 ```
+// ─── PRESYNAPSE EXTERNAL INTERFACE ────────────────────────────────────────
+// PRE computes locally. Everything below crosses its boundary as a signal it
+// emits or a resource/signal it receives. It never reads another component's state.
+//
+// OUTPUT (PRE writes; others read)
+//   glutamate          → POST, ASTRO    forward transmitter; ASTRO clears it
+//
+// RESOURCES IN (others write; PRE reads in NOT_AP)
+//   astro_lactate[syn] ← ASTRO          primary fast fuel  → pre_budget
+//   axon_ship_pre      ← AXON           secondary fuel     → pre_budget
+//                                        ship(axon_budget → pre_budget, gap_to(pre))
+//   pre_material       ← AXON  (NIGHT)  AZ proteins (RIM, Munc13, VGCC subunits)
+//   pre_energy         ← SOMA  (NIGHT)  assembly ATP for active-zone construction
+//
+// BACKWARD MESSAGES IN (POST writes from its own state; PRE reads)
+//   retro_NO  (+)      ← POST           "release reached a responsive target" → endurance
+//   retro_eCB (−)      ← POST           DSE: "over-driven, release less"      → brake
+//
+// CLEFT SELF-FEEDBACK (PRE reads the channel it writes)
+//   glutamate          ← cleft          spillover autoreceptor brake (mGluR2/3 on PRE)
+//
+// ORGANISM BROADCAST IN (external; arrives as a local level)
+//   dopamine           ← VTA            gates pre_tag (the non-local coincidence)
+//   NE, ACh            ← LC, basal      excitability/threshold context
+//
+// OWN STRUCTURE (written NIGHT, read DAY)
+//   pre_structure      slot_ceiling, VGCC_coupling, refill_ceiling
+//   pre_budget_ceiling endurance ceiling (bounds replenishment)
+//
+// EMERGENCY
+//   shockwave_lockdown ← ASTRO          global Ca²⁺ wave overrides PRE
+// ──────────────────────────────────────────────────────────────────────────
+
 DAY | AP:
+    // SENSE — deposit fast trace (residual Ca²⁺ from this spike; also drives release)
+    pre_fast_trace += spike_Ca(input_freq)
+
+    // BEHAVE — release, or fail if depleted
     if pre_budget < release_cost:
         suppress(NT_flux)
-        if pre_fast_trace > traj_thr:                    // LOCAL success: I released strongly
-            pre_endurance_need += pre_fast_trace × (1 + retrograde_local)
+        // 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
-    pre_fast_trace += spike_Ca(input_freq);  pre_fast_trace *= decay(100ms)
-    drive = sat(pre_fast_trace, K_release)
+    drive = sat(pre_fast_trace, K_release) × (1 - retro_eCB_local)   // received DSE brake
     if RRP > 0:
-        NT_flux   = RRP × drive
-        glutamate += NT_flux·Δt;  RRP -= NT_flux·Δt;  pre_budget -= NT_flux·fusion_cost
-    fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
-    if glutamate > spillover: drive *= brake             // output brake (not a fill)
+        NT_flux = RRP × drive
+        // EMIT — glutamate into cleft (read by POST, ASTRO)
+        glutamate += NT_flux·Δt
+        RRP -= NT_flux·Δt;  pre_budget -= NT_flux·fusion_cost
+    if glutamate > spillover: drive *= brake             // own-cleft autoreceptor brake
+    // no RECOVER here — RRP refills in NOT_AP; high-frequency firing depletes
+    // faster than it recovers → short-term depression deepens
 
 DAY | NOT_AP:
-    pre_fast_trace *= decay(100ms);  pre_endurance_need *= decay(min)
-    refill(pre from astro_lactate[syn] + axon_ship_pre)  // contested: lactate + shipment
+    // RECEIVE — latch arrived backward messages; replenish budget (contested supply)
+    retro_NO_local  = retro_NO
+    retro_eCB_local = retro_eCB
+    refill(pre from astro_lactate[syn] + axon_ship_pre)
+
+    // RECOVER — refill RRP from private reserve toward its ceiling
     fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
+
+    // EVALUATE (strength) — eligibility → possible_tag → tag (needs dopamine)
     if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace
-    pre_possible_tag *= decay(s);  dopamine *= decay(ms)
     if dopamine > dop_thr and pre_possible_tag > tag_thr:
         pre_tag += dopamine × pre_possible_tag
-    pre_tag *= decay(hr)
+
+    // DECAY — all traces and channels recede, closing their windows
+    pre_fast_trace     *= decay(100ms)
+    pre_possible_tag   *= decay(s)
+    pre_endurance_need *= decay(min)
+    pre_tag            *= decay(hr)
+    dopamine           *= decay(ms)                      // broadcast transient fades
+    retro_NO *= decay(s);  retro_eCB *= decay(s)         // backward channels clear
 ```
 
 ---
@@ -137,6 +196,13 @@ DAY | NOT_bAP:
     // SOURCE 2 — NMDA: large Ca if local coincidence
     if Vm > Mg_eject and astro_Dserine > thr and glutamate > 0:
         post_fast_trace += NMDA_Ca(glutamate)·rise_speed();  post_budget -= NMDA_cost
+        retro_NO += NO_emit(post_fast_trace);  post_budget -= NO_synth_cost
+        // POST → PRE (+): nNOS coupled to NMDA emits NO/BDNF — "your release was effective"
+
+    // backward brake to PRE (−): strong depolarization → endocannabinoid (DSE)
+    if Vm > eCB_thr:
+        retro_eCB += eCB_emit(Vm);  post_budget -= eCB_synth_cost
+        // POST → PRE (−): "I am over-driven — reduce release"
 
     post_fast_trace *= decay(ms)
 

elements/neuron/appunti/old/2026-06-21-biological-reference_v11.md

@@ -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.
+```

elements/neuron/appunti/old/2026-06-21-tripartite-synapse_v11.md

@@ -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.
+```

elements/neuron/appunti/old/2026-06-22-tripartite-synapse_v13.md

@@ -0,0 +1,535 @@
+# 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
+
+The presynaptic bouton releases neurotransmitter and gathers evidence about whether that
+release was worth strengthening and worth sustaining. Its behavior unfolds across two DAY
+contexts and the NIGHT scope.
+
+**During DAY, during AP — the bouton releases neurotransmitter.** The amount released depends on
+residual **calcium** from recent spikes (the fast trace, setting the drive), the current
+**VGCC coupling occupancy** (how tightly calcium channels are coupled to docking slots right
+now — filled short-term, bounded by structure), the two **retrograde messages** from the
+postsynapse (`retro_eCB` brakes the drive; `retro_NO` will confirm release reached a responsive
+target), and the availability of both **fuel and vesicles**. Two shortfalls are read
+differently: a fuel shortfall on a succeeding release is evidence the bouton needs more
+*endurance*; an empty pool with fuel to spare is ordinary short-term depression.
+
+**During DAY, during NOT_AP — the bouton consolidates, potentiates short-term, and recovers.**
+With no spike to release, it latches the retrograde messages (RECEIVE); maintains its traces —
+accumulating eligibility toward a dopamine-gated tag (TRACE); transiently tightens its VGCC
+coupling from accumulated eligibility, with no dopamine, a reversible short-term potentiation
+bounded by the structural ceiling (BEHAVE); refills both its budget (contested supply) and its
+vesicle pool (private reserve) (RECOVER); and lets its traces decay, closing the windows (DECAY).
+
+**During NIGHT — the bouton's ceilings are rewritten.** NIGHT raises the bouton's **structure**
+(active-zone capacity, including the VGCC-coupling ceiling) where a validated tag accumulated,
+and its **budget capacity** (mitochondrial endurance) where fuel repeatedly interrupted a
+succeeding release. Both draw on the same finite material and energy shipped down the axon, so
+the two kinds of growth compete — and whatever is not maintained drifts back down.
+
+```
+// PARAMETERS  K_release · release_cost · fusion_cost · vatpase_cost · spillover · brake
+//             stp_thr · coupling_gain · coupling_drift · VGCC_baseline
+// INTERFACE
+//   EMIT      glutamate → POST, ASTRO
+//   RECEIVE   retro_NO, retro_eCB ← POST  (signals latched; resources refill in RECOVER)
+//   READ      glutamate (own cleft, autobrake) ; dopamine (gates tag)
+//   OWN       pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling
+//             VGCC_active (occupancy: current coupling, filled toward VGCC_coupling ceiling)
+//   SUPPLY    astro_lactate[syn] ← ASTRO ; axon_ship_pre ← AXON ; pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT)
+//   EMERGENCY shockwave_lockdown ← ASTRO
+
+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²⁺ × current coupling occupancy, + DSE brake)
+    drive = sat(pre_fast_trace × VGCC_active, 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 — signals only)
+    retro_NO_local = retro_NO;  retro_eCB_local = retro_eCB
+    // 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
+    // BEHAVE    (short-term potentiation: eligibility tightens coupling, NO dopamine; drifts back)
+    if pre_possible_tag > stp_thr:
+        VGCC_active = min(VGCC_active + coupling_gain × pre_possible_tag, pre_structure.VGCC_coupling)
+    else:
+        VGCC_active = max(VGCC_active - coupling_drift·Δt, VGCC_baseline)    // STD = consequence
+    // RECOVER   (refill BOTH pools: contested budget + private RRP)
+    pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton))
+    RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
+    // DECAY
+    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.
+```

elements/neuron/appunti/old/2026-06-26-logic-principles-of-the-expression.md

@@ -1,20 +1,12 @@
-# Logic Principles of the expression
+# Logic Principles of the Tripartite Synapse Model
 
 These are the principles that govern the system's logic — not the syntax in which it is
 expressed, but the reasoning that shapes every variable, every behavior, and every
-transition. They are organized into nine categories, from the most foundational to the
+transition. They are organized into ten categories, from the most foundational to the
 most emergent. The final category shows how principles that are stated entirely in local
 terms necessarily produce a holistic system — a whole that no part represents but that
 every part participates in.
 
-## Da aggiungere
-- intricazione
-- top-down
-- eterarchia
-- questo tipo logica non ha un corrispettivo nella programmazione tradizionale.Perche' questa si ispira al nostro ragionando che e' unico. Ragionare su una logica unificante nella programmazione tradizionale non ha senso, perche' non c'e' una logica unica, ma una per ciascun programma
-- in G esprimiamo la possibilità di eventi con RF che da la possibilità relativa. in enliving le possibilità diventano attualità. a quel punto possiamo interpretare temporaneamente le relative attializzazioni, perche abbiamo imposto la matrice spazio temporale.
-- il fatto che possiamo far girare lenliving su un hardware piu o meno veloce, se manteniamo la relatività fra possibilità di eventi, non cambia nulla alle attualità. quello xhe cambia è la velocita di scorrimento del tempo, non le seqyenze di eventi.
-
 ---
 
 ## I. Resource and Conservation
@@ -114,7 +106,69 @@ not just its peak.
 
 ---
 
-## IV. Locality
+## IV. The Timescale Ladder
+
+This is the spine the other principles hang from. The system's quantities occupy four nested
+tiers, and timescale is not incidental to them — it *is* what distinguishes them.
+
+**Four tiers, by timescale.** FAST traces (milliseconds to seconds) — the residual calcium, the
+synaptic current, the immediate response. MEDIUM occupancy and evidence (seconds to minutes) —
+the filled receptor surface and channel coupling, the accumulating possible-tag, the endurance
+need. The SLOW tag (hours) — the validated bridge to consolidation. PERSISTENT capacity
+(written only at NIGHT, drifting over days) — the structure and budget ceilings. Each tier
+decays on its own timescale, and that decay constant is the tier's meaning: a fast-decaying
+quantity is a momentary signal, a slow one a commitment, and a non-decaying one a capacity.
+
+**The tiers are a ladder, not just four speeds.** Each rung's output is the next rung's input,
+and the coupling runs in two directions at once.
+
+**Capacity flows downward — each slower tier sets the ceiling for the faster one below it.**
+Persistent structure bounds how far medium occupancy can fill; medium occupancy (current
+coupling, current receptor surface) bounds how strongly fast behavior can act. A behavior never
+acts beyond the occupancy currently filled, and occupancy never fills beyond the structure built
+last night. The ceiling at every level was set by the level above, on a slower timescale.
+
+**Evidence flows upward — each faster tier accumulates toward the slower one above it.** Fast
+traces accumulate into medium evidence (possible-tag and endurance-need); medium evidence
+bridges, on coincidence with validation, into the slow tag; the slow tag commits, at NIGHT, into
+persistent capacity. Each tier is the evidence from which the next slower tier is built, and
+nothing reaches a slower tier without having accumulated through the faster ones first.
+
+**Both pathways are instances of the climb.** The strength pathway (fast trace → medium
+possible-tag → slow tag → persistent structure) and the endurance pathway (fast trace → medium
+endurance-need → persistent budget ceiling) are the same upward flow of evidence, differing only
+in what validates the climb — associative dopamine for strength, homeostatic fuel-shortfall for
+endurance. And both ceilings they build then flow back downward as the bounds the next day's
+behavior runs within.
+
+**This single image contains the model's whole logic.** Capacity-versus-occupancy is the
+downward flow; the two evidence streams are the upward flow; the DAY/NIGHT split is just where
+the ladder is climbed (evidence accumulates by DAY) versus where it is committed (capacity is
+written at NIGHT). The functional groups enact the ladder: ADJUST and BEHAVE read capacity
+downward, TRACE accumulates evidence upward, and NIGHT commits the top of the upward flow into
+the source of the downward flow. To understand the system is to see that it is a four-rung ladder
+with capacity descending and evidence ascending, turning once per DAY/NIGHT cycle.
+
+**The ladder governs pools as well as traces — and a pool's recovery timescale is what its
+exhaustion means.** Each tier has a depletion process, a recovery process, and a failure meaning,
+and the three are bound together by the tier's timescale. *Fast* pools (the readily-releasable
+vesicle pool) deplete and recover fast, so their shortfall is transient — short-term depression,
+self-correcting within a second once activity slows. *Medium* pools (the operational budget)
+deplete and recover at the medium scale, so their shortfall is a standing constraint, not
+instantly self-correcting — which is exactly why it is worth recording as endurance evidence.
+*Persistent* capacity (structure) changes only at NIGHT, so its "shortfall" is a structural limit
+that cannot be fixed in DAY at all. The recovery timescale of a pool therefore determines what
+kind of thing its exhaustion *is*: a passing inconvenience, a standing problem worth consolidating
+against, or a hard ceiling. This is the same "timescale = meaning" principle that governs traces,
+now applied to pools — and it is why the model can read a behavior's failure mode off which pool
+ran dry: fast-pool exhaustion is STD, medium-pool exhaustion is endurance evidence, persistent-pool
+limit is structural. Depletion and recovery are the pool-side mirror of creation and decay: a pool
+is drawn down by behaving and refilled toward its ceiling, just as a trace is deposited by behaving
+and relaxes toward zero, and in both cases the timescale is the meaning.
+
+---
+
+## V. Locality
 
 **Only local evaluation.** Every decision a component makes — to act, to deposit a trace,
 to register an interrupted success — uses only information physically present in that
@@ -141,7 +195,7 @@ reached me.
 
 ---
 
-## V. Validation and Non-Locality
+## VI. Validation and Non-Locality
 
 **Short-term change is local; long-term change is non-local.** A component can transiently
 strengthen from its own activity alone — occupancy rises with calcium, no permission needed.
@@ -169,7 +223,7 @@ running out of fuel at the verge of its own local success.
 
 ---
 
-## VI. Selection and Asymmetry
+## VII. Selection and Asymmetry
 
 **Potentiation is the active drive; depotentiation is its shadow.** The entire machinery
 is oriented toward strengthening what is significant and sustaining what is fuel-limited.
@@ -200,7 +254,7 @@ continuously corrected by the small errors its own imperfect state produces.
 
 ---
 
-## VII. Bottom-Up Emergence
+## VIII. Bottom-Up Emergence
 
 **Complex temporal behavior emerges from local reactive traces, not explicit computation.**
 The soma aligns with its input rhythm without representing the rhythm — it leaves a trace
@@ -222,7 +276,7 @@ production, produce the allocation. No allocator exists; the allocation is real.
 
 ---
 
-## VIII. Coupling, Openness, and Boundedness
+## IX. Coupling, Openness, and Boundedness
 
 **Couplings create trajectories, not just states.** Some variables, once moved, make
 further movement in the same direction easier — the astrosynapse wrapping tighter after
@@ -264,7 +318,7 @@ any internal check — determines what was worth keeping.
 
 ---
 
-## IX. From Local Expression to Holistic System
+## X. From Local Expression to Holistic System
 
 The preceding principles are stated almost entirely in local terms. Every behavior is a
 local component acting on its own state within its own budget. Every evaluation uses only

elements/neuron/appunti/old/2026-06-26-tripartite-synapse_v14.md

@@ -0,0 +1,720 @@
+# Tripartite Synapse — Pseudocode v14
+
+> Companion: `tripartite_synapse_v14_biology.md` · principle: `logic_principles` (Timescale Ladder).
+> Changes from v13:
+>  (1) every component has a plain-language intro (DAY/AP · DAY/NOT_AP · NIGHT)
+>  (2) budget refill regrouped RECEIVE → RECOVER everywhere (RECEIVE = signals only)
+>  (3) presynaptic short-term potentiation (possible_tag → VGCC occupancy) — see PRE
+>  (4) FOUR TIERS surfaced: FAST (ms–s) · MEDIUM (s–min) · SLOW (hr) · PERSISTENT (NIGHT)
+>      DECAY groups are banded by tier; the group-to-tier ladder is stated once below
+>  (5) variable-type table in conventions maps each quantity to its tier
+
+---
+
+## Functional groups (seven-group grammar)
+
+```
+RECEIVE   take in resources + signals that arrived from outside     (boundary: in)
+TRACE     maintain the trace hierarchy — deposit fast trace; accumulate
+          possible_tag + endurance_need; stabilize tag on coincidence
+ADJUST    compute local operating parameters from structure + traces + modulators
+BEHAVE    the component's defining action, within both ceilings
+EMIT      send out — signals (messages) + resources (shipments)      (boundary: out)
+RECOVER   refill own private pools consumed by behaving
+DECAY     let traces recede, closing their windows
+```
+
+EVALUATE merged into TRACE: judging a behavior is always maintaining a trace, whether or not
+a trace is written. BEHAVE and EMIT stay separate — EMIT is the output half of the locality
+interface (RECEIVE/EMIT are the only boundary crossings). TRACE spans all timescales: the
+soma's inactivation, adaptation, and nuclear-Ca deposits are all TRACE. Order within a context
+follows data dependencies; TRACE reads/writes whatever trace state is current.
+
+EVERY FLOW HAS A TIMESCALE. Decay relaxes toward 0 over τ; creation/arrival relaxes toward a
+target over τ — the same first-order operator. Within-step writes are the special case τ ≪ Δt.
+Rate-limited inflows (fill/refill/flux·Δt) carry their τ implicitly; shipment carries an
+explicit transit delay (see `transit`).
+
+THE GROUPS MOVE BETWEEN TIERS (the ladder; see logic_principles "The Timescale Ladder").
+Four tiers: FAST (ms–s) · MEDIUM (s–min) · SLOW (hr) · PERSISTENT (NIGHT-written). The groups
+move evidence UP the ladder and read capacity DOWN it:
+
+```
+  ADJUST    reads PERSISTENT ceiling + FAST trace  → sets this step's operating point (down)
+  BEHAVE    acts at FAST, bounded by the PERSISTENT ceiling                          (down)
+  TRACE     deposits FAST, accumulates FAST→MEDIUM evidence, stabilizes MEDIUM→SLOW tag (up)
+  RECOVER   refills toward the PERSISTENT ceiling                                     (down)
+  DECAY     relaxes FAST · MEDIUM · SLOW (PERSISTENT never decays in DAY)
+  NIGHT     commits SLOW tag + MEDIUM endurance_need → PERSISTENT ceilings            (up)
+```
+
+Capacity flows downward (slow sets the ceiling for fast); evidence flows upward (fast
+accumulates toward slow). Each component's DECAY group below is banded by tier to show this.
+
+---
+
+## Conventions
+
+```
+SCOPE = {DAY, NIGHT}   CONTEXT = {AP, NOT_AP, bAP, NOT_bAP, CONTINUOUS}
+
+VARIABLE TIERS (timescale = meaning; see logic_principles "The Timescale Ladder")
+  FAST       (ms–s)   immediate response     fast_trace
+  MEDIUM     (s–min)  occupancy + evidence   possible_tag · endurance_need · VGCC_active · AMPA_surface · RRP
+  SLOW       (hr)     consolidation bridge   tag
+  ─────────────────────────────────────────────────────────────────────────────
+  PERSISTENT (NIGHT)  capacity (the ceilings) structure · budget_ceiling
+                      energy (not recoverable) · material (recoverable)
+
+DAY      budget · fast_trace · possible_tag · endurance_need
+BRIDGE   tag (POST: CANDIDATE→STABLE)
+NIGHT    energy (not recoverable) · material (recoverable) · structure · budget_ceiling
+
+LOCALITY only local state + arrived signals; no component reads another's internal state.
+
+CLEFT MESSAGE CHANNELS              SHIPMENT CHANNELS (transit-delayed)
+  glutamate     PRE → POST, ASTRO     soma_ship_dend SOMA→DEND
+  astro_Dserine ASTRO → POST          soma_ship_axon SOMA→AXON
+  retro_NO      POST → PRE (+)        dend_ship_post DEND→POST
+  retro_eCB     POST → PRE (−)        axon_ship_pre  AXON→PRE
+```
+
+---
+
+## Primitives (return the increment; caller applies it)
+
+```
+sat(x, K) = x / (K + x)
+
+fill(pool, ceiling, rate, cost, budget) -> amount:        // PRIVATE reserve, rate-limited (implicit τ)
+    amount = min(rate, ceiling - pool)·Δt;  budget -= amount·cost;  return amount
+
+refill(c from supply S) -> amount:                         // CONTESTED supply, gap-bounded
+    demand = c.budget_ceiling - c.budget
+    factor = min(1, S / (Σ demand over components on S + ε));  S -= demand·factor
+    return demand·factor
+
+ship(from_budget, demand_sig, frac, cost) -> amount:       // emit into transit (not to target directly)
+    amount = min(from_budget·frac, demand_sig);  from_budget -= amount·(1+ship_cost);  return amount
+
+transit(channel, τ_transport) -> arrival:                  // delivers in-transit cargo over τ
+    arrival = channel·(Δt/τ_transport);  channel -= arrival;  return arrival
+```
+
+---
+
+## SHARED parameters
+
+```
+dopamine  NE  ACh                         // organism broadcasts (external)
+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
+
+The presynaptic bouton releases neurotransmitter and gathers evidence about whether that
+release was worth strengthening and worth sustaining. Its behavior unfolds across two DAY
+contexts and the NIGHT scope.
+
+**During DAY, during AP — the bouton releases neurotransmitter.** The amount released depends on
+residual **calcium** from recent spikes (the fast trace, setting the drive), the current
+**VGCC coupling occupancy** (how tightly calcium channels are coupled to docking slots right
+now — filled short-term, bounded by structure), the two **retrograde messages** from the
+postsynapse (`retro_eCB` brakes the drive; `retro_NO` will confirm release reached a responsive
+target), and the availability of both **fuel and vesicles**. Two shortfalls are read
+differently: a fuel shortfall on a succeeding release is evidence the bouton needs more
+*endurance*; an empty pool with fuel to spare is ordinary short-term depression.
+
+**During DAY, during NOT_AP — the bouton consolidates, potentiates short-term, and recovers.**
+With no spike to release, it latches the retrograde messages (RECEIVE); maintains its traces —
+accumulating eligibility toward a dopamine-gated tag (TRACE); transiently tightens its VGCC
+coupling from accumulated eligibility, with no dopamine, a reversible short-term potentiation
+bounded by the structural ceiling (BEHAVE); refills both its budget (contested supply) and its
+vesicle pool (private reserve) (RECOVER); and lets its traces decay, closing the windows (DECAY).
+
+**During NIGHT — the bouton's ceilings are rewritten.** NIGHT raises the bouton's **structure**
+(active-zone capacity, including the VGCC-coupling ceiling) where a validated tag accumulated,
+and its **budget capacity** (mitochondrial endurance) where fuel repeatedly interrupted a
+succeeding release. Both draw on the same finite material and energy shipped down the axon, so
+the two kinds of growth compete — and whatever is not maintained drifts back down.
+
+```
+// PARAMETERS  K_release · release_cost · fusion_cost · vatpase_cost · spillover · brake
+//             stp_thr · coupling_gain · coupling_drift · VGCC_baseline
+// INTERFACE
+//   EMIT      glutamate → POST, ASTRO
+//   RECEIVE   retro_NO, retro_eCB ← POST  (signals latched; resources refill in RECOVER)
+//   READ      glutamate (own cleft, autobrake) ; dopamine (gates tag)
+//   OWN       pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling
+//             VGCC_active (occupancy: current coupling, filled toward VGCC_coupling ceiling)
+//   SUPPLY    astro_lactate[syn] ← ASTRO ; axon_ship_pre ← AXON ; pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT)
+//   EMERGENCY shockwave_lockdown ← ASTRO
+//
+// TRACE CREATION MODES (every trace: trace += input·Δt − trace·(Δt/τ_decay))
+//   impulse    input = quantum·δ(event)  — a point event; no rise time, τ = decay only   (FAST)
+//   accumulate input = rate(condition)·Δt — ramps while a condition holds; τ = rise AND decay (MEDIUM/SLOW)
+// A trace's tier is set by BOTH its creation mode and its decay: the fast trace is impulse-created
+// and fast-decaying; possible_tag/endurance_need are slowly accumulated and medium-decaying.
+
+DAY | AP:
+    // TRACE     FAST · impulse  (Ca²⁺ bolus from THIS spike — a point event; no rise time,
+    //           decay alone sets its τ; frequency is emergent from impulse-rate vs decay)
+    pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)·δ(spike)
+    // ADJUST    (release drive from residual Ca²⁺ × current coupling occupancy, + DSE brake)
+    drive = sat(pre_fast_trace × VGCC_active, 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)
+        // TRACE  MEDIUM · accumulate  (ramps while fuel keeps interrupting a succeeding release)
+        if pre_fast_trace > traj_thr:
+            pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)·Δt
+        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 — signals only)
+    retro_NO_local = retro_NO;  retro_eCB_local = retro_eCB
+    // TRACE     (strength pathway — evidence climbs the ladder)
+    //   MEDIUM · accumulate  (ramps while fast_trace stays eligible; rise-rate is its τ_rise)
+    if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt
+    //   SLOW · accumulate    (ramps only on dopamine coincidence; rise gated by validation)
+    if dopamine > dop_thr and pre_possible_tag > tag_thr:
+        pre_tag += dopamine × pre_possible_tag·Δt
+    // BEHAVE    (short-term potentiation: eligibility tightens coupling, NO dopamine; drifts back)
+    if pre_possible_tag > stp_thr:
+        VGCC_active = min(VGCC_active + coupling_gain × pre_possible_tag, pre_structure.VGCC_coupling)
+    else:
+        VGCC_active = max(VGCC_active - coupling_drift·Δt, VGCC_baseline)    // STD = consequence
+    // RECOVER   (refill BOTH pools: contested budget + private RRP)
+    pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton))
+    RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
+    // DECAY
+    //   FAST   (ms–s)
+    pre_fast_trace *= decay(100ms)
+    //   MEDIUM (s–min)
+    pre_possible_tag *= decay(s);  pre_endurance_need *= decay(min)
+    //   SLOW   (hr)
+    pre_tag *= decay(hr)
+    //   (signals) arrived channels fade
+    dopamine *= decay(ms);  retro_NO *= decay(s);  retro_eCB *= decay(s)
+    //   (PERSISTENT: pre_structure, pre_budget_ceiling — no DAY decay; NIGHT only)
+```
+
+---
+
+## POST
+
+The postsynaptic spine is the synapse's primary memory locus: it detects coincident input,
+runs the calcium dynamics that decide potentiation versus depression, and requires the most
+validation (three coincidences) before committing. Its behavior unfolds across two DAY
+contexts and the NIGHT scope.
+
+**During DAY, during NOT_bAP — the spine integrates input and decides plasticity.** Three
+calcium sources feed its fast trace: AMPA current (small Ca, begins ejecting the NMDA Mg block),
+NMDA (large Ca, but only on the local coincidence of depolarization + astrocyte D-serine +
+glutamate), and — in the bAP context — the back-propagating spike. High calcium drives AMPA
+receptors to the surface (short-term potentiation, occupancy filled toward the slot ceiling, no
+dopamine); when calcium falls, they drift back (short-term depression as a consequence). The
+spine also emits two retrograde messages from its own state — NO when it responded, an
+endocannabinoid brake when over-driven — and accumulates a dopamine-gated tag toward
+consolidation. A fuel shortfall while calcium was climbing toward a tag is endurance evidence;
+a surface already at its ceiling is a structural limit, not endurance.
+
+**During DAY, during bAP — the back-propagating spike confirms coincidence.** The somatic spike
+arrives at the spine, adds depolarization and calcium, and supralinearly amplifies an existing
+candidate — the soma's confirmation that it fired, one of the three coincidences the spine
+requires.
+
+**During NIGHT — the spine's ceilings are rewritten.** NIGHT raises **structure** (the AMPA
+slot ceiling, spine volume) where a validated tag accumulated — with a coherence bonus when pre,
+post, and astro all tagged the same synapse — and **budget capacity** where fuel interrupted a
+climbing calcium trajectory. Both draw the same finite pool, so they compete; unmaintained
+ceilings drift down.
+
+```
+// PARAMETERS  K_AMPA · AMPA_Ca · AMPA_cost · NMDA_cost · bAP_cost · pka_cost · traffic_cost
+//             req_cost · Mg_eject · Dserine_thr · Ca_STP · Ca_TAG · eCB_thr · drift · baseline
+//             NO_synth_cost · eCB_synth_cost
+// INTERFACE
+//   EMIT      retro_NO (+), retro_eCB (−) → PRE
+//   RECEIVE   (signals) glutamate ← PRE ; astro_Dserine ← ASTRO ; bAP ← DEND/SOMA ; dopamine
+//   READ      glutamate ; astro_Dserine ; bAP (dend_structure.bAP_fidelity) ; dopamine
+//   OWN       post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling
+//   SUPPLY    astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND ; post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
+//   EMERGENCY shockwave_lockdown ← ASTRO
+// NOTE      POST endurance is own-state only (own Ca climbing); no arrived feedback term.
+
+DAY | NOT_bAP:
+    // ADJUST    (AMPA drive from arrived glutamate)
+    a = sat(glutamate, K_AMPA)
+    // BEHAVE    (SOURCE 1 AMPA: current + small Ca + begins Mg ejection)
+    AMPA_current = a × AMPA_surface;  Vm += AMPA_current;  post_budget -= AMPA_cost
+    // TRACE     (Ca deposited by AMPA)
+    post_fast_trace += AMPA_Ca·AMPA_current
+    // BEHAVE    (SOURCE 2 NMDA: large Ca on local coincidence)
+    if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0:
+        post_fast_trace += NMDA_Ca(glutamate)·rise_speed();  post_budget -= NMDA_cost
+        // EMIT      (+ NO/BDNF: "release reached a responsive target")
+        retro_NO += NO_emit(post_fast_trace);  post_budget -= NO_synth_cost
+    // EMIT      (− endocannabinoid / DSE when over-driven)
+    if Vm > eCB_thr:
+        retro_eCB += eCB_emit(Vm);  post_budget -= eCB_synth_cost
+    post_fast_trace *= decay(ms)
+    // BEHAVE    (STP fill slots from private reserve ; else STD drift = consequence)
+    if post_fast_trace > Ca_STP:
+        if post_budget < traffic_cost:
+            // FUEL shortfall → endurance (own Ca was climbing toward a tag)
+            if post_fast_trace > traj_thr and post_fast_trace_rising:
+                post_endurance_need += post_fast_trace
+        else if AMPA_surface < post_structure.slot_ceiling:
+            AMPA_surface += Ca_insert(post_fast_trace);  post_budget -= traffic_cost
+        // else: surface already at slot_ceiling → structure-limited (not endurance)
+    else:
+        AMPA_surface = max(AMPA_surface - drift·Δt, baseline)   // STD = consequence
+    // TRACE     (strength: CANDIDATE then STABLE via dopamine)
+    if post_fast_trace > Ca_TAG: post_possible_tag += post_fast_trace;  post_budget -= pka_cost
+    if dopamine > dop_thr and post_possible_tag > tag_thr:
+        post_tag += dopamine × post_possible_tag
+    // RECOVER   (refill budget from contested supply)
+    post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine))
+    // DECAY
+    //   FAST   (ms–s) — post_fast_trace already decayed above (intra-step, pre-tagging)
+    //   MEDIUM (s–min)
+    post_possible_tag *= decay(min);  post_endurance_need *= decay(min)
+    //   SLOW   (hr)
+    post_tag *= decay(hr)
+    //   (signals)
+    dopamine *= decay(ms)
+    //   (PERSISTENT: post_structure, post_budget_ceiling — no DAY decay; NIGHT only)
+
+DAY | bAP:
+    // BEHAVE    (SOURCE 3 bAP: depolarization + Ca, amplifies existing signal)
+    Vm += bAP_depol × dend_structure.bAP_fidelity;  post_budget -= bAP_cost
+    // TRACE     (supralinear boost only if a CANDIDATE is present)
+    if post_possible_tag > Ca_TAG: post_fast_trace += bAP_Ca_boost()
+```
+
+---
+
+## DEND
+
+The dendritic branch is the postsynapse's supply line and the neuron's input integrator. It
+carries the back-propagating spike out to its spines, integrates their voltages toward the
+soma, and ships material and budget to the spines it supports. Its behavior unfolds across two
+DAY contexts and the NIGHT scope.
+
+**During DAY, during bAP — the branch propagates and integrates.** When the soma fires, the
+branch propagates the back-propagating spike toward its spines, with a fidelity that attenuates
+with distance (distal spines get weaker confirmation, are harder to potentiate). It deposits
+branch calcium and integrates its spines' voltages into a single branch signal sent on to the
+soma. A fuel shortfall that cuts propagation short while the branch was strongly active is
+endurance evidence; propagation that simply attenuates with distance is a structural limit, not
+endurance.
+
+**During DAY, during NOT_bAP — the branch consolidates, supplies, and recovers.** It maintains
+its tag toward consolidation, lowers its commit threshold under acetylcholine (attention),
+ships budget down to its spines (demand-weighted by their tags), runs local translation if
+tagged, refills its own budget from astrocytic lactate and somatic shipment, and lets its
+traces decay.
+
+**During NIGHT — the branch's ceilings are rewritten.** NIGHT raises **structure** (bAP
+fidelity, translation capacity) where a validated tag accumulated and **budget capacity** where
+fuel interrupted strong branch activity, both from the shared pool, both competing; unmaintained
+ceilings drift down.
+
+```
+// PARAMETERS  prop_cost · branch_Ca_cost · integrate_cost · translate_cost · ACh_gain
+// INTERFACE
+//   EMIT      bAP_local → POST ; branch_Vm → SOMA ; dend_ship_post → POST
+//   RECEIVE   (signals) SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
+//   READ      SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
+//   OWN       dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling
+//   SUPPLY    astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT)
+//   NOTE      DEND endurance fires only on FUEL-limited propagation, not structural attenuation;
+//             own-state proxy (strong branch activity); no arrived feedback term.
+
+DAY | bAP:
+    // ADJUST    (propagation strength from structure — inside propagate())
+    // BEHAVE    (propagate bAP; distinguish fuel-limited vs structure-limited shortfall)
+    if dend_budget < prop_cost:
+        // FUEL shortfall → endurance (branch was strongly active)
+        if dend_fast_trace > traj_thr:
+            dend_endurance_need += dend_fast_trace
+        bAP_local, reached = propagate_partial(dend_budget)
+    else:
+        bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, geometry)
+        // reached < full here is structural attenuation (distance), NOT endurance
+    dend_budget -= prop_cost × reached
+    // TRACE
+    dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover();  dend_budget -= branch_Ca_cost
+    // EMIT      (integrated voltage to soma ; propagated bAP already reached spines)
+    branch_Vm = integrate(POST.Vm, spines);  dend_budget -= integrate_cost
+
+DAY | NOT_bAP:
+    // TRACE     (strength)
+    if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace
+    if dopamine > dop_thr and dend_possible_tag > tag_thr:
+        dend_tag += dopamine × dend_possible_tag
+    // ADJUST    (commit threshold lowered by attention)
+    commit_threshold *= 1/(1 + ACh·ACh_gain)
+    // BEHAVE    (local translation if tagged — fills dend capacity faster)
+    if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost
+    // EMIT      (ship budget to spines; demand = post tag)
+    dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost)
+    // RECOVER   (refill budget from contested supply)
+    dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend))
+    // DECAY
+    //   FAST   (ms–s)
+    dend_fast_trace *= decay(300ms)
+    //   MEDIUM (s–min)
+    dend_possible_tag *= decay(s);  dend_endurance_need *= decay(min)
+    //   SLOW   (hr)
+    dend_tag *= decay(hr)
+    //   (PERSISTENT: dend_structure, dend_budget_ceiling — no DAY decay; NIGHT only)
+```
+
+---
+
+## SOMA
+
+The soma is the neuron's integrating center and the root of its structural material. It sums
+the branch inputs, fires when they exceed a threshold it sets from its own adaptation and the
+neuromodulators, and ships material and budget out to the dendrites and axon. Its timing —
+refractoriness, adaptation, rhythm alignment — emerges bottom-up from local traces, never from
+a represented clock. Its behavior unfolds across two DAY contexts and the NIGHT scope.
+
+**During DAY, during AP — the soma integrates and fires.** It computes its firing threshold
+from its baseline (structure), its accumulated adaptation, and the neuromodulators, and checks
+its refractory state; if the integrated branch input clears the threshold and fuel allows, it
+fires. One spike deposits three traces at three timescales — sodium inactivation (refractory),
+slow-potassium adaptation (threshold rise), and nuclear calcium (toward CREB and the tag). A
+fuel shortfall while nuclear calcium was climbing is endurance evidence; being refractory or
+sub-threshold is a timing limit, not endurance.
+
+**During DAY, during NOT_AP — the soma recovers, aligns, and supplies.** It self-replenishes
+from its own mitochondria (its private root), integrates the latest branch inputs, deposits a
+refractory-alignment trace when suprathreshold input arrived during its refractory period (so it
+aligns to its input rhythm bottom-up), ships budget to dendrites and axon (demand-weighted by
+their tags), recovers from refractoriness at a rate its alignment trace speeds up, and lets its
+traces decay.
+
+**During NIGHT — the soma's ceilings are rewritten, and it gates the whole neuron's material.**
+NIGHT raises **structure** (excitability, synthesis capacity) and **budget capacity** from the
+shared pool; crucially the soma's own tag gates CREB-driven synthesis, so how much material all
+downstream components receive depends on the soma having been tagged.
+
+```
+// PARAMETERS  ap_cost · nuclear_cost · creb_cost · mito_output · inactivation · ap_amp · ap_contrib
+//             base_recovery · τ_Na · τ_adapt · τ_nuclear · τ_align
+// INTERFACE
+//   EMIT      fired → AXON (propagate) + DEND (bAP) ; soma_ship_dend → DEND ; soma_ship_axon → AXON
+//   RECEIVE   (signals) branch_Vm ← DEND ; dopamine ; NE ; ACh
+//   READ      dopamine ; NE ; ACh
+//   OWN       soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling
+//   SUPPLY    self (mitochondria, ROOT — private)
+//   NOTE      SOMA endurance fires only on FUEL shortfall (budget < ap_cost);
+//             refractory / sub-threshold are timing limits, not endurance. Own-state proxy.
+
+DAY | AP:
+    // ADJUST    (threshold from structure + adaptation + neuromodulators ; refractory gate)
+    threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh)
+    can_fire  = soma_Na_inactivation < inactivation
+    // BEHAVE    (fire if able)
+    if branch_Vm > threshold and can_fire:
+        if soma_budget < ap_cost:
+            // FUEL shortfall → endurance (firing was approaching CREB)
+            if soma_fast_trace > traj_thr and soma_fast_trace_rising:
+                soma_endurance_need += soma_fast_trace
+            exit
+        // EMIT      (fired → AXON, DEND)
+        fired = True;  soma_budget -= ap_cost
+        // TRACE     (three traces from one AP — FAST nuclear-Ca, MEDIUM adaptation, refractory)
+        soma_Na_inactivation += ap_amp                     // → refractory (emergent)
+        soma_adaptation      += ap_contrib                 // → threshold rise
+        soma_fast_trace      += nuclear_Ca();  soma_budget -= nuclear_cost
+        // TRACE     (strength)
+        if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace
+        if dopamine > dop_thr and soma_possible_tag > tag_thr:
+            soma_tag += dopamine × soma_possible_tag
+        soma_budget -= creb_cost
+
+DAY | NOT_AP:
+    // RECEIVE   (integrate latest branch input — signal)
+    branch_Vm = integrate(DEND.branch_Vm, branches)
+    // TRACE     (bottom-up refractory alignment: suprathreshold input during refractory)
+    if branch_Vm > threshold and soma_Na_inactivation > inactivation:
+        soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation
+    // EMIT      (ship downstream into transit; demand = propagated tags)
+    soma_ship_dend = ship(soma_budget, dend_demand, dend_ship_frac, ship_cost)
+    soma_ship_axon = ship(soma_budget, axon_demand, axon_ship_frac, ship_cost)
+    // RECOVER   (self-replenish from private root ; inactivation recovery sped by alignment)
+    soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
+    recovery = base_recovery × (1 + soma_refractory_alignment)
+    soma_Na_inactivation *= decay(τ_Na / recovery)
+    // DECAY
+    //   FAST   (ms–s) — refractory + nuclear-Ca + alignment (sub-second to seconds)
+    soma_fast_trace *= decay(τ_nuclear);  soma_refractory_alignment *= decay(τ_align)  // self-limiting
+    //   MEDIUM (s–min) — adaptation + tagging evidence
+    soma_adaptation *= decay(τ_adapt)
+    soma_possible_tag *= decay(s);  soma_endurance_need *= decay(min)
+    //   SLOW   (hr)
+    soma_tag *= decay(hr)
+    //   (signals)
+    dopamine *= decay(ms)
+    //   (PERSISTENT: soma_structure, soma_budget_ceiling — no DAY decay; NIGHT only)
+```
+
+---
+
+## AXON
+
+The axon carries the soma's spike out to its boutons and is the presynapse's supply line. It
+propagates reliably or not depending on its myelination and its recent load, and ships material
+and budget to the boutons. Its behavior unfolds across two DAY contexts and the NIGHT scope.
+
+**During DAY, during AP — the axon propagates the spike.** Reliability is set by structure
+(myelination) and degraded by recent high-frequency load (sodium inactivation at branch points —
+axonal short-term depression). A fuel shortfall while carrying a strong train is endurance
+evidence; load-driven failure is short-term depression, a consequence, not endurance.
+
+**During DAY, during NOT_AP — the axon supplies and recovers.** It maintains its tag, ships
+budget to its boutons (demand-weighted by their tags), refills its own budget from somatic
+shipment and astrocytic lactate, and lets its traces decay.
+
+**During NIGHT — the axon's ceilings are rewritten.** NIGHT raises **structure** (myelination,
+transport capacity) and **budget capacity** from the shared pool, both competing; unmaintained
+ceilings drift down.
+
+```
+// PARAMETERS  prop_cost · budget_factor
+// INTERFACE
+//   EMIT      APs_delivered → PRE (propagation) ; axon_ship_pre → PRE
+//   RECEIVE   (signals) SOMA.fired ; dopamine
+//   READ      SOMA.fired ; dopamine
+//   OWN       axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling
+//   SUPPLY    soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT)
+//   NOTE      AXON endurance fires only on FUEL shortfall; load-driven failure fail(fast_trace)
+//             is axonal STD (a consequence), not endurance. Own-state proxy.
+
+DAY | AP:
+    // ADJUST    (reliability from structure − load-driven failure)
+    reliability = axon_structure.propagation × (1 - fail(axon_fast_trace))   // fail() = STD, not endurance
+    // BEHAVE    (propagate; FUEL shortfall degrades + flags endurance)
+    if axon_budget < prop_cost:
+        reliability *= budget_factor
+        if axon_fast_trace > traj_thr:                     // FUEL-limited → endurance
+            axon_endurance_need += axon_fast_trace
+    delivered = fired × reliability;  axon_budget -= prop_cost × delivered
+    // EMIT      (delivered APs reach boutons)
+    // TRACE
+    axon_fast_trace += delivered;  axon_fast_trace *= decay(s)
+
+DAY | NOT_AP:
+    // TRACE     (strength)
+    if axon_fast_trace > elig: axon_possible_tag += axon_fast_trace
+    if dopamine > dop_thr and axon_possible_tag > tag_thr:
+        axon_tag += dopamine × axon_possible_tag
+    // EMIT      (ship to boutons; demand = pre tag)
+    axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost)
+    // RECOVER   (refill budget from contested supply)
+    axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
+    // DECAY
+    //   FAST   (ms–s)
+    axon_fast_trace *= decay(s)
+    //   MEDIUM (s–min)
+    axon_possible_tag *= decay(s);  axon_endurance_need *= decay(min)
+    //   SLOW   (hr)
+    axon_tag *= decay(hr)
+    //   (PERSISTENT: axon_structure, axon_budget_ceiling — no DAY decay; NIGHT only)
+```
+
+---
+
+## ASTRO
+
+The astrosynapse is the synapse's gatekeeper and energy hub. It clears glutamate, supplies the
+D-serine that gates postsynaptic NMDA, and distributes lactate across its territory by demand.
+Unlike the others it runs in a single continuous context rather than spiking, and its structure
+reshapes the synapse's operating point rather than just its range.
+
+**During DAY, continuously — the astrosynapse clears, gates, and fuels.** It produces energy at
+its cell body (glycolysis from glucose, the system's energy root), then allocates lactate across
+its astrosynapses weighted by each one's clearance demand. At each astrosynapse it clears
+spillover glutamate (EAAT) and supplies tonic D-serine; when spillover is high it adds a
+demand-driven D-serine pulse, brakes nothing of the presynapse directly (the presynaptic brake
+is PRE reading its own cleft), deposits its calcium trace, and accumulates a dopamine-gated tag.
+A D-serine pulse cut short by low budget while demand was high is endurance evidence; one cut
+short by precursor/material exhaustion is a material limit, not endurance. Excess overflow
+triggers the protective shockwave lockdown.
+
+**During NIGHT — the astrosynapse's ceilings are rewritten.** NIGHT raises **structure**
+(perisynaptic wrap, EAAT density, tonic D-serine) where a validated tag accumulated and **budget
+capacity** where budget-limited synthesis recurred; astro_structure is self-reinforcing in both
+directions, so it amplifies whatever trajectory the synapse is already on.
+
+```
+// PARAMETERS  K_Dserine · Ds_max · Ds_frac · Ds_cost · EAAT_cost · lactate_cost · spillover · overload
+// INTERFACE
+//   EMIT      astro_lactate[i] → pre/post/dend budgets ; astro_Dserine[i] → POST (gate)
+//   RECEIVE   (signals) glutamate ← PRE (clearance + spillover) ; dopamine
+//   READ      glutamate ; dopamine
+//   OWN       astro_structure{perisynaptic_distance⁻¹, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling
+//   SUPPLY    glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT)
+//   NOTE      ASTRO endurance fires on BUDGET-limited synthesis (got<want via low budget);
+//             material/precursor-limited synthesis is a material limit, not endurance. Own-state proxy.
+//   EMERGENCY emits shockwave_lockdown on overload
+
+DAY | CONTINUOUS:                                          // per astrosynapse i
+    // RECEIVE   (root production, capped by glucose)
+    astro_central_budget += glycolysis(glucose)·Δt
+    // ADJUST    (demand weights across territory)
+    for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff
+    factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε))
+    // EMIT      (demand-weighted lactate to all components)
+    for each i:
+        astro_lactate[i] = demand[i] × factor;  astro_central_budget -= astro_lactate[i]·lactate_cost
+    // BEHAVE    (clear glutamate ; supply tonic D-serine)
+    glutamate[i] -= astro_structure[i].EAAT × glutamate[i]·Δt;  astro_central_budget -= clearance·EAAT_cost
+    astro_Dserine[i] += astro_structure[i].Dserine_tonic·Δt
+    if glutamate[i] > spillover:
+        // TRACE
+        astro_fast_trace[i] += mGluR_Ca();  astro_fast_trace[i] *= decay(s)
+        // ADJUST    (D-serine demand from spillover)
+        want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
+        got  = min(want, astro_central_budget × Ds_frac)
+        // BEHAVE + EMIT  (D-serine pulse to POST gate)
+        astro_Dserine[i] += got;  astro_central_budget -= got·Ds_cost
+        // TRACE     (endurance: BUDGET-limited synthesis under high own demand)
+        if got < want and astro_central_budget low and astro_fast_trace[i] > traj_thr:
+            astro_endurance_need[i] += (want - got)
+        // TRACE     (strength)
+        if astro_fast_trace[i] > elig: astro_possible_tag[i] += astro_fast_trace[i]
+        if dopamine > dop_thr and astro_possible_tag[i] > tag_thr:
+            astro_tag[i] += dopamine × astro_possible_tag[i]
+    // DECAY
+    //   FAST   (ms–s) — astro_fast_trace already decayed above (intra-step)
+    //   MEDIUM (s–min)
+    astro_possible_tag[i] *= decay(s);  astro_endurance_need[i] *= decay(min)
+    //   SLOW   (hr)
+    astro_tag[i] *= decay(hr)
+    //   (PERSISTENT: astro_structure, astro_budget_ceiling — no DAY decay; NIGHT only)
+    // EMERGENCY
+    if astro_fast_trace[i] > overload: emit(shockwave_lockdown)
+```
+
+---
+
+## 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.
+```

elements/neuron/appunti/old/2026-06-29-biological-reference_v16.md

@@ -0,0 +1,454 @@
+# Tripartite Synapse — Biological Reference (companion to v16 pseudocode)
+
+> Companion to `tripartite_synapse_v16_pseudocode.md` · principle: `logic_principles_v3`.
+> v16 gives NIGHT a hierarchy of homeostatic actors at scales above the single synapse, and a
+> phased structure. The actors of consolidation are not the actors of transmission: by day the
+> six local components transmit; by night a hierarchy — astrocyte territory, the whole neuron,
+> and (as an external signal) the assembly/network — renormalizes and reallocates. Early-night
+> cycles downscale the day's transient changes (synaptic homeostasis); later cycles consolidate
+> the survivors. Occupancy filled by day (receptor surface, channel coupling) is returned to
+> baseline each night, so only what was written into a structural ceiling persists.
+
+---
+
+## 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.
+
+
+---
+
+## Presynaptic short-term potentiation — VGCC coupling occupancy
+
+`VGCC_active` is the presynaptic parallel to the postsynaptic `AMPA_surface`. Both are MEDIUM-tier
+occupancy variables: a current operating value filled toward a NIGHT-built ceiling, no dopamine,
+reversible, drifting back when undriven.
+
+Biologically, `VGCC_active` represents the effective coupling between voltage-gated calcium
+channels and the vesicle docking slots — how reliably each calcium influx is converted into
+release. Repeated eligible activity (accumulated `pre_possible_tag`) transiently tightens this
+coupling — through calcium-channel facilitation, active-zone protein phosphorylation, and
+channel-to-sensor proximity changes — raising release efficiency without changing the number of
+channels (which is the structural ceiling `pre_structure.VGCC_coupling`, written only at NIGHT).
+When eligibility falls, the coupling relaxes back to baseline over seconds-to-minutes: presynaptic
+short-term depression as the passive consequence of undriven coupling, never a signalled act.
+
+This gives the presynapse a genuine intermediate-timescale memory it previously lacked — a
+"this bouton has been reliably active lately" state that outlasts individual spikes and bursts,
+filling the gap between the fast trace (residual calcium, ~100 ms) and the tag (hours). It also
+completes the capacity/occupancy symmetry across the synapse: both PRE and POST now fill a
+MEDIUM occupancy variable toward a PERSISTENT structural ceiling, rather than PRE reading its
+ceiling directly as if capacity and occupancy were the same thing.
+
+
+---
+
+## NIGHT as iterated NREM cycles — the biology
+
+The distributed, cyclic NIGHT models sleep-dependent consolidation more faithfully than a single
+commit step.
+
+**Why cycles, not one event.** NREM sleep proceeds in repeated cycles (the ultradian ~90-minute
+rhythm, and within it the <1 Hz slow oscillation with its up- and down-states). Protein synthesis,
+hippocampal–cortical replay, and synaptic renormalization all advance incrementally across these
+cycles rather than in a single consolidation moment. Modeling NIGHT as a loop of cycles captures
+this: each cycle is a small, local round of produce → transport → incorporate.
+
+**Production each cycle (the roots).** The soma's CREB-driven transcription/translation produces a
+batch of structural material per cycle, gated by the soma's own tag (replay-driven activity).
+The astrocyte cell body produces a batch of energy (glycolysis) and ECM material per cycle, capped
+by glucose. These are the two roots; everything downstream lives on what they ship.
+
+**Transport over cycles (the descent).** Material and energy move one hop down the supply chains
+per cycle — soma → dendrite/axon → spine/bouton; astrocyte body → astrosynapses — by the same
+motor transport that carries cargo by day, now at the consolidation timescale. A distal bouton on
+a long axon therefore receives its material only after several cycles, so its consolidation lags
+a proximal one. This is the NIGHT-scale image of the transit delay.
+
+**Incorporation and tag consumption (the commit).** A tagged synapse incorporates arrived material
+into structure (more receptor slots, tighter active zone, tighter astrocytic wrap) or into budget
+capacity (mitochondrial biogenesis), spending energy on the assembly. The tag is consumed in
+proportion to what was built — the molecular tag (CaMKII/PKA-maintained eligibility) is discharged
+as capture completes. A strong tag is satisfied early; a marginal one waits for later cycles.
+
+**Two ways the night ends.** Either the standing tags are all spent (consolidation finished — the
+rested case) or the night's metabolic budget is exhausted (ran out of night — the overloaded
+case). Unspent tags are not discarded: they persist (decaying slowly) into the next day and
+compete again the next night, so importance is re-tested across nights and a marginal memory may
+consolidate over several nights or, if it decays first, never.
+
+**Energy is the irreversible cost.** Material released when an unmaintained structure is pruned
+returns to the pool and is reused; the energy burned to build or to prune is gone. Across a
+lifetime this energy throughput bounds how much the system can ever consolidate — the metabolic
+arrow of time underlying the whole model.
+
+
+---
+
+## NIGHT's hierarchy of actors — the biology
+
+**Why the actors differ from DAY's.** Transmission is local — a bouton releases, a spine
+integrates, an astrosynapse clears. Consolidation is not: it involves quantities no single
+synapse can see. Whether one synapse's strengthening "fits" depends on the neuron's total
+synaptic weight; reallocating metabolic support depends on an astrocyte's whole territory;
+deciding which memories to replay depends on assemblies of neurons. So NIGHT is enacted by
+actors at higher scales, each conserving a quantity at its scale.
+
+**The astrocyte territory (Tier 2).** The astrocyte cell body supports hundreds to thousands of
+synapses. By day it allocates lactate by demand; by night it reallocates its produced energy and
+ECM material across its whole territory, biased by the demand it accumulated and by replay. This
+is a genuine territory-level actor — the astrocyte is the metabolic arbiter of its domain, and
+its nightly reallocation decides which of its synapses can afford to consolidate.
+
+**The neuron as a whole (Tier 1).** Synaptic homeostasis (the synaptic homeostasis hypothesis of
+Tononi and Cirelli) operates on the neuron's *total* synaptic weight: across sleep, the cell's
+synapses are renormalized downward multiplicatively, preserving relative differences while
+restoring overall excitability and freeing capacity. This is a neuron-scale operation — no synapse
+can perform it, because no synapse knows the cell's total weight. In the model the neuron
+accumulates that total by day and renormalizes it by night, scaling all the cell's structures by
+a common factor when the total exceeds the cell's budget.
+
+**The assembly / network (Tier 0, external).** Systems consolidation — hippocampal–cortical replay
+— reactivates the day's patterns across ensembles of neurons during NREM, and this dialogue
+selects which assemblies are written into cortex. This is a network-scale process beyond a single
+neuron, so the model treats it as an external arrived signal (`replay_reweight`), exactly as it
+treats dopamine and glucose. Fully modeling it requires a network of these neurons.
+
+**Occupancy downscaling — why only ceilings persist.** During the day, synapses fill occupancy:
+receptors trafficked to the surface (AMPA_surface), calcium-channel coupling tightened
+(VGCC_active), eligibility accumulated (possible_tag). These are transient and reversible. If they
+carried across the night undiminished, a synapse could become lastingly strong without ever
+earning a tag or paying the consolidation cost — bypassing the entire validation machinery.
+Multiplicative-global downscaling during early-night cycles returns occupancy to baseline. A
+synapse that was tagged and had its *ceiling* raised starts the next day strong; one that merely
+filled occupancy during the day starts back at baseline. The relative potentiation survives only
+where it was written into structure — which is precisely synaptic homeostasis enforcing that the
+slow tier carries the learning and the fast/medium tier is renewed each day.
+
+**Why phased.** A single sweep cannot both reset and build, because building should act on the
+*post-reset* landscape. Early cycles are subtractive (downscale occupancy, renormalize weight,
+make metabolic room); later cycles are additive (commit the survivors). This is the NREM arc —
+slow-wave-dominated downscaling early, selective consolidation later — and it makes each cycle's
+*kind* depend on where in the night it falls, so the cycles are genuinely different operations,
+not installments of one.

elements/neuron/appunti/old/2026-06-29-tripartite-synapse_v16.md

@@ -0,0 +1,974 @@
+# Tripartite Synapse — Pseudocode v16
+
+> Companion: `tripartite_synapse_v16_biology.md` · principle: `logic_principles_v3`.
+> Changes from v15 — NIGHT gains HIGHER-SCALE ACTORS and a PHASED structure:
+>  (1) NIGHT is enacted by a hierarchy of homeostatic actors, NOT the DAY components alone:
+>      COMPONENT (commits own ceilings) → ASTROCYTE territory (reallocates across its synapses)
+>      → NEURON (renormalizes total weight) → [assembly/network replay: external arrived signal]
+>  (2) the NEURON and ASTROCYTE-territory actors ACCUMULATE aggregate traces by DAY
+>      (total weight/activity; territory demand) and ACT by NIGHT (renormalize; reallocate)
+>  (3) OCCUPANCY is reset each NIGHT: multiplicative-global downscaling drives VGCC_active,
+>      AMPA_surface, possible_tag back toward baseline — only CEILINGS persist across a night
+>  (4) NIGHT is PHASED: early cycles DOWNSCALE (subtractive, reset occupancy, make room),
+>      late cycles COMMIT (additive, build ceilings for the survivors)
+>  (5) governing rule: what persists across a night must have EARNED persistence —
+>      occupancy that earned no tag returns to baseline; the system acts locally, consolidates
+>      hierarchically
+> Carried: cyclic NIGHT, tag-as-fuel, emergent termination, DAY-up/NIGHT-down, seven-group grammar.
+
+---
+
+## Functional groups (seven-group grammar)
+
+```
+RECEIVE   take in resources + signals that arrived from outside     (boundary: in)
+TRACE     maintain the trace hierarchy — deposit fast trace; accumulate
+          possible_tag + endurance_need; stabilize tag on coincidence
+ADJUST    compute local operating parameters from structure + traces + modulators
+BEHAVE    the component's defining action, within both ceilings
+EMIT      send out — signals (messages) + resources (shipments)      (boundary: out)
+RECOVER   refill own private pools consumed by behaving
+DECAY     let traces recede, closing their windows
+```
+
+EVALUATE merged into TRACE: judging a behavior is always maintaining a trace, whether or not
+a trace is written. BEHAVE and EMIT stay separate — EMIT is the output half of the locality
+interface (RECEIVE/EMIT are the only boundary crossings). TRACE spans all timescales: the
+soma's inactivation, adaptation, and nuclear-Ca deposits are all TRACE. Order within a context
+follows data dependencies; TRACE reads/writes whatever trace state is current.
+
+EVERY FLOW HAS A TIMESCALE. Decay relaxes toward 0 over τ; creation/arrival relaxes toward a
+target over τ — the same first-order operator. Within-step writes are the special case τ ≪ Δt.
+Rate-limited inflows (fill/refill/flux·Δt) carry their τ implicitly; shipment carries an
+explicit transit delay (see `transit`).
+
+THE GROUPS MOVE BETWEEN TIERS (the ladder; see logic_principles "The Timescale Ladder").
+Four tiers: FAST (ms–s) · MEDIUM (s–min) · SLOW (hr) · PERSISTENT (NIGHT-written). The groups
+move evidence UP the ladder and read capacity DOWN it:
+
+```
+  ADJUST    reads PERSISTENT ceiling + FAST trace  → sets this step's operating point (down)
+  BEHAVE    acts at FAST, bounded by the PERSISTENT ceiling                          (down)
+  TRACE     deposits FAST, accumulates FAST→MEDIUM evidence, stabilizes MEDIUM→SLOW tag (up)
+  RECOVER   refills toward the PERSISTENT ceiling                                     (down)
+  DECAY     relaxes FAST · MEDIUM · SLOW (PERSISTENT never decays in DAY)
+  NIGHT     commits SLOW tag + MEDIUM endurance_need → PERSISTENT ceilings            (up)
+```
+
+Capacity flows downward (slow sets the ceiling for fast); evidence flows upward (fast
+accumulates toward slow). Each component's DECAY group below is banded by tier to show this.
+
+NIGHT IS THE SAME GRAMMAR, ITERATED, WITH THE FLOW REVERSED. NIGHT is not a separate section —
+each component carries a `NIGHT |` block, and a driver loops all blocks for cycle = 1,2,3…
+until the night ends. DAY runs bottom-up (consumers act first, evidence ascends leaves→roots);
+NIGHT runs top-down (producers act first, capacity descends roots→leaves). Per cycle, each
+component:
+
+```
+  RECEIVE   take in the material + energy batch that arrived from my producer this cycle
+  TRACE     read my own tag / endurance_need (the standing demand)
+  ADJUST    size this cycle's commit from material + energy actually on hand
+  BEHAVE    commit a BATCH: structure += Δ (from tag) ; budget_ceiling += Δ' (from need)
+            spend material + energy ; SPEND the tag/need by the committed amount (tag-as-fuel)
+  EMIT      ship a batch of material + energy one hop down to my consumers (demand-weighted)
+  RECOVER   reclaim material from any ceiling that decayed this cycle (energy is NOT recovered)
+  DECAY     unmaintained ceilings drift down a little; tags decay a little
+```
+
+Roots (SOMA, ASTRO cell body) PRODUCE the batch each cycle (RECEIVE = production, capped by
+glucose / CREB). The night ends when DEMAND is exhausted (no tag stands above tag_expiry,
+system-wide) OR SUPPLY is spent (the night's energy throughput is used up) — whichever first.
+Unspent tags are NOT cleared; they carry to the next DAY and compete again next NIGHT. The
+top-down order needs no schedule: iterating the local cycle delivers capacity to distal sites
+over successive cycles, as transport physically does.
+
+NIGHT'S ACTORS ARE NOT DAY'S ACTORS — THE SYSTEM ACTS LOCALLY, CONSOLIDATES HIERARCHICALLY.
+DAY is enacted by the six local components. NIGHT is enacted by a HIERARCHY of homeostatic
+actors, each conserving a quantity at its own scale and constraining the scale below:
+
+```
+  [ ASSEMBLY / NETWORK ]   replay re-presents the day across neurons      (EXTERNAL signal)
+            ↓ constrains   → arrives as replay_reweight[·] (like dopamine/glucose: external)
+  NEURON (the whole cell)  conserves TOTAL synaptic weight; renormalizes so no synapse
+            ↓ constrains   grows beyond the cell's global budget; drives occupancy downscaling
+  ASTROCYTE territory      conserves total metabolic output; reallocates energy/material
+            ↓ constrains   across ALL synapses it wraps, by accumulated territory demand
+  COMPONENT                commits its own ceilings within the allocation handed down
+```
+
+These higher actors are DORMANT-BUT-ACCUMULATING by DAY and ACTIVE-AND-CONSTRAINING by NIGHT.
+By DAY they only integrate an aggregate trace of the components' emitted activity (they sum
+what was emitted, never read a component's interior — locality holds): the NEURON accumulates
+`neuron_total_weight` and `neuron_activity`; the ASTROCYTE territory accumulates
+`astro_territory_demand[·]`. By NIGHT they act on those aggregates: the astrocyte reallocates,
+the neuron renormalizes. The assembly/network tier is not modelled here; its effect enters as
+an external arrived signal `replay_reweight`, exactly as dopamine and glucose do.
+
+NIGHT IS PHASED. Early cycles DOWNSCALE (subtractive): occupancy filled during the day —
+VGCC_active, AMPA_surface, possible_tag — is driven back toward baseline by multiplicative-global
+scaling, and total weight is renormalized. Late cycles COMMIT (additive): the survivors' tags
+build ceilings. The rule the phasing enforces: WHAT PERSISTS ACROSS A NIGHT MUST HAVE EARNED
+PERSISTENCE. Occupancy that earned no tag returns to baseline; only ceilings carry forward. The
+relative potentiation of a tagged synapse survives because it was written into its ceiling, not
+because its transient occupancy was spared.
+
+---
+
+## Conventions
+
+```
+SCOPE = {DAY, NIGHT}   CONTEXT = {AP, NOT_AP, bAP, NOT_bAP, CONTINUOUS}
+
+VARIABLE TIERS (timescale = meaning; see logic_principles "The Timescale Ladder")
+  FAST       (ms–s)   immediate response     fast_trace
+  MEDIUM     (s–min)  occupancy + evidence   possible_tag · endurance_need · VGCC_active · AMPA_surface · RRP
+  SLOW       (hr)     consolidation bridge   tag
+  ─────────────────────────────────────────────────────────────────────────────
+  PERSISTENT (NIGHT)  capacity (the ceilings) structure · budget_ceiling
+                      energy (not recoverable) · material (recoverable)
+
+DAY      budget · fast_trace · possible_tag · endurance_need
+BRIDGE   tag (POST: CANDIDATE→STABLE)
+NIGHT    energy (not recoverable) · material (recoverable) · structure · budget_ceiling
+
+LOCALITY only local state + arrived signals; no component reads another's internal state.
+
+CLEFT MESSAGE CHANNELS              SHIPMENT CHANNELS (transit-delayed)
+  glutamate     PRE → POST, ASTRO     soma_ship_dend SOMA→DEND
+  astro_Dserine ASTRO → POST          soma_ship_axon SOMA→AXON
+  retro_NO      POST → PRE (+)        dend_ship_post DEND→POST
+  retro_eCB     POST → PRE (−)        axon_ship_pre  AXON→PRE
+```
+
+---
+
+## Primitives (return the increment; caller applies it)
+
+```
+sat(x, K) = x / (K + x)
+
+fill(pool, ceiling, rate, cost, budget) -> amount:        // PRIVATE reserve, rate-limited (implicit τ)
+    amount = min(rate, ceiling - pool)·Δt;  budget -= amount·cost;  return amount
+
+refill(c from supply S) -> amount:                         // CONTESTED supply, gap-bounded
+    demand = c.budget_ceiling - c.budget
+    factor = min(1, S / (Σ demand over components on S + ε));  S -= demand·factor
+    return demand·factor
+
+ship(from_budget, demand_sig, frac, cost) -> amount:       // emit into transit (not to target directly)
+    amount = min(from_budget·frac, demand_sig);  from_budget -= amount·(1+ship_cost);  return amount
+
+transit(channel, τ_transport) -> arrival:                  // delivers in-transit cargo over τ
+    arrival = channel·(Δt/τ_transport);  channel -= arrival;  return arrival
+```
+
+---
+
+## SHARED parameters
+
+```
+dopamine  NE  ACh                         // organism broadcasts (external)
+replay_reweight[·]                        // assembly/network replay re-weighting (external, NIGHT)
+glucose  geometry                         // physical (external)
+elig  dop_thr  tag_thr  tag_expiry        // strength gates (universal)
+traj_thr  endur_thr                       // endurance gates (universal)
+ship_cost                                 // transport overhead (all shipments)
+{dend,axon,pre,post}_ship_frac            // DAY budget-shipment fractions
+τ_transport_{dend,axon,spine,bouton}      // shipment transit times (distance-dependent)
+ε
+```
+
+## NIGHT parameters (consolidation only)
+
+```
+slot_batch  cap_batch  f_cap              // per-CYCLE commit sizes / endurance fraction
+night_energy_ceiling                      // total energy a single night can spend (supply bound)
+Δt_cycle                                  // duration of one NIGHT cycle
+maint_frac  cap_frac                      // maintenance allocation
+decay_rate  capacity_decay_rate  recycle  // passive ceiling decay + material recovery
+homeostatic_ceiling  coherence_factor  assembly_cost  biogenesis_cost  maint_cost
+f_dend  f_axon  f_spine  f_bouton         // per-cycle material/energy ship fractions (down the chain)
+downscale_factor                          // per-early-cycle multiplicative occupancy reset (<1)
+neuron_weight_ceiling                     // the cell's total-weight budget (renormalization target)
+early_phase_frac                          // fraction of night cycles that are DOWNSCALE phase
+```
+
+---
+---
+# DAY
+---
+
+## PRE
+
+The presynaptic bouton releases neurotransmitter and gathers evidence about whether that
+release was worth strengthening and worth sustaining. Its behavior unfolds across two DAY
+contexts and the NIGHT scope.
+
+**During DAY, during AP — the bouton releases neurotransmitter.** The amount released depends on
+residual **calcium** from recent spikes (the fast trace, setting the drive), the current
+**VGCC coupling occupancy** (how tightly calcium channels are coupled to docking slots right
+now — filled short-term, bounded by structure), the two **retrograde messages** from the
+postsynapse (`retro_eCB` brakes the drive; `retro_NO` will confirm release reached a responsive
+target), and the availability of both **fuel and vesicles**. Two shortfalls are read
+differently: a fuel shortfall on a succeeding release is evidence the bouton needs more
+*endurance*; an empty pool with fuel to spare is ordinary short-term depression.
+
+**During DAY, during NOT_AP — the bouton consolidates, potentiates short-term, and recovers.**
+With no spike to release, it latches the retrograde messages (RECEIVE); maintains its traces —
+accumulating eligibility toward a dopamine-gated tag (TRACE); transiently tightens its VGCC
+coupling from accumulated eligibility, with no dopamine, a reversible short-term potentiation
+bounded by the structural ceiling (BEHAVE); refills both its budget (contested supply) and its
+vesicle pool (private reserve) (RECOVER); and lets its traces decay, closing the windows (DECAY).
+
+**During NIGHT — the bouton's ceilings are rewritten.** NIGHT raises the bouton's **structure**
+(active-zone capacity, including the VGCC-coupling ceiling) where a validated tag accumulated,
+and its **budget capacity** (mitochondrial endurance) where fuel repeatedly interrupted a
+succeeding release. Both draw on the same finite material and energy shipped down the axon, so
+the two kinds of growth compete — and whatever is not maintained drifts back down.
+
+```
+// PARAMETERS  K_release · release_cost · fusion_cost · vatpase_cost · spillover · brake
+//             stp_thr · coupling_gain · coupling_drift · VGCC_baseline
+// INTERFACE
+//   EMIT      glutamate → POST, ASTRO
+//   RECEIVE   retro_NO, retro_eCB ← POST  (signals latched; resources refill in RECOVER)
+//   READ      glutamate (own cleft, autobrake) ; dopamine (gates tag)
+//   OWN       pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling
+//             VGCC_active (occupancy: current coupling, filled toward VGCC_coupling ceiling)
+//   SUPPLY    astro_lactate[syn] ← ASTRO ; axon_ship_pre ← AXON ; pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT)
+//   EMERGENCY shockwave_lockdown ← ASTRO
+//
+// TRACE CREATION MODES (every trace: trace += input·Δt − trace·(Δt/τ_decay))
+//   impulse    input = quantum·δ(event)  — a point event; no rise time, τ = decay only   (FAST)
+//   accumulate input = rate(condition)·Δt — ramps while a condition holds; τ = rise AND decay (MEDIUM/SLOW)
+// A trace's tier is set by BOTH its creation mode and its decay: the fast trace is impulse-created
+// and fast-decaying; possible_tag/endurance_need are slowly accumulated and medium-decaying.
+
+DAY | AP:
+    // TRACE     FAST · impulse  (Ca²⁺ bolus from THIS spike — a point event; no rise time,
+    //           decay alone sets its τ; frequency is emergent from impulse-rate vs decay)
+    pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)·δ(spike)
+    // ADJUST    (release drive from residual Ca²⁺ × current coupling occupancy, + DSE brake)
+    drive = sat(pre_fast_trace × VGCC_active, 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)
+        // TRACE  MEDIUM · accumulate  (ramps while fuel keeps interrupting a succeeding release)
+        if pre_fast_trace > traj_thr:
+            pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)·Δt
+        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 — signals only)
+    retro_NO_local = retro_NO;  retro_eCB_local = retro_eCB
+    // TRACE     (strength pathway — evidence climbs the ladder)
+    //   MEDIUM · accumulate  (ramps while fast_trace stays eligible; rise-rate is its τ_rise)
+    if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt
+    //   SLOW · accumulate    (ramps only on dopamine coincidence; rise gated by validation)
+    if dopamine > dop_thr and pre_possible_tag > tag_thr:
+        pre_tag += dopamine × pre_possible_tag·Δt
+    // BEHAVE    (short-term potentiation: eligibility tightens coupling, NO dopamine; drifts back)
+    if pre_possible_tag > stp_thr:
+        VGCC_active = min(VGCC_active + coupling_gain × pre_possible_tag, pre_structure.VGCC_coupling)
+    else:
+        VGCC_active = max(VGCC_active - coupling_drift·Δt, VGCC_baseline)    // STD = consequence
+    // RECOVER   (refill BOTH pools: contested budget + private RRP)
+    pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton))
+    RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
+    // DECAY
+    //   FAST   (ms–s)
+    pre_fast_trace *= decay(100ms)
+    //   MEDIUM (s–min)
+    pre_possible_tag *= decay(s);  pre_endurance_need *= decay(min)
+    //   SLOW   (hr)
+    pre_tag *= decay(hr)
+    //   (signals) arrived channels fade
+    dopamine *= decay(ms);  retro_NO *= decay(s);  retro_eCB *= decay(s)
+    //   (PERSISTENT: pre_structure, pre_budget_ceiling — no DAY decay; NIGHT only)
+
+NIGHT | cycle:                                             // leaf consumer (no downstream emit)
+    // RECEIVE   batch arrived from AXON (material) + SOMA (energy) this cycle
+    pre_material += transit(pre_material_ship, τ_transport_bouton)
+    pre_energy   += transit(pre_energy_ship,   τ_transport_bouton)
+    // TRACE     read standing demand
+    //   (pre_tag → structure ; pre_endurance_need → budget_ceiling)
+    // ADJUST    size commits from material + energy on hand
+    coh = coherence_signal                                 // arrived: pre+post+astro tags aligned
+    // BEHAVE    commit batches; spend tag/need as fuel
+    if pre_tag > tag_expiry:
+        Δ = min(slot_batch, pre_material, pre_energy·f_cap)
+        pre_structure += Δ × coh;  pre_material -= Δ;  pre_energy -= Δ·assembly_cost
+        pre_tag -= Δ                                       // tag-as-fuel
+    if pre_endurance_need > endur_thr:
+        Δ' = min(cap_batch, pre_material·f_cap, pre_energy·f_cap)
+        pre_budget_ceiling += Δ';  pre_material -= Δ';  pre_energy -= Δ'·biogenesis_cost
+        pre_endurance_need -= Δ'
+    // EMIT      (none — bouton is a leaf; nothing downstream)
+    // RECOVER   reclaim material from any ceiling that decayed this cycle
+    pre_material += pre_ceiling_shrinkage·recycle          // energy NOT recovered
+    // DECAY     unmaintained ceilings + tags drift down a little
+    pre_structure -= decay_rate·Δt_cycle;  pre_budget_ceiling -= capacity_decay_rate·Δt_cycle
+    pre_structure += min(pre_maint, maint_cost);  pre_budget_ceiling += min(pre_cap_maint, cap_cost)
+    pre_tag *= decay(slow);  pre_endurance_need *= decay(slow)
+```
+
+---
+
+## POST
+
+The postsynaptic spine is the synapse's primary memory locus: it detects coincident input,
+runs the calcium dynamics that decide potentiation versus depression, and requires the most
+validation (three coincidences) before committing. Its behavior unfolds across two DAY
+contexts and the NIGHT scope.
+
+**During DAY, during NOT_bAP — the spine integrates input and decides plasticity.** Three
+calcium sources feed its fast trace: AMPA current (small Ca, begins ejecting the NMDA Mg block),
+NMDA (large Ca, but only on the local coincidence of depolarization + astrocyte D-serine +
+glutamate), and — in the bAP context — the back-propagating spike. High calcium drives AMPA
+receptors to the surface (short-term potentiation, occupancy filled toward the slot ceiling, no
+dopamine); when calcium falls, they drift back (short-term depression as a consequence). The
+spine also emits two retrograde messages from its own state — NO when it responded, an
+endocannabinoid brake when over-driven — and accumulates a dopamine-gated tag toward
+consolidation. A fuel shortfall while calcium was climbing toward a tag is endurance evidence;
+a surface already at its ceiling is a structural limit, not endurance.
+
+**During DAY, during bAP — the back-propagating spike confirms coincidence.** The somatic spike
+arrives at the spine, adds depolarization and calcium, and supralinearly amplifies an existing
+candidate — the soma's confirmation that it fired, one of the three coincidences the spine
+requires.
+
+**During NIGHT — the spine's ceilings are rewritten.** NIGHT raises **structure** (the AMPA
+slot ceiling, spine volume) where a validated tag accumulated — with a coherence bonus when pre,
+post, and astro all tagged the same synapse — and **budget capacity** where fuel interrupted a
+climbing calcium trajectory. Both draw the same finite pool, so they compete; unmaintained
+ceilings drift down.
+
+```
+// PARAMETERS  K_AMPA · AMPA_Ca · AMPA_cost · NMDA_cost · bAP_cost · pka_cost · traffic_cost
+//             req_cost · Mg_eject · Dserine_thr · Ca_STP · Ca_TAG · eCB_thr · drift · baseline
+//             NO_synth_cost · eCB_synth_cost
+// INTERFACE
+//   EMIT      retro_NO (+), retro_eCB (−) → PRE
+//   RECEIVE   (signals) glutamate ← PRE ; astro_Dserine ← ASTRO ; bAP ← DEND/SOMA ; dopamine
+//   READ      glutamate ; astro_Dserine ; bAP (dend_structure.bAP_fidelity) ; dopamine
+//   OWN       post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling
+//   SUPPLY    astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND ; post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
+//   EMERGENCY shockwave_lockdown ← ASTRO
+// NOTE      POST endurance is own-state only (own Ca climbing); no arrived feedback term.
+
+DAY | NOT_bAP:
+    // ADJUST    (AMPA drive from arrived glutamate)
+    a = sat(glutamate, K_AMPA)
+    // BEHAVE    (SOURCE 1 AMPA: current + small Ca + begins Mg ejection)
+    AMPA_current = a × AMPA_surface;  Vm += AMPA_current;  post_budget -= AMPA_cost
+    // TRACE     (Ca deposited by AMPA)
+    post_fast_trace += AMPA_Ca·AMPA_current
+    // BEHAVE    (SOURCE 2 NMDA: large Ca on local coincidence)
+    if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0:
+        post_fast_trace += NMDA_Ca(glutamate)·rise_speed();  post_budget -= NMDA_cost
+        // EMIT      (+ NO/BDNF: "release reached a responsive target")
+        retro_NO += NO_emit(post_fast_trace);  post_budget -= NO_synth_cost
+    // EMIT      (− endocannabinoid / DSE when over-driven)
+    if Vm > eCB_thr:
+        retro_eCB += eCB_emit(Vm);  post_budget -= eCB_synth_cost
+    post_fast_trace *= decay(ms)
+    // BEHAVE    (STP fill slots from private reserve ; else STD drift = consequence)
+    if post_fast_trace > Ca_STP:
+        if post_budget < traffic_cost:
+            // FUEL shortfall → endurance (own Ca was climbing toward a tag)
+            if post_fast_trace > traj_thr and post_fast_trace_rising:
+                post_endurance_need += post_fast_trace
+        else if AMPA_surface < post_structure.slot_ceiling:
+            AMPA_surface += Ca_insert(post_fast_trace);  post_budget -= traffic_cost
+        // else: surface already at slot_ceiling → structure-limited (not endurance)
+    else:
+        AMPA_surface = max(AMPA_surface - drift·Δt, baseline)   // STD = consequence
+    // TRACE     (strength: CANDIDATE then STABLE via dopamine)
+    if post_fast_trace > Ca_TAG: post_possible_tag += post_fast_trace;  post_budget -= pka_cost
+    if dopamine > dop_thr and post_possible_tag > tag_thr:
+        post_tag += dopamine × post_possible_tag
+    // RECOVER   (refill budget from contested supply)
+    post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine))
+    // DECAY
+    //   FAST   (ms–s) — post_fast_trace already decayed above (intra-step, pre-tagging)
+    //   MEDIUM (s–min)
+    post_possible_tag *= decay(min);  post_endurance_need *= decay(min)
+    //   SLOW   (hr)
+    post_tag *= decay(hr)
+    //   (signals)
+    dopamine *= decay(ms)
+    //   (PERSISTENT: post_structure, post_budget_ceiling — no DAY decay; NIGHT only)
+
+DAY | bAP:
+    // BEHAVE    (SOURCE 3 bAP: depolarization + Ca, amplifies existing signal)
+    Vm += bAP_depol × dend_structure.bAP_fidelity;  post_budget -= bAP_cost
+    // TRACE     (supralinear boost only if a CANDIDATE is present)
+    if post_possible_tag > Ca_TAG: post_fast_trace += bAP_Ca_boost()
+
+NIGHT | cycle:                                             // leaf consumer (no downstream emit)
+    // RECEIVE   batch arrived from DEND (material) + SOMA (energy) this cycle
+    post_material += transit(post_material_ship, τ_transport_spine)
+    post_energy   += transit(post_energy_ship,   τ_transport_spine)
+    // TRACE     read standing demand (post_tag → structure ; post_endurance_need → budget_ceiling)
+    // ADJUST    coherence applies to POST (synaptic component)
+    coh = coherence_signal
+    // BEHAVE    commit batches; spend tag/need as fuel
+    if post_tag > tag_expiry:
+        Δ = min(slot_batch, post_material, post_energy·f_cap)
+        post_structure += Δ × coh;  post_material -= Δ;  post_energy -= Δ·assembly_cost
+        post_tag -= Δ
+    if post_endurance_need > endur_thr:
+        Δ' = min(cap_batch, post_material·f_cap, post_energy·f_cap)
+        post_budget_ceiling += Δ';  post_material -= Δ';  post_energy -= Δ'·biogenesis_cost
+        post_endurance_need -= Δ'
+    // EMIT      (none — spine is a leaf)
+    // RECOVER   reclaim material from decayed ceilings
+    post_material += post_ceiling_shrinkage·recycle        // energy NOT recovered
+    // DECAY
+    post_structure -= decay_rate·Δt_cycle;  post_budget_ceiling -= capacity_decay_rate·Δt_cycle
+    post_structure += min(post_maint, maint_cost);  post_budget_ceiling += min(post_cap_maint, cap_cost)
+    post_tag *= decay(slow);  post_endurance_need *= decay(slow)
+```
+
+---
+
+## DEND
+
+The dendritic branch is the postsynapse's supply line and the neuron's input integrator. It
+carries the back-propagating spike out to its spines, integrates their voltages toward the
+soma, and ships material and budget to the spines it supports. Its behavior unfolds across two
+DAY contexts and the NIGHT scope.
+
+**During DAY, during bAP — the branch propagates and integrates.** When the soma fires, the
+branch propagates the back-propagating spike toward its spines, with a fidelity that attenuates
+with distance (distal spines get weaker confirmation, are harder to potentiate). It deposits
+branch calcium and integrates its spines' voltages into a single branch signal sent on to the
+soma. A fuel shortfall that cuts propagation short while the branch was strongly active is
+endurance evidence; propagation that simply attenuates with distance is a structural limit, not
+endurance.
+
+**During DAY, during NOT_bAP — the branch consolidates, supplies, and recovers.** It maintains
+its tag toward consolidation, lowers its commit threshold under acetylcholine (attention),
+ships budget down to its spines (demand-weighted by their tags), runs local translation if
+tagged, refills its own budget from astrocytic lactate and somatic shipment, and lets its
+traces decay.
+
+**During NIGHT — the branch's ceilings are rewritten.** NIGHT raises **structure** (bAP
+fidelity, translation capacity) where a validated tag accumulated and **budget capacity** where
+fuel interrupted strong branch activity, both from the shared pool, both competing; unmaintained
+ceilings drift down.
+
+```
+// PARAMETERS  prop_cost · branch_Ca_cost · integrate_cost · translate_cost · ACh_gain
+// INTERFACE
+//   EMIT      bAP_local → POST ; branch_Vm → SOMA ; dend_ship_post → POST
+//   RECEIVE   (signals) SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
+//   READ      SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
+//   OWN       dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling
+//   SUPPLY    astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT)
+//   NOTE      DEND endurance fires only on FUEL-limited propagation, not structural attenuation;
+//             own-state proxy (strong branch activity); no arrived feedback term.
+
+DAY | bAP:
+    // ADJUST    (propagation strength from structure — inside propagate())
+    // BEHAVE    (propagate bAP; distinguish fuel-limited vs structure-limited shortfall)
+    if dend_budget < prop_cost:
+        // FUEL shortfall → endurance (branch was strongly active)
+        if dend_fast_trace > traj_thr:
+            dend_endurance_need += dend_fast_trace
+        bAP_local, reached = propagate_partial(dend_budget)
+    else:
+        bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, geometry)
+        // reached < full here is structural attenuation (distance), NOT endurance
+    dend_budget -= prop_cost × reached
+    // TRACE
+    dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover();  dend_budget -= branch_Ca_cost
+    // EMIT      (integrated voltage to soma ; propagated bAP already reached spines)
+    branch_Vm = integrate(POST.Vm, spines);  dend_budget -= integrate_cost
+
+DAY | NOT_bAP:
+    // TRACE     (strength)
+    if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace
+    if dopamine > dop_thr and dend_possible_tag > tag_thr:
+        dend_tag += dopamine × dend_possible_tag
+    // ADJUST    (commit threshold lowered by attention)
+    commit_threshold *= 1/(1 + ACh·ACh_gain)
+    // BEHAVE    (local translation if tagged — fills dend capacity faster)
+    if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost
+    // EMIT      (ship budget to spines; demand = post tag)
+    dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost)
+    // RECOVER   (refill budget from contested supply)
+    dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend))
+    // DECAY
+    //   FAST   (ms–s)
+    dend_fast_trace *= decay(300ms)
+    //   MEDIUM (s–min)
+    dend_possible_tag *= decay(s);  dend_endurance_need *= decay(min)
+    //   SLOW   (hr)
+    dend_tag *= decay(hr)
+    //   (PERSISTENT: dend_structure, dend_budget_ceiling — no DAY decay; NIGHT only)
+
+NIGHT | cycle:                                             // intermediate node (relays down to POST)
+    // RECEIVE   batch arrived from SOMA this cycle
+    dend_material += transit(soma_material_to_dend, τ_transport_dend)
+    dend_energy   += transit(soma_energy_to_dend,   τ_transport_dend)
+    // TRACE     read standing demand (dend_tag → structure ; dend_endurance_need → budget_ceiling)
+    // ADJUST    (no coherence — DEND is not a synaptic component)
+    // BEHAVE    commit batches; spend tag/need as fuel
+    if dend_tag > tag_expiry:
+        Δ = min(slot_batch, dend_material, dend_energy·f_cap)
+        dend_structure += Δ;  dend_material -= Δ;  dend_energy -= Δ·assembly_cost;  dend_tag -= Δ
+    if dend_endurance_need > endur_thr:
+        Δ' = min(cap_batch, dend_material·f_cap, dend_energy·f_cap)
+        dend_budget_ceiling += Δ';  dend_material -= Δ';  dend_energy -= Δ'·biogenesis_cost
+        dend_endurance_need -= Δ'
+    // EMIT      ship remaining batch one hop down to POST (demand = post tag)
+    post_material_ship += ship(dend_material, post_demand, f_spine, ship_cost)
+    post_energy_ship   += ship(dend_energy,   post_demand, f_spine, ship_cost)
+    // RECOVER   reclaim material from decayed ceilings
+    dend_material += dend_ceiling_shrinkage·recycle        // energy NOT recovered
+    // DECAY
+    dend_structure -= decay_rate·Δt_cycle;  dend_budget_ceiling -= capacity_decay_rate·Δt_cycle
+    dend_structure += min(dend_maint, maint_cost);  dend_budget_ceiling += min(dend_cap_maint, cap_cost)
+    dend_tag *= decay(slow);  dend_endurance_need *= decay(slow)
+```
+
+---
+
+## SOMA
+
+The soma is the neuron's integrating center and the root of its structural material. It sums
+the branch inputs, fires when they exceed a threshold it sets from its own adaptation and the
+neuromodulators, and ships material and budget out to the dendrites and axon. Its timing —
+refractoriness, adaptation, rhythm alignment — emerges bottom-up from local traces, never from
+a represented clock. Its behavior unfolds across two DAY contexts and the NIGHT scope.
+
+**During DAY, during AP — the soma integrates and fires.** It computes its firing threshold
+from its baseline (structure), its accumulated adaptation, and the neuromodulators, and checks
+its refractory state; if the integrated branch input clears the threshold and fuel allows, it
+fires. One spike deposits three traces at three timescales — sodium inactivation (refractory),
+slow-potassium adaptation (threshold rise), and nuclear calcium (toward CREB and the tag). A
+fuel shortfall while nuclear calcium was climbing is endurance evidence; being refractory or
+sub-threshold is a timing limit, not endurance.
+
+**During DAY, during NOT_AP — the soma recovers, aligns, and supplies.** It self-replenishes
+from its own mitochondria (its private root), integrates the latest branch inputs, deposits a
+refractory-alignment trace when suprathreshold input arrived during its refractory period (so it
+aligns to its input rhythm bottom-up), ships budget to dendrites and axon (demand-weighted by
+their tags), recovers from refractoriness at a rate its alignment trace speeds up, and lets its
+traces decay.
+
+**During NIGHT — the soma's ceilings are rewritten, and it gates the whole neuron's material.**
+NIGHT raises **structure** (excitability, synthesis capacity) and **budget capacity** from the
+shared pool; crucially the soma's own tag gates CREB-driven synthesis, so how much material all
+downstream components receive depends on the soma having been tagged.
+
+```
+// PARAMETERS  ap_cost · nuclear_cost · creb_cost · mito_output · inactivation · ap_amp · ap_contrib
+//             base_recovery · τ_Na · τ_adapt · τ_nuclear · τ_align
+// INTERFACE
+//   EMIT      fired → AXON (propagate) + DEND (bAP) ; soma_ship_dend → DEND ; soma_ship_axon → AXON
+//   RECEIVE   (signals) branch_Vm ← DEND ; dopamine ; NE ; ACh
+//   READ      dopamine ; NE ; ACh
+//   OWN       soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling
+//   SUPPLY    self (mitochondria, ROOT — private)
+//   NOTE      SOMA endurance fires only on FUEL shortfall (budget < ap_cost);
+//             refractory / sub-threshold are timing limits, not endurance. Own-state proxy.
+
+DAY | AP:
+    // ADJUST    (threshold from structure + adaptation + neuromodulators ; refractory gate)
+    threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh)
+    can_fire  = soma_Na_inactivation < inactivation
+    // BEHAVE    (fire if able)
+    if branch_Vm > threshold and can_fire:
+        if soma_budget < ap_cost:
+            // FUEL shortfall → endurance (firing was approaching CREB)
+            if soma_fast_trace > traj_thr and soma_fast_trace_rising:
+                soma_endurance_need += soma_fast_trace
+            exit
+        // EMIT      (fired → AXON, DEND)
+        fired = True;  soma_budget -= ap_cost
+        // TRACE     (three traces from one AP — FAST nuclear-Ca, MEDIUM adaptation, refractory)
+        soma_Na_inactivation += ap_amp                     // → refractory (emergent)
+        soma_adaptation      += ap_contrib                 // → threshold rise
+        soma_fast_trace      += nuclear_Ca();  soma_budget -= nuclear_cost
+        // TRACE     (strength)
+        if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace
+        if dopamine > dop_thr and soma_possible_tag > tag_thr:
+            soma_tag += dopamine × soma_possible_tag
+        soma_budget -= creb_cost
+        // TRACE     (NEURON-level aggregator — the cell sums what its components emit, by DAY)
+        neuron_activity      += 1                           // total firing this day
+        neuron_total_weight  += Σ all component structure across the cell   // running weight tally
+
+DAY | NOT_AP:
+    // RECEIVE   (integrate latest branch input — signal)
+    branch_Vm = integrate(DEND.branch_Vm, branches)
+    // TRACE     (bottom-up refractory alignment: suprathreshold input during refractory)
+    if branch_Vm > threshold and soma_Na_inactivation > inactivation:
+        soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation
+    // EMIT      (ship downstream into transit; demand = propagated tags)
+    soma_ship_dend = ship(soma_budget, dend_demand, dend_ship_frac, ship_cost)
+    soma_ship_axon = ship(soma_budget, axon_demand, axon_ship_frac, ship_cost)
+    // RECOVER   (self-replenish from private root ; inactivation recovery sped by alignment)
+    soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
+    recovery = base_recovery × (1 + soma_refractory_alignment)
+    soma_Na_inactivation *= decay(τ_Na / recovery)
+    // DECAY
+    //   FAST   (ms–s) — refractory + nuclear-Ca + alignment (sub-second to seconds)
+    soma_fast_trace *= decay(τ_nuclear);  soma_refractory_alignment *= decay(τ_align)  // self-limiting
+    //   MEDIUM (s–min) — adaptation + tagging evidence
+    soma_adaptation *= decay(τ_adapt)
+    soma_possible_tag *= decay(s);  soma_endurance_need *= decay(min)
+    //   SLOW   (hr)
+    soma_tag *= decay(hr)
+    //   (signals)
+    dopamine *= decay(ms)
+    //   (PERSISTENT: soma_structure, soma_budget_ceiling — no DAY decay; NIGHT only)
+
+NIGHT | cycle:                                             // ROOT (neuronal material) — produces each cycle
+    // RECEIVE   = PRODUCTION: synthesize this cycle's batch, gated by own tag, capped externally
+    soma_material += CREB_synth(soma_tag)·Δt_cycle         // material — recoverable
+    soma_energy   += mito_synth()·Δt_cycle                 // energy — NOT recoverable, bounded by night budget
+    night_energy_spent += mito_synth()·Δt_cycle            // track against night supply ceiling
+    // TRACE     read standing demand (soma_tag → structure ; soma_endurance_need → budget_ceiling)
+    // ADJUST    (no coherence — SOMA is not a synaptic component)
+    // BEHAVE    commit own batches
+    if soma_tag > tag_expiry:
+        Δ = min(slot_batch, soma_material, soma_energy·f_cap)
+        soma_structure += Δ;  soma_material -= Δ;  soma_energy -= Δ·assembly_cost;  soma_tag -= Δ
+    if soma_endurance_need > endur_thr:
+        Δ' = min(cap_batch, soma_material·f_cap, soma_energy·f_cap)
+        soma_budget_ceiling += Δ';  soma_material -= Δ';  soma_energy -= Δ'·biogenesis_cost
+        soma_endurance_need -= Δ'
+    // EMIT      ship batches one hop down to DEND and AXON (demand = propagated tags)
+    soma_material_to_dend += ship(soma_material, dend_demand, f_dend, ship_cost)
+    soma_material_to_axon += ship(soma_material, axon_demand, f_axon, ship_cost)
+    soma_energy_to_dend   += ship(soma_energy,   dend_demand, f_dend, ship_cost)
+    soma_energy_to_axon   += ship(soma_energy,   axon_demand, f_axon, ship_cost)
+    // RECOVER   reclaim material from decayed ceilings (own + returned from downstream)
+    soma_material += soma_ceiling_shrinkage·recycle
+    // DECAY
+    soma_structure -= decay_rate·Δt_cycle;  soma_budget_ceiling -= capacity_decay_rate·Δt_cycle
+    soma_structure += min(soma_maint, maint_cost);  soma_budget_ceiling += min(soma_cap_maint, cap_cost)
+    soma_tag *= decay(slow);  soma_endurance_need *= decay(slow)
+```
+
+---
+
+## AXON
+
+The axon carries the soma's spike out to its boutons and is the presynapse's supply line. It
+propagates reliably or not depending on its myelination and its recent load, and ships material
+and budget to the boutons. Its behavior unfolds across two DAY contexts and the NIGHT scope.
+
+**During DAY, during AP — the axon propagates the spike.** Reliability is set by structure
+(myelination) and degraded by recent high-frequency load (sodium inactivation at branch points —
+axonal short-term depression). A fuel shortfall while carrying a strong train is endurance
+evidence; load-driven failure is short-term depression, a consequence, not endurance.
+
+**During DAY, during NOT_AP — the axon supplies and recovers.** It maintains its tag, ships
+budget to its boutons (demand-weighted by their tags), refills its own budget from somatic
+shipment and astrocytic lactate, and lets its traces decay.
+
+**During NIGHT — the axon's ceilings are rewritten.** NIGHT raises **structure** (myelination,
+transport capacity) and **budget capacity** from the shared pool, both competing; unmaintained
+ceilings drift down.
+
+```
+// PARAMETERS  prop_cost · budget_factor
+// INTERFACE
+//   EMIT      APs_delivered → PRE (propagation) ; axon_ship_pre → PRE
+//   RECEIVE   (signals) SOMA.fired ; dopamine
+//   READ      SOMA.fired ; dopamine
+//   OWN       axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling
+//   SUPPLY    soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT)
+//   NOTE      AXON endurance fires only on FUEL shortfall; load-driven failure fail(fast_trace)
+//             is axonal STD (a consequence), not endurance. Own-state proxy.
+
+DAY | AP:
+    // ADJUST    (reliability from structure − load-driven failure)
+    reliability = axon_structure.propagation × (1 - fail(axon_fast_trace))   // fail() = STD, not endurance
+    // BEHAVE    (propagate; FUEL shortfall degrades + flags endurance)
+    if axon_budget < prop_cost:
+        reliability *= budget_factor
+        if axon_fast_trace > traj_thr:                     // FUEL-limited → endurance
+            axon_endurance_need += axon_fast_trace
+    delivered = fired × reliability;  axon_budget -= prop_cost × delivered
+    // EMIT      (delivered APs reach boutons)
+    // TRACE
+    axon_fast_trace += delivered;  axon_fast_trace *= decay(s)
+
+DAY | NOT_AP:
+    // TRACE     (strength)
+    if axon_fast_trace > elig: axon_possible_tag += axon_fast_trace
+    if dopamine > dop_thr and axon_possible_tag > tag_thr:
+        axon_tag += dopamine × axon_possible_tag
+    // EMIT      (ship to boutons; demand = pre tag)
+    axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost)
+    // RECOVER   (refill budget from contested supply)
+    axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
+    // DECAY
+    //   FAST   (ms–s)
+    axon_fast_trace *= decay(s)
+    //   MEDIUM (s–min)
+    axon_possible_tag *= decay(s);  axon_endurance_need *= decay(min)
+    //   SLOW   (hr)
+    axon_tag *= decay(hr)
+    //   (PERSISTENT: axon_structure, axon_budget_ceiling — no DAY decay; NIGHT only)
+
+NIGHT | cycle:                                             // intermediate node (relays down to PRE)
+    // RECEIVE   batch arrived from SOMA this cycle
+    axon_material += transit(soma_material_to_axon, τ_transport_dend)
+    axon_energy   += transit(soma_energy_to_axon,   τ_transport_dend)
+    // TRACE     read standing demand (axon_tag → structure ; axon_endurance_need → budget_ceiling)
+    // ADJUST    (no coherence — AXON is not a synaptic component)
+    // BEHAVE    commit batches; spend tag/need as fuel
+    if axon_tag > tag_expiry:
+        Δ = min(slot_batch, axon_material, axon_energy·f_cap)
+        axon_structure += Δ;  axon_material -= Δ;  axon_energy -= Δ·assembly_cost;  axon_tag -= Δ
+    if axon_endurance_need > endur_thr:
+        Δ' = min(cap_batch, axon_material·f_cap, axon_energy·f_cap)
+        axon_budget_ceiling += Δ';  axon_material -= Δ';  axon_energy -= Δ'·biogenesis_cost
+        axon_endurance_need -= Δ'
+    // EMIT      ship remaining batch one hop down to PRE (demand = pre tag)
+    pre_material_ship += ship(axon_material, pre_demand, f_bouton, ship_cost)
+    pre_energy_ship   += ship(axon_energy,   pre_demand, f_bouton, ship_cost)
+    // RECOVER   reclaim material from decayed ceilings
+    axon_material += axon_ceiling_shrinkage·recycle        // energy NOT recovered
+    // DECAY
+    axon_structure -= decay_rate·Δt_cycle;  axon_budget_ceiling -= capacity_decay_rate·Δt_cycle
+    axon_structure += min(axon_maint, maint_cost);  axon_budget_ceiling += min(axon_cap_maint, cap_cost)
+    axon_tag *= decay(slow);  axon_endurance_need *= decay(slow)
+```
+
+---
+
+## ASTRO
+
+The astrosynapse is the synapse's gatekeeper and energy hub. It clears glutamate, supplies the
+D-serine that gates postsynaptic NMDA, and distributes lactate across its territory by demand.
+Unlike the others it runs in a single continuous context rather than spiking, and its structure
+reshapes the synapse's operating point rather than just its range.
+
+**During DAY, continuously — the astrosynapse clears, gates, and fuels.** It produces energy at
+its cell body (glycolysis from glucose, the system's energy root), then allocates lactate across
+its astrosynapses weighted by each one's clearance demand. At each astrosynapse it clears
+spillover glutamate (EAAT) and supplies tonic D-serine; when spillover is high it adds a
+demand-driven D-serine pulse, brakes nothing of the presynapse directly (the presynaptic brake
+is PRE reading its own cleft), deposits its calcium trace, and accumulates a dopamine-gated tag.
+A D-serine pulse cut short by low budget while demand was high is endurance evidence; one cut
+short by precursor/material exhaustion is a material limit, not endurance. Excess overflow
+triggers the protective shockwave lockdown.
+
+**During NIGHT — the astrosynapse's ceilings are rewritten.** NIGHT raises **structure**
+(perisynaptic wrap, EAAT density, tonic D-serine) where a validated tag accumulated and **budget
+capacity** where budget-limited synthesis recurred; astro_structure is self-reinforcing in both
+directions, so it amplifies whatever trajectory the synapse is already on.
+
+```
+// PARAMETERS  K_Dserine · Ds_max · Ds_frac · Ds_cost · EAAT_cost · lactate_cost · spillover · overload
+// INTERFACE
+//   EMIT      astro_lactate[i] → pre/post/dend budgets ; astro_Dserine[i] → POST (gate)
+//   RECEIVE   (signals) glutamate ← PRE (clearance + spillover) ; dopamine
+//   READ      glutamate ; dopamine
+//   OWN       astro_structure{perisynaptic_distance⁻¹, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling
+//   SUPPLY    glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT)
+//   NOTE      ASTRO endurance fires on BUDGET-limited synthesis (got<want via low budget);
+//             material/precursor-limited synthesis is a material limit, not endurance. Own-state proxy.
+//   EMERGENCY emits shockwave_lockdown on overload
+
+DAY | CONTINUOUS:                                          // per astrosynapse i
+    // RECEIVE   (root production, capped by glucose)
+    astro_central_budget += glycolysis(glucose)·Δt
+    // ADJUST    (demand weights across territory)
+    for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff
+    for each i: astro_territory_demand[i] += demand[i]·Δt   // TRACE: territory-level aggregator (by DAY)
+    factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε))
+    // EMIT      (demand-weighted lactate to all components)
+    for each i:
+        astro_lactate[i] = demand[i] × factor;  astro_central_budget -= astro_lactate[i]·lactate_cost
+    // BEHAVE    (clear glutamate ; supply tonic D-serine)
+    glutamate[i] -= astro_structure[i].EAAT × glutamate[i]·Δt;  astro_central_budget -= clearance·EAAT_cost
+    astro_Dserine[i] += astro_structure[i].Dserine_tonic·Δt
+    if glutamate[i] > spillover:
+        // TRACE
+        astro_fast_trace[i] += mGluR_Ca();  astro_fast_trace[i] *= decay(s)
+        // ADJUST    (D-serine demand from spillover)
+        want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
+        got  = min(want, astro_central_budget × Ds_frac)
+        // BEHAVE + EMIT  (D-serine pulse to POST gate)
+        astro_Dserine[i] += got;  astro_central_budget -= got·Ds_cost
+        // TRACE     (endurance: BUDGET-limited synthesis under high own demand)
+        if got < want and astro_central_budget low and astro_fast_trace[i] > traj_thr:
+            astro_endurance_need[i] += (want - got)
+        // TRACE     (strength)
+        if astro_fast_trace[i] > elig: astro_possible_tag[i] += astro_fast_trace[i]
+        if dopamine > dop_thr and astro_possible_tag[i] > tag_thr:
+            astro_tag[i] += dopamine × astro_possible_tag[i]
+    // DECAY
+    //   FAST   (ms–s) — astro_fast_trace already decayed above (intra-step)
+    //   MEDIUM (s–min)
+    astro_possible_tag[i] *= decay(s);  astro_endurance_need[i] *= decay(min)
+    //   SLOW   (hr)
+    astro_tag[i] *= decay(hr)
+    //   (PERSISTENT: astro_structure, astro_budget_ceiling — no DAY decay; NIGHT only)
+    // EMERGENCY
+    if astro_fast_trace[i] > overload: emit(shockwave_lockdown)
+
+NIGHT | cycle:                                             // ROOT (synaptic energy + ECM) — produces each cycle
+    // RECEIVE   = PRODUCTION: glycolysis + ECM synthesis this cycle, capped by glucose
+    astro_central_energy   += overnight_glycolysis(glucose)·Δt_cycle    // energy — NOT recoverable
+    astro_central_material += astro_cellbody_synth()·Δt_cycle           // material — recoverable
+    night_energy_spent     += overnight_glycolysis(glucose)·Δt_cycle
+    // ADJUST    tag-weighted shares across the territory
+    W = Σ astro_tag[i] over astro_tag[i] > tag_expiry
+    // EMIT      distribute this cycle's batch to astrosynapses (demand = own tag)
+    for each i with astro_tag[i] > tag_expiry:
+        w = astro_tag[i]/W
+        astro_energy[i]   += astro_central_energy·w
+        astro_material[i] += astro_central_material·w
+    // BEHAVE    each astrosynapse commits; spend tag/need as fuel (coherence applies — synaptic)
+    for each astrosynapse i:
+        coh = coherence_signal[i]
+        if astro_tag[i] > tag_expiry:
+            Δ = min(slot_batch, astro_material[i], astro_energy[i]·f_cap)
+            astro_structure[i] += Δ × coh                  // self-reinforcing both directions
+            astro_material[i] -= Δ;  astro_energy[i] -= Δ·assembly_cost;  astro_tag[i] -= Δ
+        if astro_endurance_need[i] > endur_thr:
+            Δ' = min(cap_batch, astro_material[i]·f_cap, astro_energy[i]·f_cap)
+            astro_budget_ceiling[i] += Δ';  astro_material[i] -= Δ'
+            astro_energy[i] -= Δ'·biogenesis_cost;  astro_endurance_need[i] -= Δ'
+    // RECOVER   reclaim material from decayed ceilings
+    astro_central_material += astro_ceiling_shrinkage·recycle           // energy NOT recovered
+    // DECAY
+    for each i:
+        astro_structure[i] -= decay_rate·Δt_cycle;  astro_budget_ceiling[i] -= capacity_decay_rate·Δt_cycle
+        astro_structure[i] += min(astro_maint[i], maint_cost)
+        astro_budget_ceiling[i] += min(astro_cap_maint[i], cap_cost)
+        astro_tag[i] *= decay(slow);  astro_endurance_need[i] *= decay(slow)
+```
+
+---
+
+## Special — Shockwave Lockdown
+
+```
+DAY or NIGHT | OVERLOAD:
+    Vm = HYPERPOLARIZED;  AMPA_surface = mass_internalize() → post reserve
+    axon_fast_trace += overdrive();  astro_central_budget -= emergency_cost
+```
+
+---
+---
+# NIGHT — the driver (a hierarchy of actors, phased)
+NIGHT runs a loop of cycles. Each cycle has FOUR actor tiers acting in order from the top of the
+hierarchy down: the external replay signal arrives, the NEURON renormalizes, the ASTROCYTE
+territory reallocates, then the COMPONENTS commit within what they were handed. The night is
+PHASED: early cycles DOWNSCALE (reset occupancy, renormalize weight — subtractive, make room),
+later cycles COMMIT (build ceilings for the survivors — additive). It ends emergently.
+
+```
+NIGHT driver:
+    night_energy_spent = 0
+    N_cycles_early = early_phase_frac × estimated_cycles
+    repeat cycle = 1, 2, 3, …:
+        phase = (cycle ≤ N_cycles_early) ? DOWNSCALE : COMMIT
+
+        // ── TIER 0: ASSEMBLY/NETWORK (external) ───────────────────────────────
+        // replay_reweight[s] arrives this cycle: re-presents the day's patterns and
+        // re-weights which synapses the assembly found significant (external signal).
+
+        // ── TIER 1: NEURON (renormalize total weight; drive occupancy downscaling) ──
+        if phase == DOWNSCALE:
+            // multiplicative-global occupancy reset — only CEILINGS will persist
+            for each synapse s:
+                VGCC_active[s]   *= downscale_factor
+                AMPA_surface[s]  *= downscale_factor
+                possible_tag[s]  *= downscale_factor        // medium evidence renormalized too
+            // renormalize total committed weight toward the cell's budget (Tononi-style)
+            if neuron_total_weight > neuron_weight_ceiling:
+                g = neuron_weight_ceiling / neuron_total_weight
+                for each component c in cell: c_structure *= g
+                soma_material += Σ reduction·recycle        // freed material returns to pool
+
+        // ── TIER 2: ASTROCYTE territory (reallocate metabolic support) ─────────
+        // reallocate this cycle's energy/material across the territory by accumulated demand,
+        // re-weighted by replay — the astrocyte is the metabolic arbiter of its synapses
+        for each astrosynapse i:
+            astro_alloc[i] = (astro_territory_demand[i] × replay_reweight[i])
+                             / Σ(astro_territory_demand × replay_reweight)
+        // (astro_alloc biases each synapse's share of the astrocyte's produced batch this cycle)
+
+        // ── TIER 3: COMPONENTS (commit within the allocation handed down) ──────
+        // coherence signal (cross-component) from this cycle's standing tags
+        for each synapse s:
+            coherence_signal[s] = (pre_tag[s], post_tag[s], astro_tag[s] all > tag_expiry)
+                                  ? coherence_factor : 1
+        if phase == COMMIT:
+            run PRE, POST, DEND, SOMA, AXON, ASTRO  NIGHT | cycle    // build ceilings
+        else:
+            run SOMA, ASTRO  NIGHT | cycle (PRODUCE + EMIT only)     // pre-stage material downstream
+
+        // ── termination — emergent, OR of two conditions ──────────────────────
+        night_energy_spent updated by the roots' production this cycle
+        demand_left = Σ all tags > tag_expiry  (system-wide)
+        if demand_left ≈ 0:                            break    // DEMAND exhausted (rested)
+        if night_energy_spent ≥ night_energy_ceiling:  break    // SUPPLY spent (overloaded)
+
+    // ── CODA (once at end of night) ────────────────────────────────────────────
+    // clear DAY traces and the DAY aggregators; occupancy already reset by downscaling
+    all fast_trace, possible_tag, endurance_need = 0
+    soma_Na_inactivation = soma_adaptation = soma_refractory_alignment = 0
+    neuron_activity = 0;  neuron_total_weight = recomputed from surviving structure
+    astro_territory_demand[·] = 0
+    // tags are NOT cleared — unspent tags carry forward, decaying on their slow τ
+    // structure and budget_ceiling PERSIST as the next DAY's ceilings
+    // VGCC_active / AMPA_surface have been returned to baseline by downscaling
+```
+
+Notes. (1) The phasing makes cycles genuinely different: an early cycle reshapes the landscape
+(reset occupancy, renormalize weight, pre-stage material), a late cycle builds on the reshaped
+landscape — so what gets committed depends on the order, and could not be computed in one shot.
+(2) Higher actors never read a component's interior: the neuron renormalizes a sum it accumulated
+from emitted activity; the astrocyte reallocates by demand it accumulated; coherence and replay
+arrive as signals. Locality holds — the system acts locally and consolidates hierarchically.
+(3) Occupancy is reset every night, so each DAY starts from baseline occupancy against whatever
+ceilings persisted: the only thing that carries a day forward is what earned a ceiling.
+
+---
+
+## One-view summary
+
+```
+SEVEN-GROUP GRAMMAR, TWO SCOPES, ONE LADDER
+  RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY
+
+DAY    grammar on OCCUPANCY within two ceilings (structure=strength, budget_ceiling=endurance)
+       bottom-up: consumers act, evidence ascends leaves→roots
+       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  enacted by a HIERARCHY of actors (not the DAY components alone), PHASED:
+       assembly/network replay (external) → NEURON renormalize total weight + downscale occupancy
+       → ASTROCYTE territory reallocate → COMPONENTS commit ceilings within what's handed down
+       early cycles DOWNSCALE (reset occupancy multiplicatively-global, make room),
+       late cycles COMMIT (build ceilings for survivors)
+       higher actors ACCUMULATE aggregate traces by DAY, ACT by NIGHT (locality holds)
+       ends when DEMAND exhausted (no tag stands) OR SUPPLY spent (night energy used)
+       what persists must EARN it: occupancy resets to baseline, only CEILINGS carry;
+       unspent tags carry to next night; material recycles, ENERGY does not (arrow of time)
+RULE   the system ACTS LOCALLY (DAY, local components) and CONSOLIDATES HIERARCHICALLY (NIGHT)
+FLOWS  every flow has a timescale; shipment is transit-delayed (distal fills over cycles)
+LOCAL  every group uses only own state + arrived signals; RECEIVE/EMIT are the only crossings
+```

elements/neuron/appunti/old/2026-06-30-logic-principles-of-the-expression_v4.md

@@ -0,0 +1,571 @@
+# Logic Principles of the Tripartite Synapse Model
+
+These are the principles that govern the model's logic — not the syntax in which it is
+expressed, but the reasoning that shapes every variable, every behavior, every transition.
+
+A note on language. This document does not say "the system." There is no system — only local
+components, each reading arrived signals and acting on its own state. "System," "whole,"
+"network," "the organism's memory" are names applied from outside, by us, describing what
+coupled local components do together. The first principle states this; the rest honor it by
+never speaking in the voice of a whole that does not exist. Where a sentence seems to want "the
+system does X," it is rewritten as "local components, contextualized thus, do X locally" —
+because the form of the document should enact its central claim, that locality goes all the way
+down and all the way up, with no privileged vantage anywhere inside.
+
+The nine categories run foundation-first. The closing category — the Three-Phase Ring — is the
+integrator: it shows how a single cycle of ACTION, EVALUATION, and PREPARATION, run locally by
+every component and turned in two directions (outward by DAY, inward by NIGHT), is where all the
+flows the earlier categories describe actually happen in time. It comes last because it uses
+everything established before it. Its sharpest claim: a phase is a *role*, not a fixed event, so
+the same physical machinery — a release, a structural change — serves as ACTION in one scope and
+EVALUATION in the other, and the two scopes enter the ring at different phases. A vocabulary note
+on motion: causation *circulates* across scales (category VI); the ring *turns* across phases
+(category IX). Two different loops, two different words, kept distinct.
+
+---
+
+## I. There Is No System; Holism Is Real but Only Described
+
+**There is no system — only local components.** Nowhere in the model is there a controller, a
+global plan, a representation of the whole, or a vantage from which the whole is seen. There are
+only components, each reading the signals that physically reached it and acting on its own state.
+Every behavior is local; every evaluation uses only local state and arrived signals; every trace
+is a local record; every commitment a local draw on a shared pool. "System" is our word for the
+aggregate, spoken from outside. No component is the system, occupies its standpoint, or can read
+it — not the smallest bouton and not the highest integrating actor.
+
+**And yet what we describe as holism is real.** Memory, rhythm, selection, consolidation,
+sparsification — these are real behaviors, not illusions. The puzzle is that they are real
+without any whole existing to bear them. The resolution: they are *enacted* by coupled locals,
+never *encoded* in any one of them or in any representation. The holism is in the doing — the
+ongoing competitive, signal-mediated, scope-alternating process of many local components — not
+in any part and not in any model the parts contain.
+
+**What couples the locals is what we then describe as a whole.** Three couplings do all the work.
+*Shared pools*: the only thing every component touches is the finite resource it competes for;
+when one draws, the others have less, when one returns, the others have more — local actions
+become mutually consequential through a common, capped resource. *Cross-scale coincidence*: a
+lasting change requires confirmations from larger scales that no component can produce for itself,
+so every lasting change records an agreement across scales that no single scale authored.
+*Signals*: components cannot read each other, but they emit and receive, so they are coupled
+without any one gaining access to another's interior. Through these three, purely local action
+acquires what we describe — from outside — as global organization.
+
+**The properties we call holistic belong to no component.** Rhythm, equilibrium, memory, the
+joint selection for significance-and-sustainability — none exists in any single component. They
+are descriptions of the coupled population over the DAY/NIGHT alternation. The gap between "what
+a component knows" (only its own state) and "what we describe the population as doing" (choosing
+what to keep) is not bridged by any component knowing more. It is bridged by the coupling itself.
+Understanding, here, is enacted, not encoded — and "the system understanding" is only ever our
+shorthand for coupled locals enacting, faithfully local at every step, holistic only in our
+description.
+
+**Even the cycle is local.** Each component runs its own three-phase ring (category IX), its
+phase boundaries set by its own trace decays, not by any shared clock. There is no global cycle
+any more than a global controller — only many local rings, loosely coupled through shared pools
+and signals, which we describe together as "the rhythm." The turning is real in each component;
+the collective rhythm is our description of many local turnings.
+
+---
+
+## II. Two Contextualizations, and the Loop Between Them
+
+**DAY and NIGHT are not two phases of a system; they are two contextualizations of the same
+local components.** A component does one kind of thing always: it reads arrived signals and acts
+on local state. What changes between DAY and NIGHT is the *context* that fixes what those signals
+mean, who the component's counterparties are, and what is scarce. By "DAY" we name the
+contextualization in which the relevant environment is the external world and the component's
+information is about exogenous events. By "NIGHT" we name the contextualization in which the
+relevant environment is the internal economy and the information is about endogenous
+resource-state. The component cannot tell which it is in — it has no access to "the scope" any
+more than to "the system." It reads local signals, and context makes them mean what they mean.
+
+**Each contextualization has its own environment and its own information.** NIGHT is not the
+absence of an environment — it is interaction redirected from the world to the self. By day a
+component interfaces outward, perceiving sensory-driven events and reward; by night it interfaces
+inward, perceiving how much resource reached it, what its peers are claiming, what coheres. Both
+are full perceive-act loops against a real environment. Resource levels and demand-signals are
+the night's perceptual field exactly as glutamate and dopamine are the day's. "Internal" and
+"external" are relative to the subject one fixes; from a component's own standpoint there is only
+"my environment" — the signals reaching me — which happens to be the world by day and the economy
+by night.
+
+**A component is thus two contextualizations sharing one structure.** By day it is an
+environmental interface; by night an economic agent. The two share only the structure, and the
+structure is exactly what carries between them: the night-agent builds the ceiling the day-
+interface will operate within, and the day-interface generates the evidence (the tag) that
+authorizes the night-agent to build. The tag is information becoming a resource-claim at the
+boundary — the single unit that crosses from the day's information-context to the night's
+resource-context.
+
+**The move between the two is an emergent local transition, not an imposed clock.** There is no
+global day/night switch. Each component enters its NIGHT when its own activity is low and an
+arrived sleep-pressure signal is high, and returns to its DAY when that signal falls. Both
+conditions are read locally — own activity, arrived signal — so the transition is itself a local
+decision. Components therefore cross over at different times: a wave, not a switch (local sleep).
+The signal that carries them is itself the product of locals: activity generates fatigue; fatigue,
+integrated by one component (the hypothalamic actor) that does nothing but integrate fatigue and
+emit pressure, raises sleep-pressure; high pressure plus a component's own quiet opens its
+restructuring window; restructuring discharges fatigue; discharge lowers pressure; the component
+re-enters DAY. DAY and NIGHT are the two phases of one homeostatic loop the local components run
+on themselves — neither imposed from outside nor scheduled from above. The component never knows
+it is "in NIGHT"; it reads a signal level and its own activity, and what results we call night.
+
+**The mechanistic root of the alternation: behavior and restructuring exclude each other.** A
+component cannot rebuild its structure while it is busy behaving — the two compete for the same
+substrate. Only when its activity is low does it have the access to its own architecture that
+restructuring requires. The brief low-activity gaps within a day permit small adjustments; the
+sustained, widespread quiet that the sleep-pressure signal creates permits the large ones. NIGHT
+is not an arbitrary time for consolidation — it is the condition under which consolidation is
+*possible*, because quiet is what grants a component access to itself.
+
+**Two distinct couplings join the scopes — do not conflate them.** The scopes are connected in
+two independent ways. The *fatigue loop* is the **switch**: it controls *when* a component crosses
+between DAY and NIGHT (activity → fatigue → sleep-pressure → transition), a purely temporal
+control carrying no content. The *evaluation handoff* is the **payload**: it passes *what* each
+scope leaves for the other (the tag minted by day's evaluation, consolidated by night; the
+structure minted by night's evaluation, read by the next day — see category IX). One says when to
+switch; the other says what crosses. A reader who merges them loses the fact that a component
+could switch scopes with nothing to hand off (a quiet day leaves no tag) or hold a rich payload
+that waits several switches to be honored (a tag consolidated over several nights). Switch and
+payload are orthogonal.
+
+---
+
+## III. Locality and Signals
+
+**Only local evaluation.** Every decision a component makes — to act, to deposit a trace, to
+register an interrupted success — uses only information physically present in it. It cannot read
+another component's interior. The presynapse does not know the postsynapse's calcium; the
+dendrite does not know which distal spines are active; the astrosynapse does not know whether the
+postsynapse is waiting. Each judges from its own state alone.
+
+**A component cannot read the whole, either.** The completion of locality: not only can no
+component read another's interior, none can read "the system," "the scope," or the global state.
+There is no aggregate vantage available anywhere inside — not even to the integrating actors, who
+read only the summed emissions that reached them and emit signals in turn, with no more access to
+the whole than a bouton has. Locality holds up the hierarchy as strictly as across it.
+
+**Cross-component influence travels only as signals that arrive and become local.** Information
+crosses a boundary only by being emitted — feedforward transmission, retrograde messengers,
+neuromodulatory and sleep-pressure broadcast, the demand and recycled resource of the night
+economy. A signal in transit is invisible; a signal that has arrived is local and can be read.
+Downstream reaches upstream by emitting; upstream never reaches into downstream. Every coupling
+in the model is of this form — an emission that becomes, on arrival, another component's local
+state.
+
+**Everything emits; nothing is a pure sink.** No component only consumes. Each, whatever it
+receives, emits something a neighbor will read — its transmitter, its retrograde feedback, its
+fatigue, its demand, its recycled material, or simply its activity for an integrating actor to
+sum. The direction of emission reverses with context (see the two Logic panels): outward and
+downstream by day, inward and upstream by night. But the invariant holds in both — there are no
+leaves and no sinks, only a reversal of which way "out" points.
+
+---
+
+## IV. Resource and Conservation
+
+**Nothing is free.** Every behavior consumes a resource. There is no operation that does not draw
+something down. This is not a constraint added on top of the logic — it is its foundation.
+Selectivity, competition, and forgetting all follow from the single fact that resources are
+finite.
+
+**Resources are redistributed, not created.** The pools are bounded by external ceilings. Within
+them, resource is only moved — from one site to another, from a dismantled structure back to the
+pool. No internal process manufactures capacity; it only reallocates. A gain anywhere is paid for
+by a loss elsewhere — coupling that is not designed but is the automatic consequence of drawing
+from a common pool.
+
+**Two resources, two conservation laws.** Energy is a flow — produced and consumed, gone after
+use. Material is a stock — incorporated into structure and recovered when structure is dismantled.
+Different sources, different recovery. A behavior can be energetically affordable yet materially
+limited, or the reverse. Keeping them distinct is what makes the accounting honest.
+
+**Material circulates; energy ratchets — energy is the one irreversible flow.** This is the sharp
+form of the distinction, and it is the arrow of time. Material cycles indefinitely: spent into a
+ceiling, recovered when that ceiling decays, returned to be spent again. Energy does not. It is
+produced fresh at the roots, burned irreversibly on the work of building and behaving, never
+recovered. Everything else cycles or relaxes — traces decay and reform, occupancy fills and
+drains, material recycles — but energy only ever goes down per unit produced, capped externally by
+glucose. The total learning the local components can ever do is bounded by their lifetime energy
+throughput, and no internal cleverness lifts that bound. The irreversibility of energy is what
+makes them age.
+
+**Every economy has a single capped root.** Each resource traces to one producer with a hard
+ceiling — the astrocyte cell body for synaptic energy, the soma for neuronal material. Everything
+downstream competes for shares of that capped production. The ceiling is set from outside and is
+the ultimate arbiter of how much can be done.
+
+**Scarcity is what forces choice, and choosing is learning.** What is consolidated is the outcome
+of bounded demand (the standing tags and endurance needs) meeting bounded supply (the energy and
+material produced each night), and the match need not clear — a night may run out of energy before
+it runs out of demand. Unmet demand is not discarded but carried forward and retried. The
+selective pressure is, at bottom, this repeated failure of supply to fully meet demand: it is
+*because* not everything can be afforded that there must be choosing, and the choosing is the
+learning.
+
+---
+
+## V. The Timescale Ladder
+
+The spine. Every quantity sits on one of four nested tiers, and timescale is not incidental to it
+— timescale *is* its meaning.
+
+**Four tiers.** FAST traces (ms–s): residual calcium, synaptic current — the immediate response.
+MEDIUM occupancy and evidence (s–min): the filled receptor surface and channel coupling, the
+accumulating possible-tag, the endurance need. The SLOW tag (hours): the validated bridge to
+consolidation. PERSISTENT capacity (written only at night, drifting over days): the structure and
+budget ceilings. A quantity's decay constant is what it means — a fast-decaying quantity is a
+momentary signal, a slow one a commitment, a non-decaying one a capacity. Putting two timescales
+in one variable destroys both meanings, which is why a quantity carrying both a momentary and a
+lasting role is split into two.
+
+**Capacity and occupancy are two rungs, not a separate principle.** What was once stated as
+"night builds containers, day fills them" is simply this: the PERSISTENT tier is written at night
+and bounds the MEDIUM tier, which fills by day within it. The same physical quantity — receptor
+count, vesicle coupling, fuel level — has a fast/medium component (how full, occupancy) and a
+persistent component (how big, capacity), governed by different processes at different tiers.
+Short-term change is occupancy; long-term change is capacity; they never do each other's job.
+
+**Two capacities, two drives, one pool.** Structure is the capacity for strength — how powerfully
+a behavior can act. Budget capacity is the capacity for endurance — how long it can be sustained.
+Both are persistent ceilings, both filled competitively at the medium tier, both drawn from the
+same finite material and energy, so strength and endurance compete. A ceiling of either kind is
+never free even by day: filling it costs a competitive share of a shared pool, and a high ceiling
+makes a large standing claim satisfiable only by out-competing neighbors. Capacity that cannot be
+filled is wasted.
+
+**Structure shapes form, not just maximum.** A ceiling does not merely cap — it conditions the
+transfer function at every moment. Tighter calcium-channel coupling makes each spike more reliably
+coupled to release; more anchoring slots convert each pulse more faithfully to current; tonic
+co-agonist keeps the gate primed. The persistent tier shapes the quality of behavior continuously,
+not only its peak.
+
+**The tiers are a ladder: each rung's output is the next rung's input, in both directions.**
+*Evidence ascends* — fast traces accumulate into medium evidence, which bridges (on validated
+coincidence) into the slow tag, which commits at night into persistent capacity; nothing reaches
+a slower tier without accumulating through the faster ones. *Capacity descends* — persistent
+structure bounds medium occupancy, which bounds fast behavior; the ceiling at each level was set
+by the level above, on a slower timescale. Both the strength pathway (trace → possible-tag → tag
+→ structure) and the endurance pathway (trace → endurance-need → budget ceiling) are the same
+upward climb, differing only in what validates it: associative dopamine for strength, homeostatic
+fuel-shortfall for endurance.
+
+**A pool's recovery timescale is what its exhaustion means.** The ladder governs pools as well as
+traces. A *fast* pool (the readily-releasable vesicle pool) depletes and recovers fast, so its
+shortfall is transient — short-term depression, self-correcting once activity slows. A *medium*
+pool (operational budget) recovers at the medium scale, so its shortfall is a standing constraint
+worth recording as endurance evidence. *Persistent* capacity changes only at night, so its
+"shortfall" is a structural limit unfixable in the day. This is why a behavior's failure mode can
+be read off which pool ran dry: fast-pool exhaustion is depression, medium-pool exhaustion is
+endurance evidence, persistent limit is structural. Depletion-and-recovery is the pool-side mirror
+of creation-and-decay — drawn down by behaving, refilled toward a ceiling — and in both, the
+timescale is the meaning.
+
+**The ladder is structure; the ring is timing; they are orthogonal and they compose.** The ladder
+(this category) is about *tiers of persistence* — which quantities last how long, and how capacity
+descends while evidence ascends. The three-phase ring (category IX) is about *phases of a cycle* —
+when a component acts, evaluates, and prepares. These are independent axes: one could have the
+ladder without a cyclic ring (a pure feedforward hierarchy) or a ring without four tiers (a cycle
+at one timescale). They compose in a specific way: the ring's phases are *where the ladder's flows
+occur*. ACTION injects at the bottom of the ladder (deposits the fast trace). EVALUATION enacts
+the up-flow (works the fast trace into medium evidence and the slow tag). PREPARATION enacts the
+down-flow (reads the descended capacity as the readiness the next action runs within). So the two
+pictures are not two names for one thing — the ladder says what persists, the ring says when each
+persistence-flow happens, and evaluation-is-up / preparation-is-down is where they meet.
+
+---
+
+## VI. Causation Circulates — Emergence Up, Constraint Down, Command Nowhere
+
+The model has causation in two directions, and the whole point is that they coexist without
+either becoming control.
+
+**Emergence flows up.** What we describe as global organization — sparsification, normalization,
+winner-take-more, the allocation of fuel — is nowhere computed centrally. It emerges from many
+local components drawing on shared pools. No allocator decides which synapses to fuel; the
+synapses' own demands, each purely local, competing for capped production, produce the allocation.
+No allocator exists; the allocation is real. The local emissions sum, through the pool, into an
+aggregate no component authored.
+
+**Constraint flows down.** An integrating actor holds an aggregate its constituents cannot see —
+total weight, territory demand, accumulated fatigue — and broadcasts it back as a constraint each
+constituent then interprets locally. The neuron, summing emitted activity it never reads interiors
+to obtain, broadcasts a renormalization that each component applies to itself. This is top-down,
+but it is constraint, not command: the higher actor sets a bound; the lower still decides locally
+within it.
+
+**Command exists nowhere.** This is the load-bearing claim. The downward direction never becomes a
+higher component deciding for a lower one, nor a lower one deciding for itself in isolation. No
+actor authorizes its own restructuring — each is put in the position to restructure by the actor
+above it, which holds the aggregate it cannot see and opens the quiet window it cannot open, then
+*broadcasts*, never reaching in. The soma cannot decide within the soma; it is put in position by
+the neuron — which is itself put in position by the integrated fatigue, which is itself the sum of
+what the components emitted. Causation circulates — up as emergence, down as constraint — and the
+circle closes with no controller anywhere on it. Every integrating actor is itself only another
+local component reading summed arrived signals; none is "the system" in disguise.
+
+**The recursive grant repeats at every scale.** The relationship is the same all the way up: the
+astrosynapse is put in position by the astrocyte; the soma, bouton, spine, branch, axon by the
+neuron; the neuron and astrocyte by the hypothalamic fatigue signal; the synaptic strengthening by
+the organism's dopamine and the assembly's replay. Each scale grants its constituents the
+conditions they cannot grant themselves — an aggregate they cannot see, a window they cannot open —
+and grants it by signal, never by reaching in. The hierarchy is real, the circulation is closed,
+and at no point does it produce a seer of the whole or a commander of the parts.
+
+**This cross-scale circulation enters each component's ring at a definite phase.** Causation
+*circulates* across scales (this category); a component's ring *turns* across phases (category IX) —
+two different loops. They meet at a definite point: the downward constraint arrives at the
+component's PREPARATION phase, whose subject is precisely "what is handed down from above," and the
+upward emergence departs as what the component emits during ACTION and commits during EVALUATION,
+which sums into the aggregate the scale above will read. So the vertical arm of the cross-scale
+circulation is lived, inside each component, as the vertical phase of its ring. The three subjects
+of the ring (beside / self / above) are the three ways a component connects to everything else, and
+each of the other categories' flows plugs into the phase whose subject matches it.
+
+---
+
+## VII. Selection and Asymmetry
+
+**Building is the active drive; weakening is its shadow.** All the machinery is oriented toward
+strengthening what is significant and sustaining what is fuel-limited. There is no symmetric
+machinery for weakening. Weakening happens to whatever the building machinery did not select, as a
+consequence of the resources building consumed. The orientation is toward learning; forgetting is
+its cost.
+
+**Depression is never explicit — it is what happens when building does not.** No signal says
+"weaken this." Ceilings of both kinds decay continuously and are held up only by maintenance; when
+building consumes the shared resource, unmaintained ceilings drift down. Depression is the absence
+of maintenance, not the presence of a depression signal — and the same is true of lost endurance,
+idle capacity removed for lack of use, and of occupancy, which drifts back the moment its driving
+trace decays. In ring terms (category IX), this decay lives in the PREPARATION phase: weakening is
+what preparation's settling does to whatever evaluation did not supply enough to maintain. There is
+no weakening phase because weakening is un-honored decay inside the preparing phase.
+
+**Validation enters from beyond the part; the part cannot validate itself.** A component cannot
+know whether its own activity was significant — that information exists only at a larger scale and
+arrives as a signal (the neuromodulatory broadcast for the organism's verdict, replay for the
+assembly's). Cheap reversible change is autonomous; expensive lasting change requires authorization
+that enters from outside the component being changed. This is why lasting change always records a
+coincidence across scales: each scale confirms what the one below cannot know about itself.
+
+**Strength is associative; endurance is homeostatic.** Strength requires significance — the
+dopamine coincidence saying "this was worth saving." Endurance requires only that fuel, not
+structure or significance, was the binding constraint on a forming success — it needs no external
+validation, because metabolic sustainability is not the organism's to judge but the component's own
+to register. Two independent criteria, and selection requires winning on both: activity without
+significance is not saved; significance without sustainable fuel cannot be maintained. The
+conjunction filters for connections both valuable and viable.
+
+**Equilibrium is the residual of imperfection.** Where alignment or balance is reached, the success
+removes the very signal that drove it, allowing slow drift back, which regenerates the signal. The
+soma that aligns to its input rhythm stops generating the mismatch that aligned it, drifts, and
+re-aligns. The component that builds enough endurance stops depleting, loses the signal, and lets
+capacity decay until depletion returns. Each component hovers near its own optimum, never resting
+there, corrected continuously by the small errors its own imperfect state produces. What we
+describe as a stable population is the sum of these local never-quite-settlings.
+
+---
+
+## VIII. Coupling, Openness, and Boundedness
+
+**Couplings create trajectories, not just states.** Some variables, once moved, make further
+movement the same way easier — the astrosynapse wrapping tighter after potentiation, easing future
+potentiation. These self-reinforcing couplings give momentum: components do not merely occupy
+states, they follow trajectories, deepening whatever direction they have begun. The astrosynapse is
+the strongest such coupling — the gain control that reshapes the input itself, amplifying whatever
+trajectory a synapse is on.
+
+**The same signal serves opposite functions through different receivers.** Glutamate spillover
+brakes the presynapse while exciting the astrosynapse — one ligand, two receptor types, opposite
+cascades, simultaneous opposite effects. Function is set by the receiver, not the signal. One event
+coordinates several responses with no coordinating mechanism.
+
+**Metabolic availability is a selective pressure parallel to validation.** Beyond the explicit
+activity-and-reward gating, the bare availability of fuel continuously selects which components can
+participate: one that cannot be fueled cannot generate the activity that would let it be tagged.
+Metabolism silently shapes what can be learned, independent of and parallel to the plasticity
+machinery.
+
+**Finite and open, not infinite and closed.** The components are bounded and their state space is
+bounded, and they receive inputs they cannot generate from within — sensory drive, neuromodulatory
+and replay validation, metabolic supply. Because they are finite, their self-modification generates
+no infinite regress. Because they are open, their highest validation comes from outside any
+component being changed.
+
+**The fixed points are explicit, not hidden.** The quantities the components cannot modify from
+within — thresholds, the vascular ceiling, the neuromodulatory and replay signals — are declared as
+given. They are the boundary with what the components did not set and cannot inspect. Making them
+explicit is the honest acknowledgment that every self-modifying process operates within constraints
+it did not choose. Correctness is never certified internally: whether a change was good is answered
+by the organism's later experience in the world, fed back as signal. The fixed point lies outside —
+the components act, the world responds, and the response, not any internal check, determines what
+was worth keeping.
+
+---
+
+## IX. The Three-Phase Ring, and Its Two Turnings
+
+This is the integrator. Everything above describes *what* flows — resource, evidence, constraint,
+signals, capacity. This category describes *when*: the single cycle each local component turns,
+and how the earlier categories' flows distribute across its phases. One ring, run locally by every
+component, turned in two directions — outward by DAY, inward by NIGHT.
+
+**The ring has three phases, given by the three relationships a component stands in.** A component
+relates to exactly three things — its peers beside it, itself, and what is above it — and the ring
+is one turn through all three:
+
+- **ACTION** (subject: peers, *lateral*). The defining interaction with the component's
+  counterparties. It is punctate — an event — and it deposits a fast trace, the residue the rest of
+  the turn will read.
+- **EVALUATION** (subject: self, *local*, handing to the other scope). In the quiet after the
+  action, the component reads the fast trace and works it up the ladder into slower evidence. It
+  never acts; its product is an inert token minted for the *other* scope.
+- **PREPARATION** (subject: what is above, *vertical*, readying the next action in this scope). As
+  the trace decays, the component settles its pools and gates forward, reads what has descended, and
+  assembles the readiness the next action will run on. Preparation is the sole gateway to action.
+
+The order around the ring is ACTION → EVALUATION → PREPARATION → ACTION. Because it is a ring, no
+phase is first; each turn's preparation feeds the next turn's action, and each turn's evaluation
+reads the action that preceded it. A phase is a *role*, not a fixed physical event: the same
+physical machinery (a release, a structural change) can serve as different phases in different
+scopes, and each scope enters the ring at a different phase — the rotation is worked out in "The
+two turnings" below.
+
+**The ring is necessary; its co-location in one component is not.** What the logic guarantees is
+that the ring *closes* — that every action is evaluated and every action is prepared for — not that
+any single component runs all three phases itself. A component necessarily has ACTION: the local
+act it performs is what makes it a component at all. But the EVALUATION and PREPARATION of that act
+may live in *other* components. Take the calcium channel as a component: its ACTION is letting Ca²⁺
+in — that is its whole local act. It does not evaluate whether the influx mattered (the presynapse
+does, reading the resulting trace) nor prepare its own next opening (its coupling readiness is set
+by presynaptic short-term potentiation, and above that by neuronal provisioning). The channel is
+almost pure action; its evaluation and preparation sit in the components around and above it. Yet
+the ring is intact — the influx is acted, evaluated, and prepared for — merely spread across three
+components rather than turned within one. So the ring is a property of *coupled components*, not of
+the individual: a component contributes its action, its neighbors and superiors contribute the
+evaluation and preparation that action requires, and together they close a ring none of them runs
+alone. This is the same frame as category I — there is no ring-bearing "self," only local
+components whose coupled actions we describe as one closing ring.
+
+**Action is always local; evaluation and preparation may be local or contextual.** This is the
+axis beneath the previous point. A phase is *local* when the acting component supplies it itself,
+*contextual* when a surrounding or higher component supplies it. Evaluation and preparation come in
+both forms: the presynapse evaluates its own release and prepares its own next release (local),
+while the calcium channel's influx is evaluated by the presynapse and prepared by neuronal
+provisioning (contextual). Action admits no such split — it is always local, and necessarily so.
+A component can hold an aggregate and evaluate a neighbor's trace on its behalf, or provision a
+neighbor's readiness; but it cannot *act on a neighbor's behalf*, because the action simply is the
+local event occurring in that component. To perform another's action would mean it was never that
+component's action to begin with. Acting-for-another is not action but signalling. So the one phase
+that can never be contextual is action, and this falls directly out of what action is — which is
+why every component necessarily has its own action, while its evaluation and preparation may be
+scattered into its context.
+
+**The phases are event-delimited and decay-timed, never clocked.** A phase has no fixed duration.
+The action is the boundary where preparation ends and behaving begins; the fast trace's decay below
+threshold is roughly where evaluation ends and preparation resumes. The quiet interval between
+actions — a component's refractory-like period, whether literal refractoriness at the soma or the
+NOT-active steps at the bouton — is where evaluation and preparation live, and its length is set by
+the firing pattern. A fast train compresses preparation to nothing (no time to refill: depression);
+sparse action gives preparation its full extent. Timing here is chemistry, not a timer (category V).
+
+**Evaluation and preparation share the fast trace but send it two ways.** The same trace the action
+deposits is read by both: evaluation reads it for *significance* (climbing toward the tag, for the
+other scope), preparation reads it for *readiness* (tuning the next action's timing and thresholds,
+in this scope). The soma makes this visible — its nuclear-calcium climbs toward the tag
+(evaluation), while its inactivation, adaptation, and alignment traces tune the next spike
+(preparation) — all from the one spike's deposit. Evaluation looks up and across scopes; preparation
+looks around the ring to the next action.
+
+**Evaluation reaches the next action only through preparation.** Evaluation never acts; it lays down
+inert evidence. For that evidence to shape a future action it must pass through preparation, on one
+of two timescales. Within a scope: evaluation's medium products (possible-tag, endurance-need)
+become preparation's inputs, folded into near-term readiness. Across scopes: evaluation's slow
+product (the tag) waits, is consolidated into structure, and structure is read by the next scope's
+preparation. Either way — evaluation proposes, preparation disposes, action runs. The one-way ring
+is what separates gathering from acting by exactly the time it takes preparation (or the night) to
+honor what evaluation proposed; that separation is where deliberation lives.
+
+**The coincidences of the action sort by timescale.** Where a component detects the coincidences
+that authorize a lasting change depends on whether they must be instantaneous. Coincidences that
+must be simultaneous are detected *in ACTION* by the receptors themselves — the postsynaptic NMDA
+gate passing large calcium only when presynaptic glutamate, astrocytic co-agonist, and local
+depolarization align, amplified by the descended back-propagating spike. Coincidences that can be
+integrated over the quiet are detected *in EVALUATION* by trace accumulation — the organism's
+dopamine gating the tag over the following interval. Same logic (require several partners to align),
+sorted into the phase whose timescale it fits: instantaneous coincidence is action, integrable
+coincidence is evaluation.
+
+### The two turnings
+
+One ring, turned in two directions. The three phases and their subjects are invariant across DAY
+and NIGHT; what rotates is the *content* flowing through them (information by day, resource by
+night) and — the sharp point — *which physical event counts as which phase*. From a component's
+own standpoint there is no "open" or "closed" scope: each turning runs against *its* environment,
+the world by day and the economy by night.
+
+**The same physical event is ACTION in one scope and EVALUATION in the other.** This is the
+deepest form of the duality. Transmitter release is the day's ACTION — the defining outward deed,
+transmitting to the world — and the fast trace is its byproduct, later evaluated. But the *same
+release*, run at night, is EVALUATION: the component releases not to transmit but as a *probe*, to
+read its own fast trace as a measure of how much it participates in the re-evoked pattern. And the
+structural change, which the day can only *mark* (the tag is an inert claim pointing at a
+restructuring that never happens by day), is the night's ACTION — its defining, irreversible deed.
+So the defining act of each scope is the assessment-instrument of the other: release is
+day-action / night-evaluation; restructuring is night-action / day-inert-mark. The scopes do not
+merely run the ring in two directions — they swap which event is the deed and which is the
+measurement. Because it is a ring, each scope simply enters at a different phase: the day enters at
+ACTION (act, then evaluate, then prepare — it must act first, the world will not wait); the night
+enters at PREPARATION (prepare, then measure, then act — it can afford to look before it leaps).
+
+**DAY — the ring turned outward.** PREPARATION reads the descended structure and refills the pools;
+ACTION is the cleft exchange (release, integrate, clear) against the world, leaving the fast trace;
+EVALUATION climbs the ladder to the tag — significance worked up, minted for the night. Currency:
+information, cheap, gathered passively. Ladder direction: evidence ascending. Token minted: the
+**tag**.
+
+**NIGHT — the ring turned inward, as a sequence of replay cycles.** PREPARATION imports material
+and energy and *primes* the component's own spontaneous threshold from its own standing tag (a high
+tag lowers the threshold, raising occupancy). ACTION is the structural change — general homeostatic
+lowering, then rebuilding where the tag still stands and participation was confirmed, consuming the
+tag on the build. EVALUATION is the probe: the component spontaneously releases/fires and reads its
+fast trace as *participation* in the re-evoked pattern — no dopamine, because significance is
+already settled; this measures only circuit centrality. Currency: resource, scarce. Ladder
+direction: capacity descending. Token minted: the **structure**.
+
+**Replay is how the undifferentiated tag is spent on specific behaviors — and it needs no
+orchestrator.** A component's tag accumulates by day from *many* behaviors into a single
+magnitude — how much change it needs, stripped of what for. It cannot spend that lump correctly in
+one commit (that would build a blend serving no behavior). Replay re-presents the day's behaviors
+one at a time so the lump can be allocated to each. The mechanism is local and emergent: at night,
+freed from external drive, components spontaneously fire; where a tag has lowered a component's
+threshold, intrinsic fluctuation ignites it, and the activation propagates through the *same
+pathways used by day*, re-evoking the pattern — but only where *every* link is primed (each
+component's own tag lowered its own threshold), so a pattern carries only if it was significant all
+the way around. This coherence is mechanical, not checked: an un-primed link breaks the loop at the
+gap. The re-evoked components run their *structural* logic, not their significance logic — they are
+not re-asking "did this matter" (settled) but "how much do I change for this." The replaying
+assembly is not an actor; it is the coincidence of many components' own lowered thresholds
+propagating through recurrent coupling — holism enacted, not encoded (category I).
+
+**Why night cycles: the tag depletes, and depletion re-sorts the queue.** Each re-evocation lets
+the participating components allocate a *slice* of their tag to that behavior and consume it — which
+raises their thresholds back, so that pattern steps aside and the *next*-deepest tag surfaces on the
+next cycle. The night sweeps its repertoire in rough order of tag depth, strongest most often, each
+pattern depleting and yielding to the next, exactly as a vesicle pool depletes and refills to
+schedule release one scale down. This is why the tag is spent incrementally across cycles rather
+than all at once, why strong memories replay repeatedly, and why consolidation is a gentle settling
+over many cycles (and many nights) rather than a single commit. The night ends when the tag is
+exhausted (well-rested — every significant pattern replayed and its structure rebuilt) or the
+night's energy is spent (overloaded — unspent tags carry forward). A pattern that never re-evokes
+before its tag decays is simply never built — which is how the turning forgets.
+
+**The two turnings are stitched by evaluation, and the fatigue loop switches between them.** Each
+scope's EVALUATION mints the token the *other* scope will consume: day-evaluation mints the tag
+that night spends; night-evaluation (participation) gates the structure that the next day operates
+within. This *payload* handoff is distinct from the *switch* — the fatigue loop (category II) that
+decides *when* a component crosses between scopes. One says what crosses; the other says when to
+cross; they are orthogonal (category II). So the DAY/NIGHT alternation is one ring, entered at two
+different phases, handing off to itself through evaluation, switched by fatigue — not two separate
+machines.

elements/neuron/appunti/old/presynapse old.md

@@ -0,0 +1,553 @@
+---
+include_toc: true
+---
+
+# presynapse.md
+
+## PRESYNAPSE
+
+Expansions and modulations:
+  - is expanded and developed by: [AXON](axon.md)
+  - is tuned by: [ORGANISM](../../organism.md), organs, modules
+  - expands and tunes: [PRE_VGG](pre_vgcc.md)
+  - develops _Ca2, _Rrp
+
+```Gen
+
+include: 
+  pre_vgcc.md
+
+PRESYNAPSE
+
+  type: comprehension
+
+  expansion:
+
+    // il tub serve al tuning
+    _@pre_vgcc: TUB [ comprehension: PRE_VGCC, full: 10x, active: 5x, empty: 2x ]
+
+  intrication:
+
+    // Scope
+    !DAY: INTRICATION [ ref: &ORGANISM.!DAY ]
+    !NIGHT: INTRICATION [ ref: &ORGANISM.!NIGHT ]
+
+    // Context  
+    *AP: INTRICATION [ ref: &SOMA.*AP ]
+    *TunPossible: INTRICATION [ ref: &NEURON.*TunPossible ] 
+
+    // Tub
+    _NT: INTRICATION [ ref: &ASTROSYNAPSE._NT ] 
+    _ATP: INTRICATION [ ref: &ASTROCYTE._ATP ] 
+    _eCB: INTRICATION [ ref: &POSTSYNAPSE._eCB ]
+
+  instantiation:
+
+    // Context
+    *VcggIncrease: CONTEXT []
+    *VcggDecrease: CONTEXT []
+    *Ca2PrePreActiveDecrease: CONTEXT []
+    *Ca2PreActiveDecrease: CONTEXT []
+    *RrpPreActiveDecrease: CONTEXT []
+    *RrpPreActiveDecrease: CONTEXT []
+
+    // Tub
+    _Ca2: TUB [ full: 60x, active: 30x, empty: 0x ]
+    _Rrp: TUB [ full: 30x, active: 15x, empty: 0x ]
+    _Rp: TUB [ full: 30x, active: 15x, empty: 0x ]
+    _CaTracesHigh: TUB [ full: 50x, active: 0x, empty: 0x ]
+    _CaTracesMedium: TUB [ full: 50x, active: 0x, empty: 0x ]
+    _CaTracesLow: TUB [ full: 50x, active: 0x, empty: 0x ]
+
+    _Ca2FullDev: TUB [ full: 100x, active: _Ca2.full, empty: 40x ]
+    _RrpFullDev: TUB [ full: 100x, active: _Rrp.full, empty: 40x ]
+    # serve al DEV
+
+    // Behaviour
+    $: BEHAVIOUR [ behaviour: MAIN ]
+    $: BEHAVIOUR [ behaviour: TUN_VGCC ]
+    $: BEHAVIOUR [ behaviour: DEV_TUBS ]
+```
+
+### !DAY | MAIN
+
+```Gen
+MAIN
+
+  type: behaviour
+
+  within_scope: !DAY
+
+  snippet:
+    // *AP
+    @: ACCUMULATOR [ snippet: NTreleaseLow, rf: active 12x ]
+    @: ACCUMULATOR [ snippet: NTreleaseMedium, rf: active 9x ]
+    @: ACCUMULATOR [ snippet: NTreleaseHigh, rf: active 6x ]
+
+    @: ACCUMULATOR [ snippet: TracesAccLow, rf: active 3x ]
+    @: ACCUMULATOR [ snippet: TracesAccMedium, rf: active 6x ]
+    @: ACCUMULATOR [ snippet: TracesAccHigh, rf: active 10x ]
+
+    // NOT *AP
+    @: ACCUMULATOR [ snippet: eCBClearenceMedium, rf: active 24x ]
+    @: ACCUMULATOR [ snippet: eCBClearenceLow, rf: active 48x ]
+
+    @: ACCUMULATOR [ snippet: RPShuttleLow, rf: active 24x ]
+    @: ACCUMULATOR [ snippet: RPShuttleMedium, rf: active 48x ]
+
+    @: ACCUMULATOR [ snippet: RefillGlutamine, rf: active 24x ]
+
+    @: ACCUMULATOR [ snippet: TracesClearance, rf: active 30x ]
+```
+
+**Tubs:**
+
+- **\_Ca2**: Calcium Ion entering the Presynapse when VCGG open that influence NT release. Normally returns to ~0 between spikes; stays elevated when pumps fail. They are key to check the concentration, release NT and modulation
+- **\_Rrp**: Readily Releasable Pool: The Readily Releasable Pool consists of the vesicles that are "docked" and "primed" at the active zone of the synapse. This pool is very small (usually only about 0.5% to 5% of total vesicles) and can be exhausted quickly during high-frequency firing, leading to "short-term depression" of the signal. Here we consider them as NT ready to be released.
+- **\_Rp**: Reserve Pool: The bulk of the vesicles held further back in the terminal, often tethered by a protein called synapsin. These are only mobilized during intense, prolonged stimulation. This makes up the vast majority of the vesicles (up to 80% or 90%). Here we consider them NT in reserve that can be transfered to RRP and created using Glutamine from Astorcyte.
+- **\_NT**: Neuro Transmitter, released in the synapse by the vescicles. The release increses NT and decreases RRP
+- **\_CaTracesXXX**: sono le tracce di permanenza della concentrazione di Ca2. Servono alla modulazione (TUN)
+- **\_eCB**: retrograde signal updates from postsynapsis (postsynaptic input)
+
+#### *AP
+
+Il rilascio di NT lo facciamo nel contesto di AP. Biologicamente dovrebbe avvenire solo in base alle concentrazioni, quindi anche al difuori degli AP.
+
+RF di interacting deve essere MOLTO piu' basso di un RF di AP. In maniera da essere attivo varie volte nel contesto di un episodio di AP. Il che ha senso perche' un AP e' SOMA ad un tempo piu' alto che i comportamenti di PRE. Questo poi per permettere la diversa contestualizzazione degli episodi di NTrelease, a piu' o meno alta velocita'.
+
+![nt-release.png](.attachments/nt-release.png)
+
+Non consideriamo le vesicles come liberate, ma direttamente gli NT. Questo permette di gestire la quantita' rilasciata di NT, invece di gestire un numero di vescicles. Nella realta' ciascuna vesicle contiene migliaia di NT. Qui mettiamo un floor a questo tipo di comprensione.
+
+Ci sono 4 casi che dipendono da RRP, Ca2 e indirettamente da concentrazione di NT nella SYN che diventa mGLur che limita in VGCC l'entrata di Ca2. L'idea e' che la quantita' di RRP sia il driver principale. Gli NT liberati sono di piu' al crescere di RRP e Ca2 e di meno (indirettamente) al crescere della concentrazione di NT gia' liberati nella SYN. Gli NT nella sinapsi fanno da moderazione alla ulteriore liberazione di NT, ma non bloccano mai totalmente. NT suppression only matters when everything else is already at maximum, which is exactly the biological purpose: it prevents runaway release during peak activity, not during moderate activity.
+
+---
+
+NT empty. Qui siamo contestualizzati se Ca2 full, il che dovrebbe significare indirettamente che non ci sono NT nella SYN.
+
+In tutti i casi di NT
+
+##### NTreleaseLow
+
+```Gen
+NTreleaseLow
+
+    type: accumulator
+    in_context: *AP
+
+    hypothesis: _Ca2 mediumness AND _Rrp mediumness AND NOT _ATP empty 
+      action: [ _Rrp decrease, _NT increase, _ATP decrease ]
+      trace: None
+```
+
+##### NTreleaseMedium
+
+```Gen
+NTreleaseMedium
+
+    type: accumulator
+    in_context: *AP
+
+    hypothesis: ( _Ca2 fullness AND _Rrp mediumness ) OR 
+                ( _Ca2 mediumness AND _Rrp fullness ) AND
+                NOT _ATP empty 
+      action: [ _Rrp decrease, _NT increase, _ATP decrease ]
+      trace: None
+```
+
+##### NTreleaseHigh
+
+```Gen
+NTreleaseHigh
+    type: accumulator
+
+    in_context: *AP
+
+    hypothesis: _Ca2 fullness AND _Rrp fullness  AND 
+                NOT _ATP empty
+        action: [ _Rrp decrease, NT increase, _ATP decrease ]
+        trace: None
+```
+
+##### Ca2TracesAccLow
+
+Serve a:
+
+- fare il tuning dei VGCC
+- dare la velocita' al trasporto di vesicles da RP a RRP, anche se non avendo ancora compreso \_ATP, la velocita' non cambia molto la sostanza.
+- le tracce vengono eliminate quando il neurone e' in pausa, lontano da uno spike train, *TunPossible
+- Abbiamo 3 tracce, high, medium and low. Andiamo a verificare una combinazione di queste per fare la modulazione
+- RF e' a 10, questo dovrebbe essere un RF di campionamento durante *AP context che dovremmo assicurarci sia tipo 100. Il che implicherebbe 10 campionamenti.
+- The biological meaning is that a synapse that has just been through a burst is primed for fast recovery — the molecular machinery for vesicle docking is already engaged, calcium-dependent priming factors are still elevated, and the system is in a ready state. A synapse that has been silent for several seconds has cooled down and replenishes slowly.
+- So after one second of silence CaTrace has fallen to ~37% of its peak value, after two seconds to ~14%, after three seconds to ~5%. It asymptotes toward zero but never exactly reaches it. Between spikes, Ca2 falls toward zero as the pumps clear it. The result is that CaTrace encodes not the instantaneous calcium level but the recent history of calcium activity — a smoothed, time-averaged measure of how active the synapse has been over the past one to two seconds.
+
+```Gen
+Ca2TracesAccuLow
+    type: accumulator
+
+    in_context: *AP
+
+    hypothesis: _Ca2 emptiness
+      action: [ _CaTraceLow increase ]
+      trace: None
+```
+
+##### Ca2TracesAccMedium
+
+```Gen
+Ca2TracesAccMedium
+    type: accumulator
+
+    in_context: *AP
+
+    hypothesis: _Ca2 mediumness
+      action: [ _CaTraceMed increase ]
+      trace: None
+```
+
+##### Ca2TracesAccHigh
+
+```Gen
+Ca2TracesAccumulationHigh
+    type: accumulator
+
+    in_context: *AP
+
+    hypothesis: _Ca2 fullness
+      action: [ _CaTraceHigh increase ]
+      trace: None
+```
+
+#### NOT *AP
+
+##### eCBClearance
+
+eCB dipende da POST. Tende a modulare l'entrata di Ca2 degli VGCC.
+
+Qui non facciamo un flush di eCB, riduciamo ogni mezzo secondo (context) di un RF di questo episodio.
+
+```Gen
+eCBClearance: ( active: 24x ) # Slow
+    type: accumulator
+
+    in_context: NOT *AP
+
+    hypothesis: NOT _eCB empty
+      action: [ _eCB decrease ]
+      trace: None
+```
+
+##### RPShuttleLow
+
+This happens in the seconds loop, once per second.
+
+The "Hard Bottleneck" State. Recruitment is throttled by a lack of signal, a lack of supply, or a lack of space. If even one of these "Near-Stop" conditions is met, the rate cannot exceed "Slow," regardless of the other two conditions.
+
+Rate: 0.00 – 0.25
+
+```Gen
+RPShuttleLow
+    type: accumulator
+
+    in_context: NOT *AP
+
+    hypothesis: _CaTraceLow fullness OR 
+                _RP emptiness OR 
+                _Rrp fullness
+      action: [ _RP decrease, _Rrp increase ]
+      trace: None
+```
+
+##### RPShuttleMedium
+
+The "Sub-Optimal" State. The machinery is working, but it's held back by partial limitations. This covers cases where the signal is steady but the "piston" isn't firing at full speed, or where a high vacancy in the RRP (emptiness) forces a low signal to work a bit harder.
+
+Rate: 0.50 – 0.97
+
+```Gen
+RPShuttleMedium
+    type: accumulator
+
+    in_context: *AP
+
+    hypothesis: ( _CaTraceMedium fullness AND _RP mediumness AND _Rrp mediumness ) OR 
+                ( _CaTraceHigh fullness AND _RP mediumness AND _Rrp mediumness ) OR   # signal boost
+                ( _CaTraceMedium fullness AND _RP fullness AND _Rrp mediumness ) OR   # supply boost
+                ( _CaTraceMedium fullness AND _RP mediumness AND _Rrp emptiness )     # vacancy boost
+      action: [ _RP decrease, _Rrp increase ]
+      trace: None
+```
+
+##### RPShuttleHigh
+
+The "High Performance" State. Multiple systems are optimized, but one is still at a "mediumness" level. This represents an active synapse that hasn't reached its absolute peak because either the supply is only 50% or the \_Rrp isn't empty enough to create that "maximal vacuum" pull.
+
+Rate: 1.25 – 1.94
+
+```Gen
+RPShuttleHigh
+    type: accumulator
+
+    in_context: *AP
+
+    hypothesis: ( _CaTraceHigh fullness AND _RP fullness AND _Rrp mediumness ) OR   # signal + supply
+                ( _CaTraceHigh fullness AND _RP mediumness AND _Rrp emptiness ) OR  # signal + vacancy
+                ( _CaTraceMedium fullness AND _RP fullness AND _Rrp emptiness )     # supply + vacancy
+      action: [ _RP decrease, _Rrp increase ]
+      trace: None
+```
+
+##### RefillRPGlutamine
+
+This happens in the minutes loop, once per minute, via the glutamine shuttle from the astrocyte. It is a two-step process across two cells.
+
+Step 1 — astrocyte side
+The astrocyte has been accumulating cleared glutamate from the cleft since the last minutes-loop execution. Its glutamine synthetase enzyme converts that glutamate into glutamine, filling the Glutamine_pool. The fraction successfully converted per cycle is conversion_efficiency, which is set by glucose availability and boosted temporarily if the astrocyte calcium wave fired during the preceding seconds:
+
+refill_RP = Glutamine_pool * conversion_efficiency
+Glutamine_pool = max(0.0, Glutamine_pool - refill_RP)
+
+Step 2 — presynapse side
+
+The glutamine crosses into the presynapse, where glutaminase converts it back into glutamate. That glutamate is immediately repackaged into vesicles and added to N_RP:
+
+**The asymmetry that makes depletion possible**:
+
+The chain reveals why sustained high-frequency firing eventually depletes the synapse even with all replenishment mechanisms running.
+
+The RRP holds at most `Max_RRP = 20` vesicles. At 20 Hz with strong Ca2, release can draw 2-4 vesicles per spike — potentially exhausting the RRP in under a second. The seconds loop can move vesicles from RP to RRP at a maximum rate of `k_rec_fast = 5 /s`, meaning at most 5 vesicles per second under ideal conditions. Release outpaces recruitment by roughly an order of magnitude during a burst.
+
+The RP holds up to `Max_RP = 200` vesicles — ten times the RRP. At sustained 20 Hz the RP can sustain firing for tens of seconds even after the RRP is repeatedly emptied, as long as recruitment keeps pace. But the minutes loop only refills N_RP once per minute at a rate limited by `Glutamine_pool * conversion_efficiency`. If glucose is low or the astrocyte wave has not fired, this replenishment may add only a fraction of what was consumed.
+
+The result is a three-tier buffer with mismatched timescales:
+
+RRP  — depletes in seconds,   refilled in seconds   (fast but shallow)
+RP   — depletes in minutes,   refilled in minutes   (deep but slow)
+Gln  — depletes over bursts,  refilled by glucose   (slowest, astrocyte-dependent)
+
+Each tier buys time for the one below it to respond. When all three are depleted simultaneously — which only happens under prolonged high-frequency firing with insufficient glucose — the synapse has no remaining buffer and goes silent until the minutes loop restores the Glutamine_pool.
+
+##### Ca2TracesClearance
+
+Qui facciamo un flush di CaTraceX. Deve essere fatto a valle del tuning.
+
+```Gen
+Ca2TracesClearance
+    type: accumulator
+
+    in_context: NOT *TunPossible
+
+    hypothesis: NOT _CaTraceHigh empty
+      action: [ _CaTRaceHigh decrease ]
+      trace: None
+
+    hypothesis: NOT _CaTraceMedium empty
+      action: [ _CaTRaceMedium decrease ]
+      trace: None
+
+    hypothesis: NOT _CaTraceLow empty
+      action: [ _CaTRaceLow decrease ]
+      trace: None
+```
+
+### !DAY | TUN_VGCC
+
+```Gen
+TUN_VGCC
+
+  // qui stiamo attivando e disattivando PRE_VGCC. Fra un massimo full e minimo empty (empty puo' non essere 0)
+
+  type: behaviour
+  activity_scope: !DAY
+
+  snippet:
+
+    // *TunPossible
+    @: CONTEXTOR [ snippet: VgccCheck, rf: active 60x ]
+
+    // *VcggIncrease
+    @: ACCUMULATOR [ snippet: VcggIncrease, rf:active 10x ]
+
+    // *VcggDecrease
+    @: ACCUMULATOR [ snippet: VcggDecrease, rf:active 10x ]
+```
+
+#### *TunPossible
+
+##### VgccCheck
+
+Qui controlliamo che ci siano le condizioni per aumentare o diminuire l'attivazione di VGCC
+
+```Gen
+VgccCheck
+
+    type contextor
+    in_context: *TunPossible
+
+    condition:  _CaTraceHigh fullness
+      out_context: *VcggIncrease
+
+    condition:  _CaTraceLow fullness
+      out_context: *VcggDecrease
+```
+
+#### *VcggIncrease
+
+##### VcggIncrease
+
+```Gen
+VcggIncrease
+    type: accumulator
+
+    in_context: *VcggIncrease
+
+    hypothesis:  
+      action: 
+      trace: 
+```
+
+#### *VcggDecrease
+
+##### VcggDecrease
+
+```Gen
+VcggDecrease
+    type: accumulator
+
+    in_context: *VcggDecrease
+
+    hypothesis:  
+      action: 
+      trace: 
+```
+
+### !NIGHT | DEV_TUBS
+
+```Gen
+
+DEV_TUBS
+  type: behaviour
+
+  activity_scope: !NIGHT
+
+  snippet:
+
+    # *fixed
+    @: CONTEXTOR [ snippet: Ca2Check, rf: active 60x ]
+    *CaFullDecrease
+    @: ACCUMULATOR [ snippet: CaFullDecrease, rf: active 10x ]
+    *Ca2FullIncrease
+    @: ACCUMULATOR [ snippet: Ca2FullIncrease, rf: active 10x ]
+
+    # *fixed
+    @: CONTEXTOR [ snippet: RrpCheck, rf: active 60x ]
+    *RrpFullDecrease
+    @: ACCUMULATOR [ snippet: RrpFullDecrease, rf: active 10x ]
+    *IncreaseRrpFull
+    @: ACCUMULATOR [ snippet: IncreaseRrpFull, rf: active 10x ]
+
+```
+
+#### *fixed
+
+##### Ca2Check
+
+***Tens Milliseconds Time Scale***
+
+```Gen
+Ca2Check
+
+  type: contextor
+  
+  in_context: *fixed
+
+    condition: ( empty ) 
+      out_context: *CaFullDecrease
+
+    condition: ( full) 
+      out_context: *Ca2FullIncrease
+```
+
+##### *CaFullDecrease
+
+###### CaFullDecrease
+
+```Gen
+DecreasePreCa2Full
+
+  type: accumulator
+
+  in_context: *CaFullDecrease
+
+    hypothesis: NOT ( full ) AND NOT ( empty ) 
+      action: [ increase,  decrease]
+      trace: None
+```
+
+##### *Ca2FullIncrease
+
+###### Ca2FullIncrease
+
+```Gen
+IncreasePreCa2Full
+
+  type: accumulator
+  
+  in_context: *Ca2FullIncrease
+
+    hypothesis: NOT ( full ) AND NOT ( empty ) 
+      action: [ increase,  decrease]
+      trace: None
+```
+
+#### *fixed
+
+##### RrpCheck
+
+***Tens Milliseconds Time Scale***
+
+```Gen
+RrpCheck
+
+  type: contextor
+  
+  in_context: *fixed
+
+    condition: ( empty ) 
+      out_context: *RrpFullDecrease
+
+    condition: ( full) 
+      out_context: *IncreaseRrpFull
+```
+
+##### *RrpFullDecrease
+
+###### RrpFullDecrease
+
+```Gen
+DecreasePreRrpFull
+
+  type: accumulator
+
+  in_context: *RrpFullDecrease
+
+    hypothesis: NOT ( full ) AND NOT ( empty ) 
+      action: [ increase,  decrease]
+      trace: None
+```
+
+##### *RrpFullIncrease
+
+###### RrpFullIncrease
+
+```Gen
+RrpFullIncrease
+
+  type: accumulator
+
+  in_context: *RrpFullIncrease
+
+    hypothesis: NOT ( full ) AND NOT ( empty ) 
+      action: [ increase,  decrease]
+      trace: None
+```

elements/neuron/neuron.md

@@ -23,34 +23,35 @@ NEURON
 
   type: comprehension
 
-  expansion:
-  
+    // expansion:
     @AXON: EXPAND [ comprehension: AXON ]
     @SOMA: EXPAND [ comprehension: SOMA ]
-    @D_BRANCH: EXPAND [ comprehension: D_BRANCH ]
+    @D_BRANCH_001: EXPAND [ comprehension: D_BRANCH ]
+    @D_BRANCH_002: EXPAND [ comprehension: D_BRANCH ]
+    @D_BRANCH_003: EXPAND [ comprehension: D_BRANCH ]
 
-  intrication:
+    // Intrication:
+    // Scope
     
-    # Scope
-    !DAY: INTRICATION [ ref: &ORGANISM.!DAY ]
-    !NIGHT: INTRICATION [ ref: &ORGANISM.!NIGHT ]
+    !DAY: INTRICATION [ scope: &ORGANISM.!DAY ]
+    !NIGHT: INTRICATION [ scope: &ORGANISM.!NIGHT ]
 
-    # Context  
-    *??: INTRICATION [ ref: &??.*?? ]
+    // Context  
+    *??: INTRICATION [ context: &??.*?? ]
 
-    # Tub
-    _??: INTRICATION [ ref: &??._?? ] 
+    // Tub
+    _??: INTRICATION [ tub: &??._?? ] 
     
-  instantiation:
+    // Instantiation:
 
-    # Context
-    *TunPossible: CONTEXT []
+    // Context
+    *TunPossible: INSTANTIATE [ context: local]
 
-    # Tub
-    _SpikeTrainTraces: TUB [ full: 60x, active: 30x, empty: 0x ]
+    // Tub
+    _SpikeTrainTraces: INSTANTIATE [ tub: local, full: 60x, active: 30x, empty: 0x ]
 
-    # Behaviour
-    $: BEHAVIOUR [ behaviour: MAIN_NEURON ]
+    # Container
+    void: INSTANTIATE [ container: MAIN_NEURON ]
 ```
 
 ### MAIN_NEURON
@@ -63,7 +64,7 @@ MAIN_NEURON
   within_scope: !DAY
 
   snippet:
-    @: ACCUMULATOR [ snippet: TunPossibility, rf: active 12x ]
+    void: ACCUMULATOR [ snippet: TunPossibility, rf: active 12x ]
 ```
 
 #### TunPossibility

elements/neuron/postsynapse.md

@@ -14,44 +14,51 @@ Expansions and modulations:
 
 ```Gen
 
-include: 
-  post_ampa.md
-  
 POSTSYNAPSE
 
-  type: comprehension
+    type: comprehension
     
-  expansion:
-     _@PostAmpaAll: TUB [ comprehension: POST-AMPA, full: 10x, active: 5x, empty: 2x ]
+    include: post_ampa.md
 
-  intrication:
-    # Scope
-    !DAY: INTRICATION [ ref: &ORGANISM.!DAY ]
-    !NIGHT: INTRICATION [ ref: &ORGANISM.!NIGHT ]
+    // ########################## Intrication ##########################
     
-    # Context  
-    *bAP: INTRICATION [ ref: &SOMA.*bAP ]
-    *TunPossible: INTRICATION [ ref: &NEURON.*TunPossible ]
     
-    # Tub
-    _NT: INTRICATION [ ref: &ASTROSYNAPSE._NT ] 
-    _Vpost: INTRICATION [ ref: ??._VPost ]
+        // Scope
+    !DAY: INTRICATE [ scope: &ORGANISM.!DAY ]
+    !NIGHT: INTRICATE [ scope: &ORGANISM.!NIGHT ]
 
-  instantiation:
-    # Context
+        // Context  
+    *bAP: INTRICATE [ context: &SOMA.*bAP ]
+    *TunPossible: INTRICATE [ context: &NEURON.*TunPossible ]
     
-    # Tub
-    _Ca2: TUB [ full: 60x, active: 30x, empty: 0x ]
-    _Na: TUB [ full: 60x, active: 30x, empty: 0x ]
-    _Nox: TUB [ full: 100x, active: 20x, empty: 0x ] # Nitric Oxide (NO):  A gas that diffuses freely.
-    _eCB: TUB [ full: 100x, active: 20x, empty: 0x ] # Endocannabinoids (e.g., 2-AG)
+        // Tub
+    _NT: INTRICATE [ tub: &ASTROSYNAPSE._NT ] 
+    _Vpost: INTRICATE [ tub: ??._VPost ]
    
-    _posMod: TUB [ full: None, active: ??, empty: 0x)  # riferimento a possible di BEH-PRE
-    _actMod: TUB [ full: None, active: ??, empty: ??)  # riferimento a active di BEH-PRE
+  // ########################## Instantiation ##########################
   
-    # Behaviour
-    $: BEHAVIOUR [ behaviour: MAIN_POST ]
-    $: BEHAVIOUR [ behaviour: TUN-POST-AMPA ]
+        // Context
+
+        // Tub
+    _Ca2: INSTANTIATE [ tub: local, full: 60x, act: 30x, empty: 0x ]
+    _Na: INSTANTIATE [ tub: local, full: 60x, act: 30x, empty: 0x ]
+    _Nox: INSTANTIATE [ tub: local, full: 100x, act: 20x, empty: 0x ] # Nitric Oxide (NO):  A gas that diffuses freely.
+    _eCB: INSTANTIATE [ tub: local, full: 100x, act: 20x, empty: 0x ] # Endocannabinoids (e.g., 2-AG)
+    
+    _posMod: INSTANTIATE [ tub: local, full: None, act: ??, empty: 0x)  # riferimento a possible di BEH-PRE
+    _actMod: INSTANTIATE [ tub: local, full: None, act: ??, empty: ??)  # riferimento a active di BEH-PRE
+
+        // Container
+    void: INSTANTIATE [ scope: !DAY, container: ACTION, context:  *bAP ]
+    void: INSTANTIATE [ scope: !DAY, container: RECOVERY, context:  NOT *bAP,  *Spike_train ]
+    void: INSTANTIATE [ scope: !DAY, container: PREPARE, context: * NOT Spike_train ]
+    void: INSTANTIATE [ scope: !NIGHT, container: ACTION, context:  *Not_rem_1 ]
+    void: INSTANTIATE [ scope: !NIGHT, container: RECOVERY, context:  *Not_rem_2 ]
+    void: INSTANTIATE [ scope: !NIGHT, container: PREPARE, context:  *Rem ]
+
+    // ########################## Expansion ##########################
+    
+    _@PostAmpaAll: INSTANTIATE [ tub: EXPAND [ comprehension: POST-AMPA ], full: 10x, active: 5x, empty: 2x ]
 
 ```
 
@@ -64,7 +71,9 @@ POSTSYNAPSE
 - **_eCB**:
 - **_Nox**:?
 
-### MAIN_POST: !DAY
+## !DAY | ACTION | *bAP 
+
+//### MAIN_POST: !DAY
 ```
 MAIN_POST
   type: behaviour
@@ -89,12 +98,12 @@ MAIN_POST
 
 ```
 
-#### *bAP
+//#### *bAP
 
 ![post-ltp-ltd.png](.attachments/post-ltp-ltd.png)
 
 
-##### CaNDMAEnterMax
+//##### CaNDMAEnterMax
 
 ```Gen
 CaNDMAEnterMax
@@ -108,7 +117,7 @@ CaNDMAEnterMax
       trace: 
 ```
 
-##### CaNDMAEnterMed
+//##### CaNDMAEnterMed
 
 ```Gen
 CaNDMAEnterMed
@@ -121,9 +130,10 @@ CaNDMAEnterMed
       trace: 
 ```
 
-#### NOT *bAP
+## !DAY | RECOVERY | NOT *bAP, *Spike_train
+//#### NOT *bAP
 
-##### CaNDMAEnterLow
+//##### CaNDMAEnterLow
 
 ```Gen
 CaNDMAEnterLow
@@ -136,7 +146,7 @@ CaNDMAEnterLow
       trace: 
 ```
 
-##### CaNDMAEnterMedNotBap
+//##### CaNDMAEnterMedNotBap
 
 ```Gen
 CaNDMAEnterMedNotBap
@@ -149,7 +159,7 @@ CaNDMAEnterMedNotBap
       trace: 
 ```
 
-##### CaClearance
+//##### CaClearance
 
 ```Gen
 CaClearance # Low
@@ -162,7 +172,7 @@ CaClearance # Low
       trace: None
 ```
 
-##### VPostMax
+//##### VPostMax
 ```Gen
 VPostMa
     type: accumulator
@@ -174,7 +184,7 @@ VPostMa
       trace: None
 ```
 
-##### VPostMed
+//##### VPostMed
 ```Gen
 VPostMed
     type: accumulator
@@ -186,7 +196,7 @@ VPostMed
       trace: None
 ```
 
-##### VPostMin
+//##### VPostMin
 ```Gen
 VPostMin
     type: accumulator
@@ -199,7 +209,7 @@ VPostMin
 ```
 
 Il VPost clearance lo facciamo qui nel container dove creaiamo anche i VPost, perche' altrimenti, se lo facessimo in DB, perderemmo l'aspetto temporale della contribuzione dei singoli POST.
-##### VPostClearance
+//##### VPostClearance
 ```Gen
 VPostClearance
     type: accumulator
@@ -213,7 +223,7 @@ VPostClearance
 
 Il NA clearance lo mettiamo qui come sniplet, perche' gli AMPA creano, e questi pompano fuori. Qui non e' un problema di perdere l'integrazione temporale, perche' gli AMPA sono tutti uguali nel loro behavior. Abbiamo messo gli AMPA come container perche' cosi' possiamo modularne la numerosita'.
 
-##### NaClearanceHigh
+//##### NaClearanceHigh
 ```Gen
 NaClearanceHigh
     type: accumulator
@@ -225,7 +235,7 @@ NaClearanceHigh
       trace: None
 ```
 
-##### NaClearanceLow
+//##### NaClearanceLow
 ```Gen
 NaClearanceLow
     type: accumulator
@@ -237,7 +247,7 @@ NaClearanceLow
       trace: None
 ```
 
-### TUN-POST-AMPA: !DAY
+//### TUN-POST-AMPA: !DAY
 ```Gen
 TUN-POST-AMPA
   type: behaviour
@@ -256,9 +266,9 @@ TUN-POST-AMPA
   
   
 ```
-#### *TunPossible
+//#### *TunPossible
 
-##### CheckTunPostAmpa
+//##### CheckTunPostAmpa
 ```Gen
 CheckTunPostAmpa
   type: contextor
@@ -271,7 +281,7 @@ CheckTunPostAmpa
     out_context: *TryTunDownPostAmpa
 ```
 
-##### PossibleUpPostAmpaTun
+//##### PossibleUpPostAmpaTun
 ```Gen
 PossibleUpPostAmpaTun: ( active: 10x )
   type: accumulator
@@ -282,7 +292,7 @@ PossibleUpPostAmpaTun: ( active: 10x )
       trace: 
 ```
 
-##### PossibleDownPostAmpaTun
+//##### PossibleDownPostAmpaTun
 ```Gen
 PossibleDownPostAmpaTun
   type: accumulator
@@ -292,3 +302,12 @@ PossibleDownPostAmpaTun
       action: 
       trace: 
 ```
+
+## !DAY | PREPARE | NOT *Spike_train 
+
+## !NIGHT | ACTION | *Not_rem_1
+
+## !NIGHT | RECOVERY | *Not_rem_2
+
+## !NIGHT | PREPARE | *Rem
+

elements/neuron/presynapse.md

@@ -2,552 +2,324 @@
 include_toc: true
 ---
 
-# presynapse.md
+// presynapse.md
 
-## PRESYNAPSE
-
-Expansions and modulations:
+**Expansions and modulations**:
   - is expanded and developed by: [AXON](axon.md)
   - is tuned by: [ORGANISM](../../organism.md), organs, modules
   - expands and tunes: [PRE_VGG](pre_vgcc.md)
   - develops _Ca2, _Rrp
 
-```Gen
+  **Introduction**:
   
-include: 
-  pre_vgcc.md
+  The presynaptic bouton releases neurotransmitter and gathers evidence about whether that release was worth strengthening and worth sustaining. Its behavior unfolds across two DAY contexts and the NIGHT scope.
+
+  During DAY, during AP — the bouton releases neurotransmitter. The amount released depends on:
+  
+  - residual calcium from recent spikes (the fast trace), which sets the release drive;
+  - the two retrograde messages from the postsynapse — retro_eCB brakes the drive (the postsynapse is over-driven), retro_NO will later confirm that release reached a responsive target;
+  - the availability of both fuel and vesicles — release proceeds only if budget covers the cost and the readily-releasable pool is non-empty. These two shortfalls are read differently: a fuel shortfall on a succeeding release is evidence the bouton needs more endurance; an empty pool with fuel to spare is ordinary short-term depression.
+  
+  During DAY, during NOT_AP — the bouton consolidates and recovers. With no spike to release, it:
+  
+  - receives what arrived — latches the retrograde messages, refills its budget from astrocytic lactate and arrived axonal shipment (contested supply);
+  - maintains its traces — accumulates eligibility toward a tag, and stabilizes that tag if dopamine has arrived (the bridge toward strength);
+  - recovers its readily-releasable pool from the private reserve, between spikes (which is why high-frequency firing depletes faster than it recovers);
+  - lets its traces decay, closing the eligibility, endurance, and tagging windows.
+  
+  During NIGHT — the bouton's ceilings are rewritten. Acting on the evidence gathered across the day, NIGHT raises the bouton's structure (active-zone capacity) where a validated tag accumulated, and its budget capacity (mitochondrial endurance) where fuel repeatedly interrupted a succeeding release. Both draw on the same finite material and energy shipped down the axon, so the bouton's two kinds of growth compete — and whatever is not maintained drifts back down.
+
+# PRESYNAPSE
+
+```Gen
 
 PRESYNAPSE
 
   type: comprehension
 
-  expansion:
+  include: pre_vgcc.md
 
-    // il tub serve al tuning
-    _@pre_vgcc: TUB [ comprehension: PRE_VGCC, full: 10x, active: 5x, empty: 2x ]
-
-  intrication:
+  // ########################## Intrication ##########################
   
     // Scope
-    !DAY: INTRICATION [ ref: &ORGANISM.!DAY ]
-    !NIGHT: INTRICATION [ ref: &ORGANISM.!NIGHT ]
+  !DAY: INTRICATE [ scope: &ORGANISM.!DAY ]
+  !NIGHT: INTRICATE [ scope: &ORGANISM.!NIGHT ]
 
     // Context  
-    *AP: INTRICATION [ ref: &SOMA.*AP ]
-    *TunPossible: INTRICATION [ ref: &NEURON.*TunPossible ] 
+  *AP: INTRICATE [ context: &SOMA.*AP ]
+  *Spike_train: INTRICATE [ context: &NEURON.*Spike_train ] 
+
+  *Rem: INTRICATE [ context: &HYPOTHALAMUS.*Rem ] 
+  *Not_rem_1: INTRICATE [ context: &HYPOTHALAMUS.*Not_rem_1 ] 
+  *Not_rem_2: INTRICATE [ context: &HYPOTHALAMUS.*Not_rem_2 ] 
 
     // Tub
-    _NT: INTRICATION [ ref: &ASTROSYNAPSE._NT ] 
-    _ATP: INTRICATION [ ref: &ASTROCYTE._ATP ] 
-    _eCB: INTRICATION [ ref: &POSTSYNAPSE._eCB ]
+  _NT: INTRICATE [ tub: &ASTROSYNAPSE._NT ] 
+  _pre_budget: INTRICATE [ tub: &ASTROCYTE._pre_budget ] 
+  _eCB: INTRICATE [ tub: &POSTSYNAPSE._eCB ]
 
-  instantiation:
+  // ########################## Instantiation ##########################
 
     // Context
-    *VcggIncrease: CONTEXT []
-    *VcggDecrease: CONTEXT []
-    *Ca2PrePreActiveDecrease: CONTEXT []
-    *Ca2PreActiveDecrease: CONTEXT []
-    *RrpPreActiveDecrease: CONTEXT []
-    *RrpPreActiveDecrease: CONTEXT []
 
     // Tub
-    _Ca2: TUB [ full: 60x, active: 30x, empty: 0x ]
-    _Rrp: TUB [ full: 30x, active: 15x, empty: 0x ]
-    _Rp: TUB [ full: 30x, active: 15x, empty: 0x ]
-    _CaTracesHigh: TUB [ full: 50x, active: 0x, empty: 0x ]
-    _CaTracesMedium: TUB [ full: 50x, active: 0x, empty: 0x ]
-    _CaTracesLow: TUB [ full: 50x, active: 0x, empty: 0x ]
+  _Ca2: INSTANTIATE [ tub: local, full: 60x, act: 30x, empty: 0x ]
+  _Rrp: INSTANTIATE [ tub: local, full: 60x, act: 30x, empty: 0x ]
+  _Rp: INSTANTIATE [ tub: local, full: 60x, act: 30x, empty: 0x ]
+  _CaTracesHigh: INSTANTIATE [ tub: local, full: 60x, act: 30x, empty: 0x ]
+  _CaTracesMedium: INSTANTIATE [ tub: local, full: 60x, act: 30x, empty: 0x ]
+  _CaTracesLow: INSTANTIATE [ tub: local, full: 60x, act: 30x, empty: 0x ]
 
-    _Ca2FullDev: TUB [ full: 100x, active: _Ca2.full, empty: 40x ]
-    _RrpFullDev: TUB [ full: 100x, active: _Rrp.full, empty: 40x ]
-    # serve al DEV
+  _Ca2FullDev: INSTANTIATE [ tub: local, full: 60x, act: 30x, empty: 0x ]
+  _RrpFullDev: INSTANTIATE [ tub: local, full: 60x, act: 30x, empty: 0x ] // serve al DEV
+
+    // Container
+  void: INSTANTIATE [ scope: !DAY, container: ACTION, context:  *AP ]
+  void: INSTANTIATE [ scope: !DAY, container: RECOVERY, context:  NOT *AP,  *Spike_train ]
+  void: INSTANTIATE [ scope: !DAY, container: PREPARE, context: * NOT Spike_train ]
+  void: INSTANTIATE [ scope: !NIGHT, container: ACTION, context:  *Not_rem_1 ]
+  void: INSTANTIATE [ scope: !NIGHT, container: RECOVERY, context:  *Not_rem_2 ]
+  void: INSTANTIATE [ scope: !NIGHT, container: PREPARE, context:  *Rem ]
+
+  // ########################## Expansion ##########################
+
+  _@pre_vgcc: INSTANTIATE [ tub: EXPAND [ comprehension: PRE_VGCC ], full: 10x, active: 5x, empty: 2x ] // PRE_VGCC, il tub  _@pre_vgcc serve al tuning
     
-    // Behaviour
-    $: BEHAVIOUR [ behaviour: MAIN ]
-    $: BEHAVIOUR [ behaviour: TUN_VGCC ]
-    $: BEHAVIOUR [ behaviour: DEV_TUBS ]
 ```
   
-### !DAY | MAIN
+## !DAY | ACTION | *AP 
 
 ```Gen
-MAIN
 
-  type: behaviour
+ACTION
 
-  within_scope: !DAY
+  type: container
 
-  snippet:
-    // *AP
-    @: ACCUMULATOR [ snippet: NTreleaseLow, rf: active 12x ]
-    @: ACCUMULATOR [ snippet: NTreleaseMedium, rf: active 9x ]
-    @: ACCUMULATOR [ snippet: NTreleaseHigh, rf: active 6x ]
+  // ########################## NTRelease | Fast (ms–s) ##########################
 
-    @: ACCUMULATOR [ snippet: TracesAccLow, rf: active 3x ]
-    @: ACCUMULATOR [ snippet: TracesAccMedium, rf: active 6x ]
-    @: ACCUMULATOR [ snippet: TracesAccHigh, rf: active 10x ]
+  // Devo aggiungere la limitazione dovuta al Glutamate Spillover GluR e retro_eCB !!!!
   
-    // NOT *AP
-    @: ACCUMULATOR [ snippet: eCBClearenceMedium, rf: active 24x ]
-    @: ACCUMULATOR [ snippet: eCBClearenceLow, rf: active 48x ]
+  NTreleaseLow: INSTANTIATE [ snippet: accumulator, event: 12x ] {
+    hypothesis: _Ca2 mediumness AND _Rrp mediumness AND NOT _pre_budget empty 
+      action: [ _Rrp decrease, _NT increase ]
+      cost: [ _pre_budget decrease 3x ] 
+    else: None
+  }
   
-    @: ACCUMULATOR [ snippet: RPShuttleLow, rf: active 24x ]
-    @: ACCUMULATOR [ snippet: RPShuttleMedium, rf: active 48x ]
+  NTreleaseMedium: INSTANTIATE [ snippet: accumulator, event: 9x ] {
+    hypothesis: ( _Ca2 fullness AND _Rrp mediumness ) OR ( _Ca2 mediumness AND _Rrp fullness ) AND NOT _pre_budget empty 
+      action: [ _Rrp decrease, _NT increase ]
+      cost: [ _pre_budget decrease 3x ] 
+    else: None
+  }
 
-    @: ACCUMULATOR [ snippet: RefillGlutamine, rf: active 24x ]
+  NTreleaseHigh: INSTANTIATE [ snippet: accumulator, event: 6x ] {
+    hypothesis: _Ca2 fullness AND _Rrp fullness AND NOT _pre_budget empty
+      action: [ _Rrp decrease, _NT increase ]
+      cost: [ _pre_budget decrease 3x ] 
+    else: None
+  }
+
+  // ########################## Endurance | Fast (ms–s) ##########################
+  
+    // Tag se manca pre_budget, ma il rilascio di NT sarebbe stato di beneficio
+
+  Endourance_tag: INSTANTIATE [ snippet: accumulator, event: 9x ] {
+    hypothesis: _pre_budget empty AND NOT deve esserci la possibilita di spikare e altri segnali come NO 
+      action: [ _pre_endurance_tag increase ]
+      cost: None
+    else: None
+  }
 
-    @: ACCUMULATOR [ snippet: TracesClearance, rf: active 30x ]
 ```
   
-**Tubs:**
-
-- **\_Ca2**: Calcium Ion entering the Presynapse when VCGG open that influence NT release. Normally returns to ~0 between spikes; stays elevated when pumps fail. They are key to check the concentration, release NT and modulation
-- **\_Rrp**: Readily Releasable Pool: The Readily Releasable Pool consists of the vesicles that are "docked" and "primed" at the active zone of the synapse. This pool is very small (usually only about 0.5% to 5% of total vesicles) and can be exhausted quickly during high-frequency firing, leading to "short-term depression" of the signal. Here we consider them as NT ready to be released.
-- **\_Rp**: Reserve Pool: The bulk of the vesicles held further back in the terminal, often tethered by a protein called synapsin. These are only mobilized during intense, prolonged stimulation. This makes up the vast majority of the vesicles (up to 80% or 90%). Here we consider them NT in reserve that can be transfered to RRP and created using Glutamine from Astorcyte.
-- **\_NT**: Neuro Transmitter, released in the synapse by the vescicles. The release increses NT and decreases RRP
-- **\_CaTracesXXX**: sono le tracce di permanenza della concentrazione di Ca2. Servono alla modulazione (TUN)
-- **\_eCB**: retrograde signal updates from postsynapsis (postsynaptic input)
-
-#### *AP
-
-Il rilascio di NT lo facciamo nel contesto di AP. Biologicamente dovrebbe avvenire solo in base alle concentrazioni, quindi anche al difuori degli AP.
-
-RF di interacting deve essere MOLTO piu' basso di un RF di AP. In maniera da essere attivo varie volte nel contesto di un episodio di AP. Il che ha senso perche' un AP e' SOMA ad un tempo piu' alto che i comportamenti di PRE. Questo poi per permettere la diversa contestualizzazione degli episodi di NTrelease, a piu' o meno alta velocita'.
-
-![nt-release.png](.attachments/nt-release.png)
-
-Non consideriamo le vesicles come liberate, ma direttamente gli NT. Questo permette di gestire la quantita' rilasciata di NT, invece di gestire un numero di vescicles. Nella realta' ciascuna vesicle contiene migliaia di NT. Qui mettiamo un floor a questo tipo di comprensione.
-
-Ci sono 4 casi che dipendono da RRP, Ca2 e indirettamente da concentrazione di NT nella SYN che diventa mGLur che limita in VGCC l'entrata di Ca2. L'idea e' che la quantita' di RRP sia il driver principale. Gli NT liberati sono di piu' al crescere di RRP e Ca2 e di meno (indirettamente) al crescere della concentrazione di NT gia' liberati nella SYN. Gli NT nella sinapsi fanno da moderazione alla ulteriore liberazione di NT, ma non bloccano mai totalmente. NT suppression only matters when everything else is already at maximum, which is exactly the biological purpose: it prevents runaway release during peak activity, not during moderate activity.
-
----
-
-NT empty. Qui siamo contestualizzati se Ca2 full, il che dovrebbe significare indirettamente che non ci sono NT nella SYN.
-
-In tutti i casi di NT
-
-##### NTreleaseLow
+## !DAY | RECOVERY | NOT *AP, *Spike_train
 
 ```Gen
-NTreleaseLow
 
-    type: accumulator
-    in_context: *AP
+RECOVERY
 
-    hypothesis: _Ca2 mediumness AND _Rrp mediumness AND NOT _ATP empty 
-      action: [ _Rrp decrease, _NT increase, _ATP decrease ]
-      trace: None
-```
+  type: container
 
-##### NTreleaseMedium
-
-```Gen
-NTreleaseMedium
-
-    type: accumulator
-    in_context: *AP
-
-    hypothesis: ( _Ca2 fullness AND _Rrp mediumness ) OR 
-                ( _Ca2 mediumness AND _Rrp fullness ) AND
-                NOT _ATP empty 
-      action: [ _Rrp decrease, _NT increase, _ATP decrease ]
-      trace: None
-```
-
-##### NTreleaseHigh
-
-```Gen
-NTreleaseHigh
-    type: accumulator
-
-    in_context: *AP
-
-    hypothesis: _Ca2 fullness AND _Rrp fullness  AND 
-                NOT _ATP empty
-        action: [ _Rrp decrease, NT increase, _ATP decrease ]
-        trace: None
-```
-
-##### Ca2TracesAccLow
-
-Serve a:
-
-- fare il tuning dei VGCC
-- dare la velocita' al trasporto di vesicles da RP a RRP, anche se non avendo ancora compreso \_ATP, la velocita' non cambia molto la sostanza.
-- le tracce vengono eliminate quando il neurone e' in pausa, lontano da uno spike train, *TunPossible
-- Abbiamo 3 tracce, high, medium and low. Andiamo a verificare una combinazione di queste per fare la modulazione
-- RF e' a 10, questo dovrebbe essere un RF di campionamento durante *AP context che dovremmo assicurarci sia tipo 100. Il che implicherebbe 10 campionamenti.
-- The biological meaning is that a synapse that has just been through a burst is primed for fast recovery — the molecular machinery for vesicle docking is already engaged, calcium-dependent priming factors are still elevated, and the system is in a ready state. A synapse that has been silent for several seconds has cooled down and replenishes slowly.
-- So after one second of silence CaTrace has fallen to ~37% of its peak value, after two seconds to ~14%, after three seconds to ~5%. It asymptotes toward zero but never exactly reaches it. Between spikes, Ca2 falls toward zero as the pumps clear it. The result is that CaTrace encodes not the instantaneous calcium level but the recent history of calcium activity — a smoothed, time-averaged measure of how active the synapse has been over the past one to two seconds.
-
-```Gen
-Ca2TracesAccuLow
-    type: accumulator
-
-    in_context: *AP
+  // ########################## _Ca2 level | Fast (ms–s) ##########################
 
+  TracesAccLow: INSTANTIATE [ snippet: accumulator, event: 3x ] {
     hypothesis: _Ca2 emptiness
       action: [ _CaTraceLow increase ]
-      trace: None
-```
-
-##### Ca2TracesAccMedium
-
-```Gen
-Ca2TracesAccMedium
-    type: accumulator
-
-    in_context: *AP
+      cost: None
+    else: None
+  }
   
+  TracesAccMedium: INSTANTIATE [ snippet: accumulator, event: 6x ] {
     hypothesis: _Ca2 mediumness
       action: [ _CaTraceMed increase ]
-      trace: None
-```
-
-##### Ca2TracesAccHigh
-
-```Gen
-Ca2TracesAccumulationHigh
-    type: accumulator
-
-    in_context: *AP
+      cost: None
+    else: None
+  }
 
+  TracesAccHigh: INSTANTIATE [ snippet: accumulator, event: 10x ] {
     hypothesis: _Ca2 fullness
       action: [ _CaTraceHigh increase ]
-      trace: None
-```
+      cost: None
+    else: None
+  }
 
-#### NOT *AP
+  // ########################## TracesClearance | Fast (ms–s) ##########################
 
-##### eCBClearance
+    TracesClearance: INSTANTIATE [ snippet: accumulator, event: 30x] {
     
-eCB dipende da POST. Tende a modulare l'entrata di Ca2 degli VGCC.
+      hypothesis: NOT _CaTraceHigh empty
+        action: [ _CaTRaceHigh decrease ]
+        cost: None
+      else: None
 
-Qui non facciamo un flush di eCB, riduciamo ogni mezzo secondo (context) di un RF di questo episodio.
+      hypothesis: NOT _CaTraceMedium empty
+        action: [ _CaTRaceMedium decrease ]
+        cost: None
+      else: None
 
-```Gen
-eCBClearance: ( active: 24x ) # Slow
-    type: accumulator
+      hypothesis: NOT _CaTraceLow empty
+        action: [ _CaTRaceLow decrease ]
+        cost: None
+      else: None
 
-    in_context: NOT *AP
+    }
 
-    hypothesis: NOT _eCB empty
-      action: [ _eCB decrease ]
-      trace: None
-```
+  // ##########################  Rp Shuttle | Fast (ms–s) ##########################
 
-##### RPShuttleLow
+    // The "Hard Bottleneck" State. Recruitment is throttled by a lack of signal, a lack of supply, or a lack of space. 
+    // If even one of these "Near-Stop" conditions is met, the rate cannot exceed "Slow," regardless of the other two conditions. 
+    // Rate: 0.00 – 0.25
   
-This happens in the seconds loop, once per second.
-
-The "Hard Bottleneck" State. Recruitment is throttled by a lack of signal, a lack of supply, or a lack of space. If even one of these "Near-Stop" conditions is met, the rate cannot exceed "Slow," regardless of the other two conditions.
-
-Rate: 0.00 – 0.25
-
-```Gen
-RPShuttleLow
-    type: accumulator
-
-    in_context: NOT *AP
-
-    hypothesis: _CaTraceLow fullness OR 
-                _RP emptiness OR 
-                _Rrp fullness
+  RPShuttleLow: INSTANTIATE [ snippet: accumulator, event: 24x ] {
+    hypothesis: _CaTraceLow fullness OR _RP emptiness OR _Rrp fullness
       action: [ _RP decrease, _Rrp increase ]
-      trace: None
-```
+      cost:
+    else: None
+  }
 
-##### RPShuttleMedium
-
-The "Sub-Optimal" State. The machinery is working, but it's held back by partial limitations. This covers cases where the signal is steady but the "piston" isn't firing at full speed, or where a high vacancy in the RRP (emptiness) forces a low signal to work a bit harder.
-
-Rate: 0.50 – 0.97
-
-```Gen
-RPShuttleMedium
-    type: accumulator
-
-    in_context: *AP
+    // The "Sub-Optimal" State. The machinery is working, but it's held back by partial limitations. 
+    // This covers cases where the signal is steady but the "piston" isn't firing at full speed, 
+    // or where a high vacancy in the RRP (emptiness) forces a low signal to work a bit harder. Rate: 0.50 – 0.97
 
+  RPShuttleMedium: INSTANTIATE [ snippet: accumulator, event: 48x ] {
     hypothesis: ( _CaTraceMedium fullness AND _RP mediumness AND _Rrp mediumness ) OR 
                 ( _CaTraceHigh fullness AND _RP mediumness AND _Rrp mediumness ) OR   # signal boost
                 ( _CaTraceMedium fullness AND _RP fullness AND _Rrp mediumness ) OR   # supply boost
                 ( _CaTraceMedium fullness AND _RP mediumness AND _Rrp emptiness )     # vacancy boost
       action: [ _RP decrease, _Rrp increase ]
-      trace: None
+      cost: 
+    else: None
+  }
+
 ```
   
-##### RPShuttleHigh
-
-The "High Performance" State. Multiple systems are optimized, but one is still at a "mediumness" level. This represents an active synapse that hasn't reached its absolute peak because either the supply is only 50% or the \_Rrp isn't empty enough to create that "maximal vacuum" pull.
-
-Rate: 1.25 – 1.94
+## !DAY | PREPARE | NOT *Spike_train 
 
 ```Gen
-RPShuttleHigh
-    type: accumulator
 
-    in_context: *AP
+PREPARE
 
+  type: container
+
+  // ########################## PRE_VGCC Tun | Medium (s–min) ##########################
+
+    // qui stiamo attivando e disattivando PRE_VGCC. Fra un massimo full e minimo empty (empty puo' non essere 0)
+    
+  VgccTun: INSTANTIATE [ snippet: accumulator, event: 60x ] {
+  
+    condition:  _CaTraceHigh fullness
+      hypothesis:  
+        action:
+        cost: [ _pre_budget decrease 3x ] 
+      else: 
+        
+    condition:  _CaTraceLow fullness
+      hypothesis:  
+        action:
+        cost: [ _pre_budget increase 3x ] 
+      else: 
+  }
+
+  // ########################## RefillGlutamine | Medium (s–min) ##########################
+
+    // The "High Performance" State. Multiple systems are optimized, but one is still at a "mediumness" level. 
+    // This represents an active synapse that hasn't reached its absolute peak because either the supply is only 50% 
+    // or the \_Rrp isn't empty enough to create that "maximal vacuum" pull. Rate: 1.25 – 1.94
+
+  RefillGlutamine: INSTANTIATE [ snippet: accumulator, event: 24x ] {
     hypothesis: ( _CaTraceHigh fullness AND _RP fullness AND _Rrp mediumness ) OR   # signal + supply
                 ( _CaTraceHigh fullness AND _RP mediumness AND _Rrp emptiness ) OR  # signal + vacancy
                 ( _CaTraceMedium fullness AND _RP fullness AND _Rrp emptiness )     # supply + vacancy
       action: [ _RP decrease, _Rrp increase ]
-      trace: None
+      cost: 
+    else: None
+  }
+
+  // ########################## eCBClearance | Medium (s–min) ##########################
+  
+    eCBClearenceMedium: INSTANTIATE [ snippet: accumulator, event: 24x ] {
+      hypothesis: NOT _eCB empty
+        action: [ _eCB decrease ]
+        cost: 
+      else: None
+    }
+
+    eCBClearenceLow: INSTANTIATE [ snippet: accumulator, event: 48x] {
+      hypothesis: NOT _eCB empty
+        action: [ _eCB decrease ]
+        cost: 
+      else: None
+    }
+    
 ```
 
-##### RefillRPGlutamine
-
-This happens in the minutes loop, once per minute, via the glutamine shuttle from the astrocyte. It is a two-step process across two cells.
-
-Step 1 — astrocyte side
-The astrocyte has been accumulating cleared glutamate from the cleft since the last minutes-loop execution. Its glutamine synthetase enzyme converts that glutamate into glutamine, filling the Glutamine_pool. The fraction successfully converted per cycle is conversion_efficiency, which is set by glucose availability and boosted temporarily if the astrocyte calcium wave fired during the preceding seconds:
-
-refill_RP = Glutamine_pool * conversion_efficiency
-Glutamine_pool = max(0.0, Glutamine_pool - refill_RP)
-
-Step 2 — presynapse side
-
-The glutamine crosses into the presynapse, where glutaminase converts it back into glutamate. That glutamate is immediately repackaged into vesicles and added to N_RP:
-
-**The asymmetry that makes depletion possible**:
-
-The chain reveals why sustained high-frequency firing eventually depletes the synapse even with all replenishment mechanisms running.
-
-The RRP holds at most `Max_RRP = 20` vesicles. At 20 Hz with strong Ca2, release can draw 2-4 vesicles per spike — potentially exhausting the RRP in under a second. The seconds loop can move vesicles from RP to RRP at a maximum rate of `k_rec_fast = 5 /s`, meaning at most 5 vesicles per second under ideal conditions. Release outpaces recruitment by roughly an order of magnitude during a burst.
-
-The RP holds up to `Max_RP = 200` vesicles — ten times the RRP. At sustained 20 Hz the RP can sustain firing for tens of seconds even after the RRP is repeatedly emptied, as long as recruitment keeps pace. But the minutes loop only refills N_RP once per minute at a rate limited by `Glutamine_pool * conversion_efficiency`. If glucose is low or the astrocyte wave has not fired, this replenishment may add only a fraction of what was consumed.
-
-The result is a three-tier buffer with mismatched timescales:
-
-RRP  — depletes in seconds,   refilled in seconds   (fast but shallow)
-RP   — depletes in minutes,   refilled in minutes   (deep but slow)
-Gln  — depletes over bursts,  refilled by glucose   (slowest, astrocyte-dependent)
-
-Each tier buys time for the one below it to respond. When all three are depleted simultaneously — which only happens under prolonged high-frequency firing with insufficient glucose — the synapse has no remaining buffer and goes silent until the minutes loop restores the Glutamine_pool.
-
-##### Ca2TracesClearance
-
-Qui facciamo un flush di CaTraceX. Deve essere fatto a valle del tuning.
-
-```Gen
-Ca2TracesClearance
-    type: accumulator
-
-    in_context: NOT *TunPossible
-
-    hypothesis: NOT _CaTraceHigh empty
-      action: [ _CaTRaceHigh decrease ]
-      trace: None
-
-    hypothesis: NOT _CaTraceMedium empty
-      action: [ _CaTRaceMedium decrease ]
-      trace: None
-
-    hypothesis: NOT _CaTraceLow empty
-      action: [ _CaTRaceLow decrease ]
-      trace: None
-```
-
-### !DAY | TUN_VGCC
-
-```Gen
-TUN_VGCC
-
-  // qui stiamo attivando e disattivando PRE_VGCC. Fra un massimo full e minimo empty (empty puo' non essere 0)
-
-  type: behaviour
-  activity_scope: !DAY
-
-  snippet:
-
-    // *TunPossible
-    @: CONTEXTOR [ snippet: VgccCheck, rf: active 60x ]
-
-    // *VcggIncrease
-    @: ACCUMULATOR [ snippet: VcggIncrease, rf:active 10x ]
-
-    // *VcggDecrease
-    @: ACCUMULATOR [ snippet: VcggDecrease, rf:active 10x ]
-```
-
-#### *TunPossible
-
-##### VgccCheck
-
-Qui controlliamo che ci siano le condizioni per aumentare o diminuire l'attivazione di VGCC
-
-```Gen
-VgccCheck
-
-    type contextor
-    in_context: *TunPossible
-
-    condition:  _CaTraceHigh fullness
-      out_context: *VcggIncrease
-
-    condition:  _CaTraceLow fullness
-      out_context: *VcggDecrease
-```
-
-#### *VcggIncrease
-
-##### VcggIncrease
-
-```Gen
-VcggIncrease
-    type: accumulator
-
-    in_context: *VcggIncrease
-
-    hypothesis:  
-      action: 
-      trace: 
-```
-
-#### *VcggDecrease
-
-##### VcggDecrease
-
-```Gen
-VcggDecrease
-    type: accumulator
-
-    in_context: *VcggDecrease
-
-    hypothesis:  
-      action: 
-      trace: 
-```
-
-### !NIGHT | DEV_TUBS
+## !NIGHT | ACTION | *Not_rem_1
 
 ```Gen
 
-DEV_TUBS
-  type: behaviour
+DEVELOP
 
-  activity_scope: !NIGHT
+  type: container
 
-  snippet:
+  // !NIGHT | ???
 
-    # *fixed
-    @: CONTEXTOR [ snippet: Ca2Check, rf: active 60x ]
-    *CaFullDecrease
-    @: ACCUMULATOR [ snippet: CaFullDecrease, rf: active 10x ]
-    *Ca2FullIncrease
-    @: ACCUMULATOR [ snippet: Ca2FullIncrease, rf: active 10x ]
+  // ########################## CaFull | ??? ##########################
 
-    # *fixed
-    @: CONTEXTOR [ snippet: RrpCheck, rf: active 60x ]
-    *RrpFullDecrease
-    @: ACCUMULATOR [ snippet: RrpFullDecrease, rf: active 10x ]
-    *IncreaseRrpFull
-    @: ACCUMULATOR [ snippet: IncreaseRrpFull, rf: active 10x ]
+  Ca2Check: INSTANTIATE [ snippet: accumulator, event: 60x ] {
+  
+    condition: ( empty ) // CaFullDecrease
+      hypothesis: NOT ( full ) AND NOT ( empty ) 
+        action: [ increase,  decrease]
+        cost: 
+      else: None
+      
+    condition: ( full) // Ca2FullIncrease
+      hypothesis: NOT ( full ) AND NOT ( empty ) 
+        action: [ increase,  decrease]
+        cost: 
+      else: None
+  }
+
+  // ########################## RRPFull | ??? ##########################
+  
+  RrpCheck: INSTANTIATE [ snippet: accumulator, event: 60x ]
+  
+    condition: ( empty ) // RrpFullDecrease
+      hypothesis: NOT ( full ) AND NOT ( empty ) 
+        action: [ increase,  decrease]
+        cost: 
+      else: None
+      
+    condition: ( full) // RrpFullIncrease
+      hypothesis: NOT ( full ) AND NOT ( empty ) 
+        action: [ increase,  decrease]
+        cost: 
+      else: None
+  }
 
 ```
 
-#### *fixed
+## !NIGHT | RECOVERY | *Not_rem_2
 
-##### Ca2Check
-
-***Tens Milliseconds Time Scale***
-
-```Gen
-Ca2Check
-
-  type: contextor
-  
-  in_context: *fixed
-
-    condition: ( empty ) 
-      out_context: *CaFullDecrease
-
-    condition: ( full) 
-      out_context: *Ca2FullIncrease
-```
-
-##### *CaFullDecrease
-
-###### CaFullDecrease
-
-```Gen
-DecreasePreCa2Full
-
-  type: accumulator
-
-  in_context: *CaFullDecrease
-
-    hypothesis: NOT ( full ) AND NOT ( empty ) 
-      action: [ increase,  decrease]
-      trace: None
-```
-
-##### *Ca2FullIncrease
-
-###### Ca2FullIncrease
-
-```Gen
-IncreasePreCa2Full
-
-  type: accumulator
-  
-  in_context: *Ca2FullIncrease
-
-    hypothesis: NOT ( full ) AND NOT ( empty ) 
-      action: [ increase,  decrease]
-      trace: None
-```
-
-#### *fixed
-
-##### RrpCheck
-
-***Tens Milliseconds Time Scale***
-
-```Gen
-RrpCheck
-
-  type: contextor
-  
-  in_context: *fixed
-
-    condition: ( empty ) 
-      out_context: *RrpFullDecrease
-
-    condition: ( full) 
-      out_context: *IncreaseRrpFull
-```
-
-##### *RrpFullDecrease
-
-###### RrpFullDecrease
-
-```Gen
-DecreasePreRrpFull
-
-  type: accumulator
-
-  in_context: *RrpFullDecrease
-
-    hypothesis: NOT ( full ) AND NOT ( empty ) 
-      action: [ increase,  decrease]
-      trace: None
-```
-
-##### *RrpFullIncrease
-
-###### RrpFullIncrease
-
-```Gen
-RrpFullIncrease
-
-  type: accumulator
-
-  in_context: *RrpFullIncrease
-
-    hypothesis: NOT ( full ) AND NOT ( empty ) 
-      action: [ increase,  decrease]
-      trace: None
-```
+## !NIGHT | PREPARE | *Rem

modules/winnertakeall/winnertakeall.md

@@ -23,39 +23,32 @@ include:
 
   type: comprehension
 
-  expansion:
-  
+    // Expansion
     @NEU_005: EXPAND [ comprehension: NEURON ]
     @NEU_006: EXPAND [ comprehension: NEURON ]
 
-  instantiation:
+    // Intrication
+    // Scope
+    !NIGHT: INTRICATE [ scope: &ORGANISM.!NIGHT]
 
-    # Scope
-    !NIGHT: SCOPE [ reference: &ORGANISM.!NIGHT]
+    // Container Instantiation
  
-    # Behaviour
+    // external
 
-    ## external
+    $OUT-EXCI-001: INSTANTIATE [ container: OUT_EXCITATION, argument: COLLECTION [
+      pre: (  @NEU_001.@AXO_001._presynapse, @NEU_002.@AXO_001._presynapse ) ] ]   
 
-    @OUT-EXCI-001: BEHAVIOUR [ behaviour: OUT_EXCITATION, collection: COLLECTION [
-      pre: (  @NEU_001.@AXO_001._presynapse, 
-              @NEU_002.@AXO_001._presynapse ) ] ]
-
-    @IN-EXCI-001: BEHAVIOUR [ behaviour: IN_EXCITATION, collection: COLLECTION [
-      post: ( @NEU_001.@D_BRANCH_002._postsynapse, 
-              @NEU_002.@D_BRANCH_002._postsynapse ) 
+    $IN-EXCI-001: INSTANTIATE [ container: IN_EXCITATION, argument: COLLECTION [
+      post: ( @NEU_001.@D_BRANCH_002._postsynapse, @NEU_002.@D_BRANCH_002._postsynapse ) 
       astro:  &ASTROCYTE._astrosynapse ] ]
 
-    @IN-INHI-001: BEHAVIOUR [ behaviour: IN_INHIBITION, collection: COLLECTION [
-      post: ( @NEU_001.@SOMA_001._somasynapse, 
-              @NEU_002.@SOMA_001._somasynapse ) 
+    $IN-INHI-001: INSTANTIATE [ container: IN_INHIBITION, argument: COLLECTION [
+      post: ( @NEU_001.@SOMA_001._somasynapse, @NEU_002.@SOMA_001._somasynapse ) 
       astro:  &ASTROCYTE._astrosynapse ] ]
 
-    ## internal
+    // internal Area xxx
 
-    ### Area xxx
-
-    @: BEHAVIOUR [ behaviour: EXCITATION, collection: COLLECTION [ 
+    void: INSTANTIATE [ container: EXCITATION, argument: COLLECTION [ 
       pre: @NEU_001.@AXON-001._presynapse, 
       post: @NEU_001.@D_BRANCH_001._postsynapse, 
       astro: &ASTROCYTE._astrosynapse ] ]
@@ -70,17 +63,15 @@ EXCITATION
 
   activity_scope: !NIGHT
 
-  snippet:
+    // snippet: *Fixed
+    void: INCLUDE [ contextor: ExcitationPossible, event: act 12x ]
 
-    # *Fixed
-    @: CONTEXTOR [snip: ExcitationPossible, RF: active 60x]
+    // snippet: *ActivateAstroPostPre
+    void: INCLUDE [ binder: ExcitationBind, event: act 12x, cost: act 3x ]
+    void: INCLUDE [ accumulator: ClearTraces, event: act 12x, cost: act 3x ]
 
-    # *ActivateAstroPostPre
-    @: BINDER [snippet: ExcitationBind, RF: active 6x]
-    @: ACCUMULATOR [snippet: ClearTraces, RF: active 6x]
-
-    *DeActivateAstroPost
-    @: BINDER [snippet: ExcitationUnbind, RF: active 6x]
+    // snippet: *DeActivateAstroPost
+    void: INCLUDE [ binder: ExcitationUnbind, event: act 12x, cost: act 3x ]
 ```
 
 #### *Fixed