ubrain 0.46.0.dev3__cp313-cp313-win_amd64.whl

ubrain/__init__.py

@@ -0,0 +1,51 @@
+"""ubrain -- Untrained Brain: never trained, always learning.
+
+A modality-general brain that learns from experience by local plasticity. Plug in
+any AI encoder as its senses and any body as its interface.
+
+    from ubrain import Brain
+    brain = Brain()                                   # the whole brain (a preview, 0.28)
+    brain.attach("sense", "vision", codec=camera)     # streams by port class
+    brain.attach("reward"); brain.attach("action", n=4)
+    action = brain.tick({"sense.vision": picture, "reward": r})["action"]
+
+    from ubrain import Brain, profile                 # a circuit: the experts' layer
+    brain = Brain(profile("walker"), manifest)
+    actions = brain.tick({"proprio": ..., "tone": False, "goal": (0.5, 0.0, 0.0)})
+
+Pre-release (0.46.0.dev3; codecs and their certificates since 0.3, the hippocampal
+episode and the `observer` profile since 0.4, CLIP as the `vision` extra since 0.5,
+the `explorer` profile and recognising senses since 0.6, the memory system -- the
+cortical slow store, replay into it, the `rememberer` profile -- since 0.7, working
+memory -- the prefrontal buffer, rehearsal, the `holder` profile -- since 0.8,
+noticing and switching -- the salience gate, the mode controller, consolidation on
+idle, the `attender` profile -- since 0.9, episodic control -- the hippocampal store
+that acts, the hand-over to the striatum, the `chooser` profile -- since 0.10, the hubs
+-- the thalamic relay, acetylcholine, noradrenaline and serotonin as scalars on existing
+knobs, the `modulated` profile -- since 0.11, walking adaptation -- one learning rate or
+two, the after-effect, savings and spontaneous recovery, the `adapter` profile -- since
+0.12, a Gymnasium game as a body -- `ubrain.bodies.gym`, the `game` extra -- since 0.13, a
+brain's state saved and loaded, observation and health, the datasheet, channel kinds
+checked against ports -- the interface specification's core documents -- since 0.14,
+the striatum valuing a situation code conditioned by a goal code, the `corticostriatal`
+profile -- since 0.23, the whole brain with no wiring, `Brain()`, streams attached by port
+class, named variants -- since 0.28): a
+generic brain -- regions with typed ports, the wiring as a dataflow -- running two anatomies on two bodies with no brain code between
+them: `walker` (the G1, contract 1.0 over protocol 0.3) and `player` (any body
+that shows a situation and pays a reward: a bandit, or a Gymnasium game through
+ubrain.bodies.gym). The laws behind every region are in The Untrained Brain Series,
+Volume 1; how this package is built, in Volume 2.
+"""
+
+from ubrain.brain import Brain
+from ubrain.language import Language
+from ubrain.contract import (CONTRACT_VERSION, Channel, Manifest, act_03, manifest_from_hello_03,
+                             senses_from_state_03)
+from ubrain.wiring import Wiring, load, profile
+from ubrain.codecs import Certificate, Codec, FrozenCodes, GaussianCodes, Sense, certify
+
+__version__ = "0.46.0.dev3"
+
+__all__ = ["Brain", "Language", "Channel", "Manifest", "Wiring", "CONTRACT_VERSION", "load", "profile",
+           "Codec", "FrozenCodes", "GaussianCodes", "Sense", "Certificate", "certify",
+           "manifest_from_hello_03", "senses_from_state_03", "act_03", "__version__"]

ubrain/bodies/__init__.py

@@ -0,0 +1,21 @@
+"""Bodies: the client side of a body that runs in its own process.
+
+A body (a simulated robot, a game) runs as a server in its own environment and
+speaks the tick bridge's protocol over TCP. ubrain never imports a simulator; it
+talks to the server:
+
+    from ubrain.bodies import BodyClient, start_body
+    proc, port = start_body(gallery=True, head_camera=True)    # the MuJoCo G1
+    body = BodyClient("127.0.0.1", port)
+    manifest = manifest_from_hello_03(body.hello)
+
+`client.py` and `protocol.py` are copied byte for byte from the MuJoCo body's own
+package (bodies/mujoco/body in the ubrain repository); they need only the standard
+library.
+"""
+
+from ubrain.bodies.client import BodyClient, decode_image
+from ubrain.bodies.launch import find_body, free_port, kill_tree, start_body, start_body_for
+
+__all__ = ["BodyClient", "decode_image", "start_body", "start_body_for", "find_body", "free_port",
+           "kill_tree"]

ubrain/extras/__init__.py

@@ -0,0 +1,2 @@
+"""Codec extras: wrappers for frozen AI models, each behind its own pip extra so the
+brain itself never needs torch. `pip install ubrain[vision]` -> ubrain.extras.clip."""

ubrain/profiles/adapter.toml

@@ -0,0 +1,42 @@
+# The adapter: the walker that also adapts its walk. A sustained push
+# fixed to the pelvis heading turns the walking body; the cerebellum learns a
+# counter-turn on the yaw-rate command from the sensed turn (the torso gyro's z, its
+# climbing fibre). When the push stops, the learned counter-turn is the after-effect.
+# Two learning rates with retention (Smith 2006) give savings and spontaneous
+# recovery; one rate gives neither (the two-rate adaptation law). The walker's two regions are
+# unchanged: with no correction learned, this is the walker tick for tick.
+#
+# `clamp` is the APPLICATION's channel (the experimenter's error clamp, a flag:
+# Manifest.with_channels(Channel("clamp", "flag"))); absent from the senses, it is
+# down and the cerebellum learns.
+
+[brain]
+name = "adapter"
+contract = "1.0"
+
+[regions."cerebellum.forward"]     # as the walker
+d_g = 2048
+s = 128
+eta = 0.5
+
+[regions."cerebellum.brace"]
+tau = 0.9
+eta = 0.3
+
+[regions."cerebellum.adapt"]       # two rates, the measured constants per tick (40 ticks a stride):
+arm = "dual"                       # b_f 0.007, a_f 0.9^(1/40), b_s 0.0008, a_s 0.995^(1/40)
+                                   # ("single": one rate, eta 0.005); axis 2 is the G1's
+                                   # gyro z in proprio, slot 2 the walk's yaw rate
+
+[inputs]
+"cerebellum.forward.proprio" = "proprio"
+"cerebellum.forward.command" = "goal"      # the efference copy: the goal, as the walker
+                                           # (the adaptation was measured without a forward model)
+"cerebellum.brace.proprio" = "proprio"
+"cerebellum.brace.cue" = "tone"
+"cerebellum.adapt.proprio" = "proprio"     # the sensed turn after last tick's command
+"cerebellum.adapt.clamp" = "clamp"
+
+[outputs]
+walk = "goal + cerebellum.brace + cerebellum.adapt"   # the goal, the counter-move, the counter-turn
+offsets = "zero"

ubrain/profiles/attender.toml

@@ -0,0 +1,52 @@
+# The attender: a body with a plugged-in sense that NOTICES. Each item seen is judged
+# against the last few it saw by the salience network's novelty statistic (1 - the
+# largest cosine), whose null is exact: the threshold is derived so that a
+# fresh item is mistaken for a familiar one at the false-alarm rate alpha. Novel items
+# are written into the hippocampal episode; familiar ones are skipped (a gate on the
+# write, the gate's law: a trade of load against coverage). A novel item is also a
+# DEMAND on the mode controller (the network triangle): the system plans and
+# stays in executive mode while novel items keep coming, and falls back to the default
+# mode when nothing new is pending. Its first idle tick ends the episode, which is
+# REPLAYED into the cortex under fresh index keys -- consolidation when idle, the
+# default mode's job (consolidation by replay, timed by the default mode).
+#
+# The derived threshold assumes codes that look like random directions in the
+# workspace (white codes, as the sense prepares them). A codec whose items crowd a cone
+# or a low-rank subspace makes fresh items look familiar: certify() the codec first.
+
+[brain]
+name = "attender"
+contract = "1.0"
+
+[regions."salience.gate"]
+memory = "trace"                # a fading trace a brain could have (certified on its law, D.1); since 0.25
+lam = 0.95                      # its fade per item
+alpha = 0.05                    # P(a fresh item judged familiar): the threshold is derived from it
+
+[regions."modes.controller"]
+arm = "triangle"                # plan iff a demand is pending (always_cen, always_dmn, coin: the comparisons)
+policy = "interrupt"            # a surprise (none is wired here) abandons the chunk
+k = 4                           # executive ticks per demand: attending, before idling is possible
+
+[regions."hippocampus.episode"]
+slots = 64
+
+[regions."cortex.store"]        # one tick is one event: gamma 1.0 forgets nothing
+gamma = 1.0
+replay_eta = 1.0
+
+[inputs]
+"salience.gate.item" = "camera"                         # a codec channel: plug a Sense in
+"modes.controller.novel" = "salience.gate.novel"        # a novel item is a demand
+"hippocampus.episode.item" = "salience.gate.passed"     # novel items only
+"hippocampus.episode.recall" = "recall"                 # an event: which slot of the episode
+"hippocampus.episode.boundary" = "modes.controller.idle"  # default mode: the episode ends, replayed
+"cortex.store.replay" = "hippocampus.episode.replay"
+"cortex.store.recall" = "recollect"                     # an event: which consolidated memory
+
+[outputs]
+memory = "hippocampus.episode.recalled"
+remembered = "hippocampus.episode.index"
+recollection = "cortex.store.recalled"
+recollected = "cortex.store.index"
+mode = "modes.controller.mode"                          # 1 executive, 0 default mode

ubrain/profiles/chooser.toml

@@ -0,0 +1,49 @@
+# The chooser: the player (the striatum) with an episodic memory that acts first, and
+# a hand-over between them -- the complementary learning system as a controller. Every
+# (situation, action, outcome) is bound into one decaying hippocampal store; at a
+# decision each action's recalled outcome is read and the best taken, one-shot
+# (memory is ahead early, where the striatum's table has barely moved). But the
+# store's votes sit in the crosstalk of every other pair it holds, and the striatum
+# overtakes it late where that crosstalk or its forgetting wins (the crossover law of
+# episodic control). So memory acts only while it can tell its arms apart -- its votes'
+# top-two margin above its own crosstalk scale ||x|| sqrt(2/d), read off the store with
+# no estimate in it --
+# and the striatum acts otherwise. Both learn from every outcome, on the action actually
+# taken, crediting every choice since the last outcome (a bandit: one; a maze: the
+# episode's).
+#
+# What the criterion is NOT (derived, and measured so): it measures separability,
+# not reliability. The store's margin grows as it fills, so memory's share of decisions
+# RISES even where the table has overtaken it; the hand-over tracks the better pure
+# controller within a derived shortfall, and an oracle that knew both curves would do
+# better. The same body runs on `player` (striatum alone) for the comparison.
+
+[brain]
+name = "chooser"
+contract = "1.0"
+
+[regions."hippocampus.episodic_control"]   # the measured store: d 256, decay 0.995 per outcome
+d = 256
+gamma = 0.995
+kappa = 1.0                     # the measured convention: act above one sigma of crosstalk (omit: always act)
+
+[regions."basal_ganglia.striatum"]         # the player's setting: eta 0.1, values from 0.5
+eta = 0.1
+q0 = 0.5
+credit = "episode"              # every choice since the last outcome (end-of-episode credit)
+
+[regions."control.handover"]                # memory's action when it acted, the striatum's otherwise
+
+[inputs]
+"hippocampus.episodic_control.state" = "situation"         # an event: which situation this is
+"hippocampus.episodic_control.reward" = "reward"           # the outcome of what was taken before it
+"hippocampus.episodic_control.taken" = "control.handover.choice"   # last tick's action, whoever chose it
+"basal_ganglia.striatum.state" = "situation"
+"basal_ganglia.striatum.reward" = "reward"
+"basal_ganglia.striatum.taken" = "control.handover.choice"
+"basal_ganglia.striatum.inhibit" = "hippocampus.episodic_control.confident"   # memory acts: the race is held
+"control.handover.memory" = "hippocampus.episodic_control.choice"
+"control.handover.habit" = "basal_ganglia.striatum.choice"
+
+[outputs]
+action = "control.handover.choice"

ubrain/profiles/companion.toml

@@ -0,0 +1,122 @@
+# The companion: the whole brain in a walking body that notices, remembers, sleeps on
+# it and chooses -- the explorer's cerebellum under the attender's memory system, with
+# the striatum behind it (apps/gallery_companion, 2026-10-26). Nothing here is new
+# machinery: every region is certified on its own; this wiring is what puts them
+# together on one body for days.
+#
+# - The two cerebellar regions calibrate the frozen gait and brace on a cue (walker).
+# - What the camera's sense delivers is JUDGED by the salience gate against the last few
+#   items (novelty, the exact null) and its verdict is an output (`novel`), and a novel
+#   item is a demand on the mode controller (the triangle): the system attends while
+#   new things keep coming and falls back to the default mode when nothing is pending.
+#   Unlike the attender, the gate does NOT stand before the episode: the camera's items
+#   are written directly, and the application's event segmentation (the same picture
+#   recognised on steady glances in a row) decides what counts as seen. Measured
+#   2026-10-26 (stage 0): with the gate before the episode, 6 of 12 pictures were judged
+#   familiar and never written -- the gate's threshold is derived for white codes, and
+#   CLIP's centred codes are correlated; the false-familiar rate was 0.5 against alpha
+#   0.05. That is a finding for the engine (the gate's null on real codes), not a knob
+#   to turn here; the scoreboard checks `novel` against the law so the miss stays
+#   visible. An idle tick does NOT end the episode either: a
+#   day in the gallery is one episode, holding the order things were seen in, and it
+#   ends when the person says `sleep` (the `boundary` event) -- then it is REPLAYED
+#   into the cortex under fresh index keys, the day consolidated at night (measured
+#   2026-10-26: with the idle boundary every glance-burst of k = 4 ticks emptied the
+#   episode, and nothing could be asked about the day).
+# - The striatum learns, from a reward the person gives, what to do at a situation (the
+#   picture it stands at).
+#
+# Recall is BY INDEX: a cue names a slot of the episode or the n-th consolidated memory
+# (the cortex's `cue` port reads a KEY, not an item's content). Content-addressed
+# questions ("after the dog?") are the application's two steps over the brain's own
+# answers: recall every slot, find the dog, ask the next. The person's words reach the
+# brain as pictures (CLIP text snapped to the image vocabulary) in the app; no `said`
+# channel is wired yet.
+
+[brain]
+name = "companion"
+contract = "1.0"
+
+[regions."cerebellum.forward"]     # as the walker
+d_g = 2048
+s = 128
+eta = 0.5
+
+[regions."cerebellum.brace"]
+tau = 0.9
+eta = 0.3
+
+[regions."salience.gate"]
+memory = "trace"                # a fading trace a brain could have (certified on its law, D.1); since 0.25
+lam = 0.95                      # its fade per item
+alpha = 0.05                    # P(a fresh item judged familiar): the threshold is derived from it
+
+[regions."modes.controller"]
+arm = "triangle"                # plan iff a demand is pending
+policy = "interrupt"
+k = 4                           # executive ticks per demand
+
+[regions."hippocampus.episode"]
+slots = 64
+
+[regions."hippocampus.episode@route"]   # a second ordered episode: the route (rung 5, 2026-10-27).
+slots = 64                              # Its items are skills taken and things seen, in order, from a
+                                        # joint vocabulary; "go to the X" is its recall, replayed
+
+[regions."prefrontal.buffer"]   # working memory: goals held while walking (rung 6, 2026-10-27).
+gamma_m = 0.75                  # the measured decay per write (the holder's): about seven held
+eta = 1.0
+slots = 16
+
+[regions."thalamus.relay"]      # attention among things in view (rung 7, 2026-10-27): the view's
+routes = 6                      # fixations are the routes (both halves x three squares); a route
+alpha = 0.05                    # opens when its content matches the thing sought (`seek`), and
+                                # every open route is read off the bus (`attention`)
+
+[regions."cortex.store"]        # one tick is one event at 50 Hz: gamma 1.0 forgets nothing
+gamma = 1.0
+replay_eta = 1.0
+
+[regions."basal_ganglia.striatum"]
+eta = 0.1
+q0 = 0.5
+
+[inputs]
+"cerebellum.forward.proprio" = "proprio"
+"cerebellum.forward.command" = "goal"
+"cerebellum.brace.proprio" = "proprio"
+"cerebellum.brace.cue" = "tone"
+"salience.gate.item" = "camera"                         # a codec channel: plug CLIP in
+"modes.controller.novel" = "salience.gate.novel"        # a novel item is a demand
+"hippocampus.episode.item" = "camera"                   # every item seen (the app segments events)
+"hippocampus.episode.recall" = "recall"                 # an event: which slot of the episode
+"hippocampus.episode.boundary" = "boundary"             # `sleep`: the day's episode ends, replayed
+"cortex.store.replay" = "hippocampus.episode.replay"
+"cortex.store.recall" = "recollect"                     # an event: which consolidated memory
+"hippocampus.episode@route.item" = "route_item"        # a skill taken, or a thing seen (a codec channel)
+"hippocampus.episode@route.recall" = "recall_route"    # an event: which step of the route
+"hippocampus.episode@route.boundary" = "route_boundary"  # an event: the route ends (a new trip)
+"prefrontal.buffer.item" = "goal_item"                 # a goal: a thing, through the camera's sense
+"prefrontal.buffer.recall" = "recall_goal"             # an event: which goal of the list
+"prefrontal.buffer.clear" = "goal_clear"               # an event: a new list
+"thalamus.relay.routes" = "routes"                     # the fixations' codes, R x d (the app's crops)
+"thalamus.relay.goal" = "seek"                          # the thing sought: its code (a trip's target)
+"basal_ganglia.striatum.state" = "situation"            # the picture it stands at
+"basal_ganglia.striatum.reward" = "reward"              # the person's good / bad
+
+[outputs]
+walk = "goal + cerebellum.brace"
+offsets = "zero"
+memory = "hippocampus.episode.recalled"
+remembered = "hippocampus.episode.index"
+recollection = "cortex.store.recalled"
+recollected = "cortex.store.index"
+mode = "modes.controller.mode"                          # 1 executive, 0 default mode
+novel = "salience.gate.novel"                           # the gate's verdict on this tick's item (1 novel)
+action = "basal_ganglia.striatum.choice"
+route_memory = "hippocampus.episode@route.recalled"
+route_remembered = "hippocampus.episode@route.index"
+goal_memory = "prefrontal.buffer.recalled"
+goal_remembered = "prefrontal.buffer.index"
+attention = "thalamus.relay.reads"                      # every open route's read off the bus
+opened = "thalamus.relay.open"                          # which routes the gate opened

ubrain/profiles/corticostriatal.toml

@@ -0,0 +1,36 @@
+# The corticostriatal path: the striatum valuing a situation CODE, never an index. A
+# body's situation arrives as a code on the sphere (a vector channel, or a sense's
+# workspace code); the striatum reads it through the cerebellum's granule expansion
+# (1024 units, the 64 largest kept, centred, unit norm) and learns a value per action
+# by the three-factor rule, the expansion as the eligibility. The goal, a code too,
+# conditions the values by binding: the same situation under another goal is another
+# point of the expansion, so values that reverse with the goal are learned apart.
+#
+# The law (ubrain.datasheet.value_law) gives the expected reward of the greedy choice
+# for ANY feature map on a sample of the world -- this expansion, the raw code, the
+# binned table an application would otherwise build -- so which reads best is computed
+# before a run, and the answer depends on the world: the raw code where the reward is
+# linear in the code, the expansion where it is not, a table of the prototypes where
+# the situations are a few clean ones. While `explore` is up the actions are taken in
+# turn (every action learned alike, the schedule the law was measured under); while it
+# is down the largest value is taken.
+
+[brain]
+name = "corticostriatal"
+contract = "1.0"
+
+[regions."basal_ganglia.striatum"]   # the measured setting: eta 0.1, 64 of 1024, the goal bound
+eta = 0.1
+features = "expansion"               # or "raw": the code itself, read linearly
+d_g = 1024
+s = 64
+context = "bind"                     # or "sum": the goal superposed (shares what the goals share)
+
+[inputs]
+"basal_ganglia.striatum.situation" = "situation"   # a code: a vector channel or a sense
+"basal_ganglia.striatum.context" = "goal"          # the goal, a code of the situation's width
+"basal_ganglia.striatum.reward" = "reward"         # the outcome of the choice before it
+"basal_ganglia.striatum.explore" = "explore"       # a flag: take the actions in turn
+
+[outputs]
+action = "basal_ganglia.striatum.choice"

ubrain/profiles/explorer.toml

@@ -0,0 +1,35 @@
+# The explorer: the walker that also remembers what it sees. A legged body with a
+# head camera; a plugged-in vision codec (CLIP) turns what the camera looks at into
+# codes, and the hippocampus writes them into one episode as it walks, slot by slot;
+# a cue recalls a slot. The walker's two cerebellar regions are unchanged.
+
+[brain]
+name = "explorer"
+contract = "1.0"
+
+[regions."cerebellum.forward"]     # as the walker
+d_g = 2048
+s = 128
+eta = 0.5
+
+[regions."cerebellum.brace"]
+tau = 0.9
+eta = 0.3
+
+[regions."hippocampus.episode"]
+slots = 64
+
+[inputs]
+"cerebellum.forward.proprio" = "proprio"
+"cerebellum.forward.command" = "goal"
+"cerebellum.brace.proprio" = "proprio"
+"cerebellum.brace.cue" = "tone"
+"hippocampus.episode.item" = "camera"          # a codec channel: plug CLIP in
+"hippocampus.episode.recall" = "recall"        # the app's cue
+"hippocampus.episode.boundary" = "boundary"
+
+[outputs]
+walk = "goal + cerebellum.brace"
+offsets = "zero"
+memory = "hippocampus.episode.recalled"
+remembered = "hippocampus.episode.index"

ubrain/profiles/holder.toml

@@ -0,0 +1,30 @@
+# The holder: a body with a plugged-in sense whose items are HELD in working memory
+# -- the prefrontal active buffer, persistent activity -- and recalled by position on
+# a cue. Each item seen is bound to its position's role and added to one decaying
+# vector; with no CA3 behind it, the buffer holds about seven items at a plausible
+# decay (working memory's count law, on the event clock). On an idle event the
+# buffer rehearses its schedule's next item; rehearsal changes WHICH items are held,
+# never how many (the rehearsal law: a full cycle restores the presentation's profile).
+# A clear event starts a new list.
+
+[brain]
+name = "holder"
+contract = "1.0"
+
+[regions."prefrontal.buffer"]   # the measured working-memory decay and rehearsal setting
+gamma_m = 0.75                  # per WRITE event (a presentation or a rehearsal), not per tick:
+eta = 1.0                       # a tick that writes nothing does not age the buffer
+slots = 16                      # positions (roles); an item past the last is dropped
+schedule = "cycle"              # none, cycle, oldest, newest, random (the measured schedules)
+n_rehearse = 16                 # idle rehearsals per list, then the schedule is spent
+m = 3                           # the oldest/newest schedules' item count
+
+[inputs]
+"prefrontal.buffer.item" = "camera"          # a codec channel: plug a Sense in
+"prefrontal.buffer.recall" = "recall"        # an event: which position to recall (0 the first)
+"prefrontal.buffer.idle" = "idle"            # an event: a free moment, rehearse
+"prefrontal.buffer.clear" = "clear"          # an event: the list ends
+
+[outputs]
+memory = "prefrontal.buffer.recalled"        # the recalled code
+remembered = "prefrontal.buffer.index"       # which vocabulary item it is

ubrain/profiles/modulated.toml

@@ -0,0 +1,107 @@
+# The modulated brain: the hubs on a brain that notices, remembers and chooses. Nothing
+# here is new machinery: each neuromodulator is ONE SCALAR on a knob an existing region
+# already has, and the thalamus is a gate on a route.
+#
+# - The thalamus relays R incoming streams (`routes`, one workspace code per route) to a
+#   shared bus, opening a route only when its content matches the goal held elsewhere
+#   (the relay's gate). Gating removes the crosstalk of irrelevant routes and risks
+#   closing the target's own: it pays with many routes and a goal that matches, and
+#   costs with few routes or a goal that barely matches (the relay's law).
+# - Noradrenaline sets the salience gate's criterion from the recent rate of JUDGED
+#   surprise: the threshold that errs least at that rate, for the world the gate judges
+#   (M known codes, repeats at noise sigma; exact). Slow adaptation pays after the
+#   novelty rate changes; on a stationary stream it costs a little; and fast adaptation
+#   RUNS AWAY -- the level counts surprise its own threshold decides -- to judging
+#   nothing novel (noradrenaline's law). Hence eta 0.02, not 0.1.
+# - Acetylcholine splits each event's plasticity in the cortex: novel items encoded at
+#   a = 0.8, one earlier experience -- as the hippocampus holds it (hippocampus.replay) -- replayed
+#   at 0.2 on every event -- graded, where the
+#   binary mode switch (arm = "binary", idle = modes.controller.idle) encodes nothing
+#   when idle and replays only then; graded recalls both recent and older experience
+#   better wherever the two differ (acetylcholine's law).
+# - Serotonin is the striatum's patience: a choice's eligibility decays by
+#   exp(-1/tau_hat) per tick until its outcome, tau_hat the running mean time between
+#   decisions. Less patience moves choice toward small-soon rewards by the race's fixed
+#   point; scaling patience to the usual trial time pays where the option it moves
+#   toward is the better one and costs where it turns impulsive (serotonin's law).
+#
+# The gate judges against a KNOWN set (`known`, taught by the body, never judged;
+# remember = false), the world the noradrenaline criterion is certified in; the
+# criterion's d is the camera sense's workspace width and must match it. Dopamine is
+# the striatum's own reward-prediction error, as before.
+
+[brain]
+name = "modulated"
+contract = "1.0"
+
+[regions."thalamus.relay"]
+routes = 4                      # R streams arrive as a 4 x d batch (one workspace code per route)
+alpha = 0.05                    # an unrelated route slips through with probability 0.05 (the null's quantile)
+
+[regions."neuromodulator.noradrenaline"]   # before the gate: its level is read this tick
+d = 256                         # the camera sense's workspace width
+M = 64                          # known codes the gate judges against
+sigma = 3.0                     # the noise a familiar thing is seen again under (the first measured setting)
+eta = 0.02                      # slow: pays after a change, never runs away (0: a fixed criterion)
+level = 0.1                     # the novelty rate the world had
+
+[regions."salience.gate"]
+memory = "window"               # the noradrenaline world keeps the exact window: its laws on the trace are
+                                # not certified yet
+remember = false                # judged against the known set only
+alpha = 0.05                    # the threshold until noradrenaline sets it (it does, every tick)
+
+[regions."modes.controller"]
+arm = "triangle"                # a novel item is a demand: plan iff one is pending
+k = 4
+
+[regions."neuromodulator.acetylcholine"]   # before the cortex
+arm = "graded"
+idle_p = 0.2                    # the tonic level a = 1 - idle_p = 0.8, the busy fraction
+
+[regions."hippocampus.replay"]   # before the cortex: what the cortex replays is what it still holds
+d_h = 8192                      # the trace's own width: a replay is only as good as this read of it
+gamma_h = 0.995                 # per item recorded
+
+[regions."cortex.store"]
+gamma = 0.94                    # per event (the slower measured decay): right when one tick is one
+                                # event; a body ticking at 50 Hz wants gamma near 1 (rememberer)
+
+[regions."neuromodulator.serotonin"]       # before the striatum
+tau = 4.0                       # the usual time between decisions to start from (ticks)
+kappa = 0.02                    # how fast it follows the time decisions actually take (0: fixed)
+
+[regions."basal_ganglia.striatum"]
+eta = 0.1
+q0 = 0.5
+
+[inputs]
+"thalamus.relay.routes" = "routes"                      # R workspace codes, one per route
+"thalamus.relay.goal" = "goal"                          # the goal the routes are matched to
+"thalamus.relay.read" = "attend"                        # an event: which route to read off the bus
+"neuromodulator.noradrenaline.novel" = "salience.gate.novel"       # last tick's verdict (recurrent)
+"neuromodulator.noradrenaline.novelty" = "salience.gate.novelty"   # ... and whether an item arrived
+"salience.gate.item" = "camera"                         # a codec channel: plug a Sense in
+"salience.gate.know" = "known"                          # codes taught as familiar
+"salience.gate.theta" = "neuromodulator.noradrenaline.theta"
+"modes.controller.novel" = "salience.gate.novel"
+"hippocampus.replay.item" = "salience.gate.passed"      # the hippocampus records what the cortex encodes
+"hippocampus.replay.encoding" = "neuromodulator.acetylcholine.level"
+"cortex.store.item" = "salience.gate.passed"            # novel items, encoded at a
+"cortex.store.key" = "hippocampus.replay.key"           # ... under the key the hippocampus gives them
+"cortex.store.replay" = "hippocampus.replay.replay"     # one earlier experience, as the hippocampus holds it
+"cortex.store.replay_key" = "hippocampus.replay.replay_key"   # ... rewritten under its own key at 1 - a
+"cortex.store.encoding" = "neuromodulator.acetylcholine.level"
+"cortex.store.recall" = "recollect"                     # an event: which encoded memory
+"neuromodulator.serotonin.state" = "situation"          # a decision: the time since the last one
+"basal_ganglia.striatum.state" = "situation"
+"basal_ganglia.striatum.reward" = "reward"
+"basal_ganglia.striatum.patience" = "neuromodulator.serotonin.patience"
+
+[outputs]
+workspace = "thalamus.relay.bus"
+attended = "thalamus.relay.read"
+recollection = "cortex.store.recalled"
+recollected = "cortex.store.index"
+mode = "modes.controller.mode"
+action = "basal_ganglia.striatum.choice"

ubrain/profiles/observer.toml

@@ -0,0 +1,21 @@
+# The observer: a body with a plugged-in sense (a camera through CLIP, a microphone,
+# a text stream) whose items the hippocampus writes into one episode, slot by slot,
+# and recalls by slot on a cue. What it recalls is a code of the sense's vocabulary,
+# so the body (or the app) can say WHAT was seen. Its accuracy is the sense's
+# certificate: ubrain.certify(codec, sample, d).
+
+[brain]
+name = "observer"
+contract = "1.0"
+
+[regions."hippocampus.episode"]
+slots = 64
+
+[inputs]
+"hippocampus.episode.item" = "camera"          # a codec channel: plug a Sense in
+"hippocampus.episode.recall" = "recall"        # an event: which slot to recall
+"hippocampus.episode.boundary" = "boundary"    # an event: the episode ends
+
+[outputs]
+memory = "hippocampus.episode.recalled"        # the recalled code
+remembered = "hippocampus.episode.index"       # which vocabulary item it is

ubrain/profiles/player.toml

@@ -0,0 +1,19 @@
+# The player: a body that shows a situation and pays a reward (a bandit, a game).
+# The striatum learns a value per (situation, action) from each outcome and
+# releases actions by the Go race. No cerebellum, no walking: the same Brain, a
+# different anatomy, and not one line of brain code changed for it.
+
+[brain]
+name = "player"
+contract = "1.0"
+
+[regions."basal_ganglia.striatum"]   # the measured setting: eta 0.1, values from 0.5
+eta = 0.1
+q0 = 0.5
+
+[inputs]
+"basal_ganglia.striatum.state" = "situation"   # an event: which situation this is
+"basal_ganglia.striatum.reward" = "reward"     # the outcome of the last action
+
+[outputs]
+action = "basal_ganglia.striatum"