511 lines
20 KiB
Markdown
511 lines
20 KiB
Markdown
# Tripartite Synapse — Pseudocode v10
|
||
|
||
> Companion document: `tripartite_synapse_v10_biology.md` explains the biological
|
||
> meaning of every variable and behavior. This document is the logic only.
|
||
|
||
---
|
||
|
||
## Conventions
|
||
|
||
```
|
||
SCOPE = { DAY, NIGHT }
|
||
CONTEXT = { AP, NOT_AP, bAP, NOT_bAP, CONTINUOUS }
|
||
COMPONENTS = { PRE, POST, DEND, SOMA, AXON, ASTRO }
|
||
|
||
DAY variables
|
||
budget fast resource (energy + consumables), consumed by behavior
|
||
fast_trace local record, decays in ms–s, biases next behavior
|
||
possible_tag accumulates from fast_trace, decays in s–min
|
||
endurance_need accumulates on interrupted local success, decays in s–min
|
||
|
||
DAY→NIGHT bridge
|
||
tag decays in hours; POST: CANDIDATE → STABLE
|
||
|
||
NIGHT variables
|
||
energy assembly ATP, NOT recoverable
|
||
material structural proteins, RECOVERABLE after decay
|
||
structure strength ceiling — READ in DAY, WRITTEN in NIGHT
|
||
budget_ceiling endurance ceiling — READ in DAY, WRITTEN in NIGHT
|
||
|
||
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.
|
||
```
|
||
|
||
---
|
||
|
||
## Saturating form (used wherever a graded signal drives output)
|
||
|
||
```
|
||
sat(x, K) = x / (K + x)
|
||
```
|
||
|
||
---
|
||
|
||
## Fixed parameters
|
||
|
||
```
|
||
K_release K_AMPA K_Dserine
|
||
Mg_eject Ca_STP Ca_TAG eCB_thr
|
||
elig dop_thr tag_thr tag_expiry
|
||
traj_thr endur_thr
|
||
spillover inactivation overload
|
||
homeostatic_ceiling decay_rate capacity_decay_rate recycle
|
||
|
||
dopamine NE ACh // organism broadcast (external)
|
||
glucose // vascular ceiling (external)
|
||
geometry // dendritic topology (external)
|
||
```
|
||
|
||
---
|
||
---
|
||
# DAY
|
||
|
||
Execution contexts (AP, bAP, CONTINUOUS): run behavior, spend budget, deposit traces.
|
||
Replenishment contexts (NOT_AP, NOT_bAP): competitive refill, ship downstream, decay traces, set tags.
|
||
|
||
---
|
||
|
||
## Pool-filling primitives
|
||
|
||
Two shapes share the core "rise toward a ceiling, bounded by the gap, paying budget":
|
||
|
||
```
|
||
// PRIVATE: fill own pool from own reserve toward own ceiling, at a rate cap
|
||
fill(pool, ceiling, rate_cap, cost, budget):
|
||
amount = min(rate_cap, ceiling - pool)·Δt // bounded by rate AND gap
|
||
pool += amount
|
||
budget -= amount·cost
|
||
|
||
// CONTESTED: fill toward ceiling by a rationed share of a shared supply S
|
||
refill(component c from supply S):
|
||
demand = c.budget_ceiling - c.budget // claim = gap to ceiling
|
||
total = Σ demand over components on S
|
||
factor = min(1, S / (total + ε))
|
||
c.budget += demand × factor // never exceeds ceiling
|
||
S -= demand × factor
|
||
```
|
||
|
||
Choose by source: a pool drawn from a **private reserve** uses `fill`; a pool drawn from a
|
||
**contested shared supply** uses `refill`. The distinction is biologically real — RRP comes
|
||
from the bouton's private reserve pool, while operational budget comes from astrocytic lactate
|
||
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)
|
||
// 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) // received DSE brake
|
||
if RRP > 0:
|
||
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:
|
||
// 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
|
||
if dopamine > dop_thr and pre_possible_tag > tag_thr:
|
||
pre_tag += dopamine × pre_possible_tag
|
||
|
||
// 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
|
||
```
|
||
|
||
---
|
||
|
||
## POST
|
||
|
||
```
|
||
DAY | NOT_bAP:
|
||
refill(post from astro_lactate[syn] + dend_ship_post)
|
||
|
||
// SOURCE 1 — AMPA: current + small Ca + begins Mg ejection
|
||
a = sat(glutamate, K_AMPA)
|
||
AMPA_current = a × AMPA_surface; Vm += AMPA_current
|
||
post_fast_trace += AMPA_Ca·AMPA_current; post_budget -= AMPA_cost
|
||
|
||
// 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)
|
||
|
||
// CASE 1 — short-term potentiation: fill slots from private reserve (no dopamine)
|
||
// NOT generic fill(): rate is Ca-driven, and the else-branch is the STD consequence
|
||
if post_fast_trace > Ca_STP:
|
||
AMPA_surface = min(AMPA_surface + Ca_insert(post_fast_trace),
|
||
post_structure.slot_ceiling) // private: spine endosomal reserve
|
||
post_budget -= traffic_cost
|
||
else:
|
||
AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // STD = consequence
|
||
|
||
// interrupted success (LOCAL: my Ca was climbing toward a tag)
|
||
if post_budget < req_cost and post_fast_trace > traj_thr and post_fast_trace_rising:
|
||
post_endurance_need += post_fast_trace
|
||
|
||
// CASE 2 — tagging CANDIDATE
|
||
if post_fast_trace > Ca_TAG: post_possible_tag += post_fast_trace
|
||
post_possible_tag *= decay(min); post_endurance_need *= decay(min)
|
||
post_budget -= pka_cost
|
||
dopamine *= decay(ms)
|
||
if dopamine > dop_thr and post_possible_tag > tag_thr:
|
||
post_tag += dopamine × post_possible_tag // STABLE
|
||
post_tag *= decay(hr)
|
||
|
||
DAY | bAP:
|
||
// SOURCE 3 — bAP: depolarization + Ca, amplifies 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
|
||
|
||
```
|
||
DAY | bAP:
|
||
bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity,
|
||
dend_budget, geometry)
|
||
dend_budget -= prop_cost × reached
|
||
// interrupted success (LOCAL: my branch was strongly active)
|
||
if reached < full and dend_fast_trace > traj_thr:
|
||
dend_endurance_need += dend_fast_trace
|
||
dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_fast_trace *= decay(300ms)
|
||
dend_budget -= branch_Ca_cost
|
||
branch_Vm = integrate(POST.Vm, spines); dend_budget -= integrate_cost
|
||
|
||
DAY | NOT_bAP:
|
||
dend_fast_trace *= decay(300ms); dend_endurance_need *= decay(min)
|
||
refill(dend from astro_lactate[branch] + soma_ship_dend)
|
||
ship(dend_budget → post_budget, gap_to(post))
|
||
if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace
|
||
dend_possible_tag *= decay(s); dopamine *= decay(ms)
|
||
if dopamine > dop_thr and dend_possible_tag > tag_thr:
|
||
dend_tag += dopamine × dend_possible_tag
|
||
dend_tag *= decay(hr)
|
||
if dend_tag > tag_expiry and dend_budget > translate_cost:
|
||
dend_budget -= translate_cost
|
||
commit_threshold *= 1/(1 + ACh·gain)
|
||
```
|
||
|
||
---
|
||
|
||
## SOMA
|
||
|
||
```
|
||
DAY | AP:
|
||
threshold = soma_structure.baseline / (1) // baseline strength
|
||
× (1 + soma_adaptation)
|
||
× neuromod(NE, ACh)
|
||
can_fire = soma_Na_inactivation < inactivation
|
||
if branch_Vm > threshold and can_fire:
|
||
if soma_budget < ap_cost:
|
||
// interrupted success (LOCAL: nuclear Ca climbing toward CREB)
|
||
if soma_fast_trace > traj_thr and soma_fast_trace_rising:
|
||
soma_endurance_need += soma_fast_trace
|
||
exit
|
||
fired = True; soma_budget -= ap_cost
|
||
soma_Na_inactivation += ap_amp // → refractory (emergent)
|
||
soma_adaptation += ap_contrib // → threshold rise
|
||
soma_fast_trace += nuclear_Ca() // → plasticity
|
||
soma_budget -= nuclear_cost
|
||
if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace
|
||
soma_possible_tag *= decay(s); dopamine *= decay(ms)
|
||
if dopamine > dop_thr and soma_possible_tag > tag_thr:
|
||
soma_tag += dopamine × soma_possible_tag
|
||
soma_tag *= decay(hr); soma_budget -= creb_cost
|
||
|
||
DAY | NOT_AP:
|
||
// bottom-up alignment: suprathreshold input during refractory (LOCAL)
|
||
if branch_Vm > threshold and soma_Na_inactivation > inactivation:
|
||
soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation
|
||
recovery = base_recovery × (1 + soma_refractory_alignment)
|
||
soma_Na_inactivation *= decay(τ_Na / recovery)
|
||
soma_adaptation *= decay(τ_adapt)
|
||
soma_fast_trace *= decay(τ_nuclear)
|
||
soma_refractory_alignment *= decay(τ_align) // self-limiting
|
||
soma_endurance_need *= decay(min)
|
||
fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget) // private: own mitochondria, no external cost
|
||
branch_Vm = integrate(DEND.branch_Vm, branches)
|
||
ship(soma_budget → dend_budget, gap_to(dend))
|
||
ship(soma_budget → axon_budget, gap_to(axon))
|
||
```
|
||
|
||
---
|
||
|
||
## AXON
|
||
|
||
```
|
||
DAY | AP:
|
||
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace))
|
||
if axon_budget < prop_cost:
|
||
reliability *= budget_factor
|
||
// interrupted success (LOCAL: I was propagating a strong train)
|
||
if axon_fast_trace > traj_thr:
|
||
axon_endurance_need += axon_fast_trace
|
||
delivered = fired × reliability; axon_budget -= prop_cost × delivered
|
||
axon_fast_trace += delivered; axon_fast_trace *= decay(s)
|
||
|
||
DAY | NOT_AP:
|
||
axon_fast_trace *= decay(s); axon_endurance_need *= decay(min)
|
||
refill(axon from soma_ship_axon + astro_lactate[shaft])
|
||
ship(axon_budget → pre_budget, gap_to(pre))
|
||
if axon_fast_trace > elig: axon_possible_tag += axon_fast_trace
|
||
axon_possible_tag *= decay(s); dopamine *= decay(ms)
|
||
if dopamine > dop_thr and axon_possible_tag > tag_thr:
|
||
axon_tag += dopamine × axon_possible_tag
|
||
axon_tag *= decay(hr)
|
||
```
|
||
|
||
---
|
||
|
||
## ASTRO
|
||
|
||
```
|
||
DAY | CONTINUOUS:
|
||
astro_central_budget += glycolysis(glucose)·Δt // root, capped by glucose
|
||
|
||
// demand-weighted lactate allocation across territory
|
||
for each astrosynapse 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
|
||
|
||
// per-astrosynapse fast operation (synapse i)
|
||
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:
|
||
astro_fast_trace[i] += mGluR_Ca(); astro_fast_trace[i] *= decay(s)
|
||
want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
|
||
got = min(want, astro_central_budget × Ds_frac)
|
||
// interrupted success (LOCAL: I was under high demand)
|
||
if got < want and astro_fast_trace[i] > traj_thr:
|
||
astro_endurance_need[i] += (want - got)
|
||
astro_Dserine[i] += got; astro_central_budget -= got × Ds_cost
|
||
drive_pre[i] *= brake // same signal, PRE brake
|
||
if astro_fast_trace[i] > elig: astro_possible_tag[i] += astro_fast_trace[i]
|
||
astro_possible_tag[i] *= decay(s); dopamine *= decay(ms)
|
||
if dopamine > dop_thr and astro_possible_tag[i] > tag_thr:
|
||
astro_tag[i] += dopamine × astro_possible_tag[i]
|
||
astro_tag[i] *= decay(hr)
|
||
astro_endurance_need[i] *= decay(min)
|
||
if astro_fast_trace[i] > overload: trigger(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
|
||
|
||
Build ceilings (structure = strength, budget_ceiling = endurance) from DAY evidence.
|
||
Two economies (energy: astrocyte→astrosynapse ; material: soma→spine/bouton) compete.
|
||
Unmaintained ceilings decay; recovered material funds the rest.
|
||
|
||
---
|
||
|
||
## Step 1 — Replenish and distribute
|
||
|
||
```
|
||
NIGHT | 1:
|
||
// energy economy (astrocyte central → astrosynapses, tag-weighted)
|
||
astro_central_budget += overnight_glycolysis(glucose)·Δt
|
||
astro_central_energy += overnight_astro_energy()·Δt
|
||
astro_central_material += astro_cellbody_synth()·Δt
|
||
W = Σ astro_tag[i] over astro_tag[i] > tag_expiry
|
||
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
|
||
|
||
// 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 -= (f_dend + f_axon)·soma_material
|
||
post_material += dend_material × f_spine; dend_material -= f_spine·dend_material
|
||
pre_material += axon_material × f_bouton; axon_material -= f_bouton·axon_material
|
||
|
||
{pre,post,dend,axon}_energy += soma_energy × f_energy[·]
|
||
{pre,post,dend,axon}_budget += astro_lactate_reserve × f[·]·Δt
|
||
```
|
||
|
||
## Step 2 — Strength commits (raise structure)
|
||
|
||
```
|
||
NIGHT | 2:
|
||
coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? bonus : 1
|
||
|
||
for each component 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)
|
||
// astro_structure self-reinforcing: higher → future LTP easier
|
||
```
|
||
|
||
## Step 2b — Endurance commits (raise budget_ceiling)
|
||
|
||
```
|
||
NIGHT | 2b:
|
||
// driven by endurance_need (interrupted local success), NO dopamine
|
||
// competes with step 2 for the SAME material + energy
|
||
for each component 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)
|
||
```
|
||
|
||
## Step 3 — Passive decay (both ceilings, by neglect)
|
||
|
||
```
|
||
NIGHT | 3:
|
||
remaining = total_material - consumed_by_commits
|
||
maint = remaining × 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
|
||
// both drift down — depotentiation / endurance-loss by neglect
|
||
|
||
for each synapse with net_change < 0:
|
||
rec = |net_change| × recycle
|
||
{pre,post,astro}_material += rec × frac // material recovered, energy not
|
||
```
|
||
|
||
## Step 4 — Homeostatic scaling
|
||
|
||
```
|
||
NIGHT | 4:
|
||
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
|
||
```
|
||
|
||
## Step 5 — Clear traces
|
||
|
||
```
|
||
NIGHT | 5:
|
||
all fast_trace = 0; all possible_tag = 0; all 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 behavior runs within structure (strength) and budget_ceiling (endurance),
|
||
both filled by competition; consumes budget; deposits fast_trace.
|
||
fast_trace + non-local coincidence → tag (strength evidence)
|
||
depletion + interrupted LOCAL success → endurance_need (endurance evidence)
|
||
traces decay in NOT/CONTINUOUS contexts.
|
||
|
||
NIGHT tag → raise structure
|
||
endurance_need → raise budget_ceiling
|
||
both draw the SAME material + energy → strength and endurance compete
|
||
unmaintained ceilings decay → freed material funds the rest.
|
||
|
||
LOCALITY every evaluation uses only local state + arrived signals.
|
||
cross-compartment influence travels only as signals that become local.
|
||
```
|