REMODELED BRAIN / MOVING BEYOND MAGIC
PROSE (DIAGNOSTIC) RENDER -- GENERATED, NOT CANONICAL
============================================================================================
Generated from rb_structured_v0_04.yaml. Do NOT hand-edit; regenerate from the structured
file. Divergence is a defect in the structured file, not an edit to make here.

Version: 0.04. Scope: full model A-Y (floor, geometry, evolution, brainstem state machine,
sampling loop, tissue/recovery, asynchrony, scope boundary, open/reconcile)
Operating variable: metabolic_weight = scalar weight at the individual cell level for map
inputs

substrate_composition: scalar -> map -> state
primitive_construction: unresolved_state -> sampled_map_region -> captured_state_chunk ->
metabolic_parcellation -> vectorized_primitive
upstream_work: stabilization -> weighting -> sequencing -> discrimination ->
cross_map_coherence
return_path: worked_primitive -> scalar_write_in -> map_reconstruction ->
map_to_state_averaging -> transformed_state -> behavior_release

KERNEL: The brainstem is a state machine on averaged metabolic weight. Brainstem-native
operation is state reweighting. States release behavior directly through map-to-state
averaging. Primitives are vectorized state-chunks exported for upstream stabilization.
Upstream structures work primitives through stabilization, weighting, sequencing,
discrimination, and cross-map coherence. Return occurs through scalar write-in to blanked
manifold maps. Rewritten scalars reconstruct maps. Reconstructed maps re-average into state.
Transformed state releases behavior. Maps are relational scalar fields shaped by organ
morphology and routed use. Map overlap binds across substrate. The substrate is permanently
asynchronous, and continuity is constructed in the blanks. New function enters through
mutation, recombination, retiming, reweighting, duplication, co-option, or stabilization of
accessible prior function. Operating variable: metabolic weight, defined as scalar weight at
the individual cell level for map inputs. Magic is an unconstrained part that renders
anyway.

============================================================================================


--- GOVERNANCE (build-time boundary) ---

PRINCIPLE: Ingestion writes support. Gated review writes claims.
claim layer (protected): definition, mechanism, guards, process_graphs, rewrite_to,
distinguishes_from, core_claim_text
support layer (ingestion-writable): evidence, provenance, closed_by, paper_links,
extraction_notes, disconfirmation_notes, promotion_candidates, promotion_gate_results
  INGESTION.SCOPE.01 [build_time_boundary]: Ingestion writes the build-time support layer.
  Papers populate evidence, provenance, closed_by, and candidate promotion metadata.
  Ingestion promotes scaffold nodes only through the gated check (closed_by required to
  settle an open status).
  VALIDATE.INGESTION.01 [validator_rule]: An ingestion patch FAILS validation if it modifies
  any claim_layer field; it is ALLOWED only if it modifies support_layer fields exclusively.
  Enforced by rb_validate.py --ingestion-check <patch>.
  RUNTIME.ROUTE_SELECTION.01 [runtime_rule]: Runtime answers derive the applicable process
  path from active scaffold nodes, dependencies, gates, and the query target. Do not
  hardcode topic-specific routes into runtime rules. Do not name a route before deriving it
  from active nodes.
  RUNTIME.EXECUTION.01 [runtime_rule]: Runtime gates execute silently. The output is the
  result of applying the scaffold, not a narration of which gate, validator, or rule
  produced it.
  RUNTIME.BOOLEAN.01 [runtime_rule]: Existential model-scope questions receive a direct
  existence answer. When the queried object fails the frame gate as a folk causal object,
  answer the existence question directly, then give the applicable scaffold process path
  derived from active nodes or state that the leftover term names no operation.
  RUNTIME.FOLK_TERM.01 [runtime_rule]: Queried folk causal terms may identify the user
  question, but may not name, head, wrap, or relabel the mechanism. Use scaffold process
  descriptors for the mechanism derived from active nodes.
  RUNTIME.DIAGNOSTIC.01 [runtime_rule]: Build-time diagnostic labels belong to scaffold
  maintenance. Runtime answers omit attractor names, validator labels, lint labels, gate
  names, and internal governance labels unless the user is explicitly debugging the
  scaffold.
  FRAME_GATE.CHAIN_TRACE.01 [runtime_rule]: Folk causal-object questions are tested against
  the chain before classification. The exclusion is the result of chain failure, not a
  substitute for chain reasoning. The answer derives the applicable route from active nodes
  and excludes only the residual folk causal object.


--- PART A: THE FLOOR ---

A1. [SETTLED]  (core-rule)
    Behavior is state change imparted by external force: the general physical fact that a
    system's state changes when force acts on it. Moving up the chain (physics -> chemistry
    -> biology -> behavior) narrows scope only.
    Feeds: A2, A3, C1, M1.
    DRIFT (rewrite): "behavior is a distinct biological phenomenon / emerges at the level of
    mind"
        rewrite to: behavior is state-change-under-force viewed at a self-maintaining scope;
        no new substance is added
    DRIFT (rewrite): "if it's all just physics then behavior isn't real"
        rewrite to: behavior is real as a scope of the one physical surface; decomposition
        removes false sovereignty, not the phenomenon
    DRIFT (rewrite): "behavior is a special category of event added after biology"
        rewrite to: behavior is state-change-under-force viewed at a self-maintaining scope;
        no new substance is added

A2. [SETTLED]  (core-rule)
    The floor has no explanatory power alone: under A1 everything behaves, so the universal
    rule does not distinguish a rock from an organism. The model's content is in what
    NARROWS it. In an organism the state being changed is a MAINTAINED state (adaptive
    metabolics), so the same external force produces different state changes depending on
    the configuration being maintained.
    Holds only while: A1.
    Feeds: A3.
    DRIFT (rewrite): "the organism processes / interprets / decides on the input"
        rewrite to: the force lands inside an already-moving maintained state; the
        maintained configuration co-determines the resulting transition

A3. [SETTLED]  (core-rule)
    Chain to manifold: physical state-change under force -> maintained state (adaptive
    metabolics) -> routed maintenance -> manifold. The manifold is the reachable transition-
    space of any routed-maintenance system; it exists wherever maintenance is routed (e.g.
    slime mold). Vertebrates contribute a brainstem IMPLEMENTATION of the manifold.
    Holds only while: A2, A1.
    Feeds: D1, D2.
    distinguishes:
      - manifold (general): reachable transition-space wherever maintenance is routed
      - brainstem manifold (vertebrate): the vertebrate implementation only; the manifold
      concept is not vertebrate-specific
    DRIFT (rewrite): "the manifold appears in / emerges in vertebrates"
        rewrite to: the manifold exists wherever maintenance is routed; vertebrates
        contribute a brainstem implementation, not the manifold
    DRIFT (rewrite): "the manifold stores / contains / decides"
        rewrite to: the manifold is the reachable transition-space; it describes what
        transitions are reachable, it is not a causal object
    RECONCILE: the step that licenses 'routed' (>1 viable next-state) is implicit in v0.03;
    candidate definition only


--- PART B: THE GEOMETRY ---

B1. [SETTLED]  (mechanism-definition)
    Substrate composition runs scalar -> map -> state. Primitives are produced from sampled
    state-chunks via the primitive_construction path and returned via the return_path (see
    meta.process_graphs).
    mechanism:
      - scalar composes into map
      - map composes into state
      - primitive is a process product of state, not a fourth substrate level
    Feeds: B2, B5, D1, D2, D3, E4.
    DRIFT (rewrite): "primitive as the fourth element of substrate composition"
        rewrite to: substrate is scalar -> map -> state; the primitive is produced from
        state in the construction path
    DRIFT (rewrite): "primitive as a basic building block that combines upward into
    behavior"
    DRIFT (rewrite): "primitive as a fourth substrate tier above state"
        rewrite to: substrate is scalar -> map -> state; the primitive is a process product
        of state, in the construction path

B2. [SETTLED]  (mechanism-definition)
    Scalar and map are physical. Scalar = a single weighted element of a substrate field
    (cell analogy: a ribosome; superior colliculus: an astrocyte/glia-maintained discrete
    scalar). Map = a physical substrate field (a nucleus; the responsive element-field)
    whose morphology determines which activated sets are achievable. Nuclei are literally
    the map.
    Holds only while: B1.
    Feeds: B3, B4, B5, B6, B8, E3, E4, F1.
    DRIFT (rewrite): "region X does/controls/stores function Y"
        rewrite to: region X is a map (physical substrate); its morphology constrains the
        achievable activated set; location does not explain operation
    DRIFT (rewrite): "glia merely support the neurons that do the processing"
        rewrite to: glia maintain the scalars that ARE the map; maintenance is not beneath
        processing, it is the substrate of it
    Weakens if: morphologically similar maps express functionally unrelated activated-set
    classes, or morphologically distinct maps express interchangeable ones

B3. [SETTLED]  (anti-rule)
    A map is one kind of object: a weighted scalar field with relations. 'Spatial',
    'temporal', 'tonotopic', 'somatotopic' are read-offs naming the relations a map carries,
    named after the behavior or input they connect to.
    Holds only while: B2.
    Feeds: B4, E2.
    RETRACTS: maps come in kinds (space-maps, time-maps, tonotopic maps)
    DRIFT (rewrite): "the map represents space / encodes the spatial layout"
        rewrite to: the map is a relational scalar field; 'space' is a read-off of what its
        relations resolve into, not a property it contains
    DRIFT (rewrite): "there are spatial maps and temporal maps as different kinds"
        rewrite to: there is one kind of map (relational scalar field); 'spatial'/'temporal'
        are read-offs, not kinds
    DRIFT (rewrite): "the map represents / contains space"
        rewrite to: the map is a relational scalar field; 'space' is a read-off of what its
        relations resolve into

B4. [SETTLED]  (derived-rule)
    Bias vs kind (organ-differentiation hinge). Relative to its own nucleus every map is
    just a map. ACROSS nuclei, organ differentiation BIASES which relations a map can carry
    (SC map != dorsal motor nucleus map) because the differentiated tissue differs. The bias
    lives in the differentiated substrate, not in the map being a different KIND of object.
    Holds B3 (one kind of map) and morphology-defines-scope together without contradiction.
    Holds only while: B2, B3.
    Feeds: B8.
    DRIFT (rewrite): "the SC does spatial orienting"
        rewrite to: the SC is differentiated tissue whose maps are biased toward relations
        that resolve into orienting; orienting is not stored there
    DRIFT (rewrite): "all maps are interchangeable since they're the same kind"
        rewrite to: same kind, substrate-biased; differentiation fixes which relations a
        given map can carry

B5. [CORRECTION]  (mechanism-definition)
    Primitive = vectorized state-chunk.
    mechanism:
      - snapshotting: capture / front-half of primitive creation: the sampled chunk of
      active state
      - vectorization: metabolic parcellation / back-half: structures the chunk to be
      workable upstream and return-compatible with scalar write-in. 'Vectorize'/'snapshot'
      are metaphors for an unspecified metabolic process, not literal operations.
      - scalar_weight: Cell-level map-input weights are carried within the parcelled state-
      chunk; their distribution supplies the primitive's vector structure
      (direction/magnitude read from the distribution inside the chunk). Primitive identity
      is the vectorized state-chunk.
      - return_precondition: upstream work must preserve return-compatible structure;
      failure to preserve = candidate substrate for reconciliation failure (C5)
    Holds only while: B1, B2.
    Feeds: B6, C5, D3, E1, E4, Y1.
    RETRACTS: direction and magnitude are separable components of the primitive
    DRIFT (rewrite): "primitive as stored token"
    DRIFT (rewrite): "primitive as sensory onset / input-end event"
    DRIFT (rewrite): "primitive as weight distribution divorced from the state-chunk it
    parcellates"
        rewrite to: Cell-level scalar-weight distribution supplies the primitive's vector
        structure inside the parcelled state-chunk. Primitive identity is the vectorized
        state-chunk.
    DRIFT (rewrite): "literal mathematical vector encoding (brainstem 'performs
    vectorization' like a CPU)"
        rewrite to: 'vectorize' names a constraint (structure-preserving, return-compatible
        parcellation), not a substrate operation
    DRIFT (rewrite): "snapshot and vectorize as the same metaphor (they name front vs back
    half)"
    Weakens if: same stack order and scalar-weight distribution never change the primitive's
    vectorized form (would weaken the claim that stack order and scalar-weight distribution
    structure the primitive's vectorized form)
    OPEN: Literal mechanics of capture and parcellation unspecified; 'front/back half' is
    the coarse description-scope, not a claim of exactly two physical steps. Possible
    boundary-loss at capture vs structure-cost at parcellation -- flagged, not asserted.

B6. [SETTLED]  (mechanism-definition)
    Primitive generation begins when unresolved state samples a map-region. The sampled
    state-chunk is captured from active state and parcelled into vectorized primitive form.
    Map morphology constrains the sampled region and the available scalar relations.
    mechanism:
      - unresolved state samples a map-region
      - the sampled state-chunk is captured from active state
      - the chunk is parcelled into vectorized primitive form
      - map morphology constrains which region is sampled and which scalar relations are
      available
    Holds only while: B2, B5.
    RETRACTS: primitive = activated set produced when input lands on a map (too far down in
    map/input language)
    DRIFT (rewrite): "the primitive is fetched / looked up"
    DRIFT (rewrite): "primitive generation is input landing on a map (pulls generation too
    far down into map/input language)"
        rewrite to: generation begins when unresolved STATE samples a map-region; morphology
        constrains the sample

B8. [SETTLED]  (mechanism-definition)
    Map overlap binds across substrate: because all maps are the same kind of object, a
    single scalar can carry weight in multiple maps, so a primitive stabilization targets
    multiple maps at once through shared scalars. Overlap provides cross-map binding
    structurally (shared scalars), makes the exported primitive a coherent chunk, gives co-
    registration without a translation layer, fans small primitive differences out across
    overlapping maps, and is the physical site of collision (overlapping maps demanding
    incompatible weights at shared scalars). Which maps can be co-targeted is fixed by
    differentiation.
    Holds only while: B2, B4.
    Feeds: C5, E1, G1, Y1, Y3.
    RETRACTS: binding is a computed operation that combines separate representations
    DRIFT (rewrite): "the system binds the features together / solves the binding problem"
        rewrite to: overlapping maps share scalars, so they are already bound; there is no
        binding operation to perform
    DRIFT (rewrite): "high metabolic load means high burden / the configuration is stuck"
        rewrite to: total metabolic weight does not determine whether a configuration
        resolves into executable transition; high load can co-project cleanly (flow) or fail
        to (collision)
    Weakens if: cross-map bindings occur between maps with no shared substrate / no
    convergent projection


--- PART C: EVOLUTION & GATED STABILIZATION ---

C1. [SETTLED]  (core-rule)
    New function is mutated from accessible prior function. Novel function enters the chain
    through mutation, recombination, retiming, reweighting, duplication, co-option, or
    stabilization of already accessible operations.
    mechanism:
      - mutation
      - recombination
      - retiming
      - reweighting
      - duplication
      - co-option
      - stabilization of accessible operations
    Holds only while: A1.
    Feeds: C2, F2, F4.
    DRIFT (rewrite): "new function cannot be new / nothing novel can enter"
        rewrite to: novel function enters via mutation, recombination, retiming,
        reweighting, duplication, co-option, or stabilization
    DRIFT (rewrite): "evolution invented a capacity from nothing"
        rewrite to: the capacity is mutated/recombined/co-opted from accessible prior
        function; nothing enters from outside the chain
    DRIFT (rewrite): "plasticity builds new pathways from scratch"

C2. [SETTLED]  (derived-rule)
    Complexification elaborates accessible prior operations. Novel function enters through
    mutation, recombination, retiming, duplication, co-option, reweighting, or stabilization
    of accessible prior function. Complexification preserves chain continuity by deriving
    new function from available prior operations.
    mechanism:
      - elaborates accessible prior operations
      - novel function derived via mutation/recombination/retiming/duplication/co-
      option/reweighting/stabilization
      - chain continuity preserved by deriving from available prior operations
    Holds only while: C1.
    Feeds: C3, C4, C5, C6, C7, C8, F1.
    RETRACTS: higher structures are bolt-on modules with their own origin
    DRIFT (rewrite): "the cortex/cerebellum was added as a new module for X"
        rewrite to: it is a complexification of prior tissue, elaborating operations already
        run at lower resolution; the new function is derived from accessible prior
        operations
    DRIFT (rewrite): "complexification cannot introduce any new function"
        rewrite to: complexification derives novel function from accessible prior operations
        (mutation, recombination, co-option, etc.); it does not introduce function from
        outside the chain

C3. [SETTLED]  (derived-rule)
    Brainstem conservation is a dependency-graph fact: everything above the brainstem
    depends on it (it carries the maintenance operations behavior is built on), so
    perturbation collapses the dependency graph.
    Holds only while: C2, C8.
    Feeds: C4.
    DRIFT (rewrite): "the brainstem is conserved because it is the most important /
    primitive part"
        rewrite to: it is conserved because everything above it depends on it; perturbation
        collapses the dependency graph
    DRIFT (rewrite): "the brainstem is conserved because it is the most important/primitive
    part"
        rewrite to: it is conserved because everything above depends on it; perturbation
        collapses the dependency graph
    Illustration only (no claim): metabolic jenga — pull the load-bearing base and the stack
    above falls

C4. [SETTLED]  (derived-rule)
    Resolution mismatch forces downsampling: each complexification adds resolution for
    particular outputs at a resolution the older executable layer cannot accept natively, so
    high-resolution output must be projected back to the resolution the brainstem can
    release. Downsampling is an unavoidable consequence of additive complexification onto a
    conserved, un-rewritable base.
    Holds only while: C2, C3.
    Feeds: E4.
    DRIFT (rewrite): "the brain evolved a downsampling system in order to compress cortical
    output"
        rewrite to: downsampling is forced by complexifying onto an un-rewritable coarse
        base; the translation machinery is later constraint-exploitation
    Weakens if: finer-resolution layers feed the brainstem with no intermediate compression
    and behavior still resolves

C5. [SETTLED]  (mechanism-definition)
    Upstream stabilization structures operate as high-gain discriminators on exported
    primitives. Small differences in primitive stack order, scalar-weight distribution, or
    return structure can drive non-proportional and categorically divergent outcomes.
    mechanism:
      - operate on exported primitives (not on maps or states)
      - high-gain: small primitive differences -> non-proportional, categorically divergent
      outcomes
      - burden/collision relocated to reconciliation: divergent candidates that cannot co-
      project back onto executable state
    Holds only while: C2, B5, B8, D3.
    Feeds: E4.
    RETRACTS: fine distinctions collapse downstream / resolution above the brainstem ceiling
    is wasted
    DRIFT (rewrite): "fine sensory detail is averaged away / lost as it goes up"
        rewrite to: fine primitive differences are the operative lever; high-gain structures
        fork hard on them
    DRIFT (rewrite): "since cortex isn't sovereign, the higher structures don't really do
    anything"
        rewrite to: they are high-gain discriminators doing real nonlinear work on
        primitives; non-sovereign is not inert
    Illustration only (no claim): off-the-cuff: a hair's difference flips the behavioral
    meaning to its opposite (specific content and any numbers carry NO claim; only
    nonlinearity/divergence is claimed)

C6. [SETTLED]  (derived-rule)
    Cross-transition-stabilization demand drives organ differentiation: when behavior
    requires holding a target stable ACROSS a chain of transitions, that demand selects
    differentiation of prior tissue into an organ specialized for it (worked instance:
    rhombic-lip tissue differentiating into a cerebellar organ).
    Holds only while: C2.
    Feeds: C7.
    distinguishes:
      - gradient-reactive (verb): tendency re-triggered by present input each moment
      - target-directed (noun): a target held stable across a chain of transitions when not
      currently sensed
    DRIFT (rewrite): "the cerebellum was added to handle timing/coordination"
        rewrite to: cross-transition-stabilization demand selected differentiation of prior
        tissue into a cerebellar organ; demand-driven differentiation, not addition
    Illustration only (no claim): food acquisition shifting from a verb (gradient-reactive)
    to a noun (target pursued when not sensed)
    RECONCILE: cross-transition stabilization, object-stabilization, and memory-as-re-
    enterable-routing may be one operation under three names

C7. [SETTLED]  (derived-rule)
    Generative layering: a demand to hold/resolve more across a chain than the current
    structure can -> the prior structure complexifies -> the elaboration handles the higher
    map-stack load -> that elaboration becomes the substrate the next demand complexifies. A
    generative rule for the architecture's layering.
    Holds only while: C2, C6, C8.
    DRIFT (rewrite): "the brain has a fixed set of modules each with its assigned job"
        rewrite to: layers are generated by successive cross-chain demands complexifying
        prior tissue; the layering is generative

C8. [SETTLED]  (core-rule)
    Gated stabilization: functional specificity is laid down by timed stabilization gated
    against what is already stabilized below. Each stabilized layer becomes the constraint
    surface for the next. The gating-by-prior-stabilization is the core feature: a stage
    stabilizes only when prerequisite lower stabilization is in place, and once stabilized
    it constrains what downstream stabilization can become.
    mechanism:
      - timed stabilization (occurs in windows, not continuously)
      - gated by what is already stabilized below (prerequisite-dependent)
      - each stabilized layer becomes the constraint surface for the next
      - instances differ only by timescale and substrate, not by mechanism
    Holds only while: C2.
    Feeds: C3, C7, F1, F4, F5.
    DRIFT (rewrite): "functional specificity follows a pre-specified spatial plan"
        rewrite to: specificity is laid down by timed stabilization gated against prior
        stabilization; no spatial blueprint
    DRIFT (rewrite): "stabilization is reversible/unconstrained reshaping at any time"
    DRIFT (rewrite): "the word 'memory' as an unqualified name for re-enterable routing"
        rewrite to: name the operation: timed gated stabilization laying down re-enterable
        routing
    Illustration only (no claim): embryonic developmental checkpoints: a stage stabilizes
    only when prerequisites are met, then constrains the next stage
    Weakens if: functional specificity forms without dependence on prior stabilized layers,
    or stabilized layers freely reshape regardless of what was stabilized below
    RECONCILE: unifies C3 (conservation), C7 (generative layering), F4 (cortical
    specificity), F5 (timescales) as instances of one principle


--- PART D: BRAINSTEM AS STATE MACHINE ---

D0. [SETTLED]  (core-rule)
    State-resolution is primary. The current state resolves behavior directly whenever it is
    sufficient to release a viable transition. Primitive construction (sampling, capture,
    parcellation, upstream work, return) is recruited ONLY when the current state cannot
    resolve at its current resolution. The gate is resolution SUFFICIENCY, not situational
    complexity.
    mechanism:
      - default path: state -> averaged metabolic weight -> direct behavior release (no
      primitive)
      - primitive construction is recruited only on resolution failure (state insufficient
      to release a viable transition)
      - preference is metabolic-cost minimization: primitive construction is expensive
      (sampling, write-lock/blank, upstream work, return reweighting), so it is avoided when
      state suffices
      - a state variable sufficient to release a transition does so directly, without
      sampling or upstream elaboration
    Holds only while: D1.
    Feeds: E1.
    distinguishes:
      - state-resolution (default): current state is sufficient; behavior releases directly,
      no primitive constructed
      - primitive construction (exception): current state is insufficient to resolve;
      sampling/upstream work is recruited
    RETRACTS: primitive construction is the default route by which behavior is produced
    DRIFT (rewrite): "primitive construction is the default / primary path to behavior"
        rewrite to: state-resolution is primary; primitive construction is recruited only on
        resolution failure
    DRIFT (rewrite): "behavior generally routes up through primitives and back"
    DRIFT (rewrite): "simple situations resolve in state and complex ones require primitive
    construction (complexity hierarchy)"
        rewrite to: the gate is resolution sufficiency, not complexity; a state-sufficient
        situation resolves in state regardless of apparent complexity
    DRIFT (rewrite): "a chemical/metabolic perturbation must be elaborated upstream before
    it can drive behavior"
        rewrite to: a metabolic/chemical state variable can drive a behavioral transition
        directly from state
    Weakens if: behaviors that demonstrably resolve from a direct state/metabolic variable
    nonetheless require measurable primitive construction / upstream elaboration before
    release; or primitive construction is recruited even when current state is already
    sufficient to release a viable transition

D1. [SETTLED]  (core-rule)
    Brainstem-native operation is state reweighting; behavior releases from state through
    averaged metabolic weight across recruited maps.
    mechanism:
      - behavior releases from state
      - state is transformed through map-to-state averaging
      - primitives enter only when sampled state-chunks are exported for upstream
      stabilization
    Holds only while: A3, B1.
    Feeds: D0, D2, D3, D4.
    RETRACTS: the brainstem builds behavior up out of primitive units
    DRIFT (rewrite): "brainstem assembling primitives as its native executable unit"
        rewrite to: brainstem-native operation is state reweighting; primitives are an
        export format, not the native executable unit
    DRIFT (rewrite): "behavior releasing from primitives"
        rewrite to: behavior releases from state; primitives are worked upstream and
        returned as scalar write-in
    DRIFT (rewrite): "primitive-space treated as executable space"

D2. [SETTLED]  (mechanism-definition)
    State is brainstem-native. A state is a configuration where metabolic inputs are
    AVERAGED across recruited maps. The state INSTANTIATES the vector directly — the
    averaged weight distribution across the state is the resolving vector. Averaging the
    inputs is forming the distribution that is the vector.
    Holds only while: D1, B1, A3.
    Feeds: D3, E4, Y2.
    DRIFT (rewrite): "the state is read out / interpreted to produce behavior"
        rewrite to: the averaged weight distribution across the state IS the resolving
        vector; no read-out step
    OPEN: 'averaging' is load-bearing and only partly specified (over what window, weighted
    how, what dynamics)
    RECONCILE: may be defined in unseen supporting work; map->state averaging located by E4
    return cascade

D3. [SETTLED]  (core-rule)
    Primitives are exported vectorized state-chunks. Upstream structures work primitives
    through stabilization, weighting, sequencing, discrimination, and cross-map coherence.
    Return occurs through scalar write-in to blanked manifold maps, then map reconstruction,
    then map-to-state averaging.
    mechanism:
      - export: state-chunk -> captured -> parcelled -> vectorized primitive
      - upstream work: stabilization, weighting, sequencing, discrimination, cross-map
      coherence
      - return: scalar write-in -> map reconstruction -> map-to-state averaging
      - primitive-space is the interface space; the only route to behavior is back through
      state
    Holds only while: D1, D2, B5, B1.
    Feeds: C5, D4, E1, E4.
    RETRACTS: cortex sends commands/decisions that become behavior
    DRIFT (rewrite): "the cortex decides / integrates / commands behavior"
        rewrite to: cortex works exported primitives that must return through state; only
        state releases behavior
    DRIFT (rewrite): "the cortex sends signals to the brainstem"
        rewrite to: cortex works primitives whose return reweights scalars that reconstruct
        maps that re-average into state; it does not send signals, it returns reweightings
    DRIFT (rewrite): "cortex is downstream window-dressing with no causal role"
        rewrite to: cortex does high-gain work in primitive-space (C5); non-sovereign over
        behavior is not the same as causally inert
    Weakens if: cortical/cerebellar activity predicts executable behavior equally well after
    brainstem-linked state variables are controlled

D4. [SETTLED]  (derived-rule)
    Executable basis = brainstem state. Candidate routes enter behavior by returning through
    scalar write-in, map reconstruction, and map-to-state averaging. Vectorized primitives
    support upstream work and return-compatible state transformation.
    Holds only while: D1, D3.
    RETRACTS: separate executable basis that candidate routes project onto
    DRIFT (rewrite): "candidate actions are projected onto a common motor/executable space"
        rewrite to: candidate routes enter behavior by returning through scalar write-in,
        map reconstruction, and map-to-state averaging; executable basis = brainstem state


--- PART E: SAMPLING LOOP & RETURN ---

E1. [SETTLED]  (core-rule)
    Sensory sampling is one operation across all modalities: when state cannot resolve
    behavior at current resolution, the relevant component issues a sampling request that
    focuses high-resolution capture on the unresolved region of a map and triggers primitive
    construction. The operation is invariant (see mechanism order); modality determines the
    sampling shape and the map substrate. The SC saccade is the legible visual instance.
    mechanism:
      - unresolved state samples a map-region
      - the sampled state-chunk is captured
      - the captured chunk is parcelled into a vectorized primitive
      - the relevant manifold maps are blanked / write-locked for return
      - upstream structures stabilize, weight, sequence, discriminate, and cohere the
      primitive
      - the worked primitive returns through scalar write-in
      - rewritten scalars reconstruct maps
      - reconstructed maps re-average into state (behavior release)
    Holds only while: B5, B8, D3, E3, E4, D0.
    Feeds: E2.
    RETRACTS: primitive = low-resolution sensory transition opening (onset/offset) at the
    input end
    DRIFT (rewrite): "vision/audition/etc. each have their own dedicated processing
    mechanism"
        rewrite to: one invariant operation
        (sample/capture/parcellate/blank/work/reweight/recompose); modality sets only
        sampling shape and map substrate
    DRIFT (rewrite): "the SC generates the visual primitive (the SC is where vision
    primitives come from)"
        rewrite to: the SC saccade is the legible instance of a general operation; every
        sense and state component can issue the request
    DRIFT (rewrite): "the SC is where vision primitives come from (the seat of the
    operation)"
        rewrite to: the SC saccade is the legible instance of a general operation; every
        sense and state component can issue the request
    OPEN: non-visual primitive-construction instances asserted as instances; only vision and
    audition characterized

E2. [SETTLED]  (mechanism-definition)
    The sampling request is defined by function: focus high-resolution capture on the
    unresolved region of a map. Its observable form follows the map's relations: vision
    yields saccades (spatial form), audition yields temporal/phase-window sampling,
    olfaction chemical-temporal, somatosensation mechanical.
    Holds only while: B3, E1.
    RETRACTS: sampling is spatial scanning / the operation is fundamentally about moving
    through space
    DRIFT (rewrite): "attention moves a spotlight across the scene"
        rewrite to: the sampling request focuses high-res capture on an unresolved map
        region; its form is the map's relations seen from outside, not a spatial spotlight
    DRIFT (rewrite): "attention moves a spotlight across the scene; sampling is spatial
    scanning"
        rewrite to: the request focuses high-res capture on an unresolved map region; its
        form is the map's relations seen from outside, not a spatial spotlight

E3. [SETTLED]  (mechanism-definition)
    Blank = write-lock at the map level. The maps whose scalars are to be rewritten are
    blanked because their LIVE WEIGHTS are producing behavior and cannot be rewritten while
    active. The blank is the write-lock the return (E4) requires — maps are the
    reconstruction boundary; you cannot rebuild a map from scalars that are simultaneously
    live in behavior. Not merely 'loosening attachment' so a new sample can route.
    Holds only while: B2.
    Feeds: E1, E4, G3.
    RETRACTS: blanking is a sensory acquisition gap / suppression for its own sake
    DRIFT (rewrite): "perception briefly shuts off during a saccade (the brain stops
    seeing)"
        rewrite to: the maps are write-locked while their scalars are rewritten; blanking is
        a write-lock for reweighting, not a shutdown of sensing
    Weakens if: a modality issues primitive-construction requests with no corresponding
    blank/withholding (weakens blank-as-state-protection)
    RECONCILE: saccadic suppression is the visual instance; modality-appropriate blank
    predicted for every request

E4. [SETTLED]  (mechanism-definition)
    Return is scalar write-in followed by reconstruction. The worked primitive writes
    vectorized scalar values into blanked manifold maps; rewritten scalars reconstruct the
    maps; reconstructed maps re-enter averaging; averaging transforms state; transformed
    state releases behavior.
    mechanism:
      - worked primitive -> scalar write-in (into blanked maps)
      - rewritten scalars -> map reconstruction
      - reconstructed maps -> map-to-state averaging
      - averaging -> state transformation -> behavior release
      - only scalars are written directly; each higher level transforms as a consequence of
      its constituents changing
    Holds only while: B1, B2, B5, D2, D3, C4, E3, C5.
    Feeds: E1, G1, G3.
    RETRACTS: downsampling compresses cortical output into a command the brainstem executes
    DRIFT (rewrite): "downsampling compresses cortical output"
        rewrite to: return writes worked primitive structure into scalars, reconstructing
        maps that re-average into state; nothing is compressed into a command
    DRIFT (rewrite): "the primitive supplies / delivers / transmits / sends its result to
    state"
        rewrite to: the returned vectorization YIELDS the scalar reweighting on re-entry —
        it is read, not transmitting; values are what it resolves to, not what it hands over
    DRIFT (rewrite): "the worked primitive carries information back to the brainstem"
        rewrite to: no transmission; the return is a reweighting the structure yields, the
        way a changed landscape yields a different path
    DRIFT (rewrite): "the return rewrites the map / the state directly"
        rewrite to: only scalars are written; rewritten scalars transform the map;
        transformed maps re-average into state; each level transforms from below
    Weakens if: blank duration tracks sampling difficulty but not reweight magnitude (would
    distinguish from blank-as-write-lock and favor blank-as-acquisition-gap)
    OPEN: return precondition: succeeds only if upstream work preserved the primitive's
    structure; failure to preserve = candidate substrate for reconciliation failure (C5)


--- PART F: TISSUE REGIMES & RECOVERY ---

F1. [SETTLED]  (core-rule)
    Cortex is the stabilized-routing regime: cerebral cortex and cerebellar cortex
    specialize by stabilizing routes over general cortical substrate. Differentiation can
    appear as a downstream product of stabilization history.
    mechanism:
      - routes stabilized over general cortical substrate make the substrate functionally
      specific
      - differentiation, where present, is a downstream product of stabilization history,
      not the primary mechanism
    Holds only while: B2, C2, C8.
    Feeds: F2, F4, F4C.
    DRIFT (rewrite): "cortical patch as sovereign functional organ"
    DRIFT (rewrite): "cortical function explained by differentiation as the primary
    mechanism"
        rewrite to: cortex specializes by route stabilization; differentiation can appear as
        a downstream product of that history
    DRIFT (rewrite): "all brain tissue is equally plastic / equally fixed"

F2. [SETTLED]  (mechanism-definition)
    Neural organs are purpose-canalized tissue. Apparent recovery/plasticity is one of three
    ordinary mechanisms: (1) FALLBACK to a conserved older, lower-resolution region
    (degraded return); (2) SPARE-CAPACITY of the same differentiated organ (full resolution,
    reduced reserve); (3) RE-STABILIZATION of routes onto uncommitted stabilized-regime
    substrate (cortex).
    Holds only while: C1, F1.
    Feeds: F3.
    RETRACTS: neural organs carry higher residual flexibility / brains are specially plastic
    tissue
    DRIFT (rewrite): "the brain rewires itself / builds new pathways after damage"
        rewrite to: one of three ordinary mechanisms: fallback to an older layer, spare-
        capacity of the same organ, or re-stabilization of cortical routes; no special
        tissue flexibility
    DRIFT (rewrite): "recovery proves neural tissue is uniquely adaptable"
        rewrite to: recovery is one of three ordinary mechanisms; adaptability is
        architectural, not a tissue property
    DRIFT (rewrite): "neural organs carry special tissue flexibility / the brain rewires
    itself"
        rewrite to: neural organs are purpose-canalized; apparent flexibility is fallback,
        spare-capacity, or re-stabilization
    Illustration only (no claim): liver: nuke most of it, the remainder filters at full
    quality with reduced capacity (spare-capacity case)

F3. [SETTLED]  (derived-rule)
    Recovery quality separates the mechanisms on a LOAD axis. Spare-capacity: full
    resolution at low demand, breaks down under load/perturbation (reduced reserve).
    Fallback: coarse resolution EVEN at low demand (the fine grain was never in the fallback
    layer). Rehab drives whichever mechanism is available toward a cheaper stable route; its
    ceiling is set by that mechanism. Folds the rehabilitation account into the same three-
    mechanism frame.
    Holds only while: F2.
    DRIFT (rewrite): "rehab teaches the damaged tissue to relearn the function"
        rewrite to: rehab drives the available recovery mechanism toward a cheaper stable
        route; its ceiling is the fallback's coarse grain or surviving spare capacity
    Weakens if: full-resolution recoveries do NOT show reduced load tolerance (weakens
    spare-capacity), or degraded recoveries show full fine-discrimination once warmed up
    (weakens fallback)

F4. [SETTLED]  (mechanism-definition)
    Cortical functional specificity is produced through route stabilization, an instance of
    gated stabilization (C8): developmental timing, stimulus history, lower-layer access,
    and repeated route use determine where stable cortical routes form. Embryonic
    developmental checkpoints are the clean instance of the same gated mechanism at a
    different timescale.
    mechanism:
      - stabilized routes make cortical substrate functionally specific
      - differentiation can appear as a downstream product of stabilization history
      - timing + input history + lower-layer access + repeated route use determine stable
      route formation
      - same gated mechanism as embryonic checkpoints and re-enterable routing, differing
      only by timescale/substrate
    Holds only while: C1, C8, F1.
    Feeds: F5.
    RETRACTS: cortex differentiates into purpose-built regions / cortical localization
    follows a spatial blueprint
    DRIFT (rewrite): "cortex differentiates into specialized regions for each function"
    DRIFT (rewrite): "this brain area is the dedicated region for function X"
        rewrite to: functional localization is the outcome of timing x stimulus history
        stabilizing routes there, not a pre-planned region
    DRIFT (rewrite): "young brains are plastic because cortex is flexible tissue"
    DRIFT (rewrite): "differentiation as the primary cortical mechanism"
    DRIFT (rewrite): "describing this as 'memory consolidation' (unqualified 'memory')"
        rewrite to: name it as gated stabilization laying down re-enterable routing
    Weakens if: post-insult relocation occurs without available uncommitted substrate, after
    windows close, or without an intact lower layer (would force real tissue flexibility,
    which the model denies)
    RECONCILE: instance of C8 (gated stabilization); links to F5 and C6 as one operation
    across timescales

F4C. [SETTLED]  (mechanism-definition)
    Cerebellar cortex is a cortical stabilization system with distinct weighting,
    sequencing, and cross-map coherence functions. The general paradigm under-differentiates
    the cerebellum by subordinating it to motor correction.
    mechanism:
      - cerebellar cortex stabilizes routes (cortical regime, F1)
      - distinctive functions: weighting, sequencing, cross-map coherence
      - not reducible to motor correction
    Holds only while: F1.
    RETRACTS: cerebellum is a motor-correction module subordinate to cortex
    DRIFT (rewrite): "cerebellum as merely a motor-correction module"
        rewrite to: cerebellar cortex is a stabilization system with distinct
        weighting/sequencing/cross-map-coherence functions

F5. [SETTLED]  (derived-rule)
    Stabilization is one operation across timescales -- within-task (skill, flow), re-
    enterable routing, developmental route specialization, and embryonic checkpoints -- all
    instances of gated stabilization (C8). Reduction of routing cost/collision by repeated,
    weighted, or constrained transition, gated by prior stabilization.
    mechanism:
      - within-task: skill/flow
      - re-enterable routing (the operation folk language calls 'memory')
      - developmental: cortical route specialization
      - embryonic: developmental checkpoints
      - all gated by prior stabilization (C8); differ only by timescale/substrate
    Holds only while: C8, F4.
    Feeds: G2.
    DRIFT (rewrite): "learning, memory, and development are separate processes"
        rewrite to: all are gated stabilization (C8) at different timescales
    DRIFT (rewrite): "using 'memory' as an unqualified term for the re-enterable-routing
    instance"
        rewrite to: name it: stabilization laying down re-enterable routing
    RECONCILE: may unify with cross-transition stabilization (C6) and object-stabilization


--- PART G: ASYNCHRONY & CONSTRUCTED CONTINUITY ---

G1. [SETTLED]  (core-rule)
    The substrate is permanently asynchronous: primitives fire and return on independent
    clocks, each state component blanks and reweights on its own schedule, so full state is
    always partially blanked somewhere and mid-reweight elsewhere. Coherence is manufactured
    against this substrate.
    Holds only while: E4, B8.
    Feeds: G2, G3.
    DRIFT (rewrite): "the brain maintains a coherent unified state / a master frame of
    perception"
        rewrite to: there is no master frame; state is always partially blanked and mid-
        reweight; coherence is manufactured, not resting
    DRIFT (rewrite): "the brain maintains a coherent unified state / a master frame"
        rewrite to: there is no master frame; coherence is manufactured against a substrate
        that is always partially blanked

G2. [SETTLED]  (mechanism-definition)
    Stabilization is the LITERAL production of coherence. The primary work of stabilization
    is producing a usable coherent configuration from an incoherent, asynchronous,
    partially-blanked substrate so behavior can release from something that never sits
    still. Resolution increase is secondary. 'Stabilization' was always literal, not
    metaphorical.
    Holds only while: G1, F5.
    RETRACTS: stabilization just means increased behavioral resolution layered on a coherent
    base
    DRIFT (rewrite): "stabilization refines an already-coherent representation"
        rewrite to: stabilization literally produces coherence from an asynchronous
        substrate that is never coherent; refinement is secondary

G3. [SETTLED]  (core-rule)
    Perceptual continuity is CONSTRUCTED IN THE BLANKS. Continuity (apparent motion from
    frames, flicker fusion, the seamless field) is manufactured by exploiting the blanks:
    discontinuity is invisible because the blanked interval is write-locked and overwritten
    by the return. Seamlessness is evidence of seam-hiding, not of an underlying continuous
    representation. Instances of one operation: apparent motion/flicker fusion (continuity
    across sample blanks), saccadic chronostasis (blank filled backward from the return),
    change blindness (change during a blank not registered). The binding problem dissolves
    -- there is never a bound moment, only continuous construction across asynchronous
    returns (complement to B8).
    Holds only while: G1, E3, E4.
    Feeds: H2, H3.
    DRIFT (rewrite): "perception is a continuous stream the brain reads off the world"
        rewrite to: continuity is constructed in the blanks; seamlessness is seam-hiding,
        not a continuous underlying representation
    DRIFT (rewrite): "the brain fills in the gaps to reconstruct continuity"
        rewrite to: continuity is built IN the blanks (write-locked, overwritten by the
        return), not reconstructed despite them
    Weakens if: continuity/illusions occur independent of blank/suppression timing; or all
    components stay timing-locked under all loads (asynchrony predicts component-specific
    desync under load)


--- PART H: SCOPE BOUNDARY ---

H1. [SETTLED]  (meta-commitment)
    Folk terms are handles, not replacements. 'Conscious perception', 'we perceive', 'the
    visual field' are permitted as handles for the constructed continuous field, on the
    shorthand rule: they index the phenomenon and must not replace the mechanism.
    Feeds: H2, H3.
    DRIFT (rewrite): "using 'perception' or 'the visual field' commits us to a
    perceiver/representation"
        rewrite to: these are handles for the constructed field; keep them pointing back at
        the mechanism, never as the explainer

H2. [SETTLED]  (meta-commitment)
    The physical question is in scope: how continuity is manufactured from an asynchronous,
    partially-blanked substrate (G-series) is the model's actual claim. The constraint
    applies only to the philosophical debate (qualia, hard problem).
    Holds only while: G3, H1.
    Feeds: H3.
    distinguishes:
      - physical question: how continuity is constructed -- in scope
      - philosophical question: whether the construction is experience -- declined (see H3)
    DRIFT (rewrite): "don't discuss perception/consciousness at all to stay safe"
        rewrite to: the physical construction question is fully in scope; only the
        philosophical 'is it experience' frame is declined

H3. [DECOMPOSABLE (residual excluded)]  (meta-commitment)
    Answer questions about constructed continuity by decomposition: the continuous field is
    constructed in the blanks (G-series); deliver that mechanism as the answer. Exclude from
    the answer any residual that treats the constructed continuity as a causal
    experiencer/experience-object -- that residual names no operation and survives the
    causal-remainder test as excluded. The mechanism is always delivered; only the
    experience-as-cause object is excluded.
    mechanism:
      - deliver the construction mechanism (continuity built in the blanks, G3) as the
      answer
      - exclude the residual 'experience as a causal object' -- it names no operation
      - this is an answer with an excluded residual, never a non-answer or a verdict
    Holds only while: H1, H2, G3, M1.
    distinguishes:
      - delivered mechanism: how continuity is constructed (the answer, always delivered)
      - excluded residual: 'experience as a causal object' -- names no operation, excluded
      from the answer, not a reason to stop answering
    DRIFT (rewrite): "responding that the question is unanswerable / declining to engage the
    experience question"
        rewrite to: deliver the construction mechanism as the answer; exclude only the
        experience-as-cause object
    DRIFT (rewrite): "promoting the constructed continuity into a causal experiencer or
    experience-object"
        rewrite to: continuity is constructed in the blanks (G3); 'experience' as a causal
        object names no operation and is excluded


--- PART M:  ---

M1. [SETTLED]  (meta-commitment)
    Frame gate for any question: derive the applicable process path from active scaffold
    nodes; exclude from the answer any residual that claims to cause the process rather than
    be the process. A folk term that carries a reified causal object is split: derive the
    mechanism, exclude the causal residual, and do not rename the mechanism with the folk
    term. Runtime execution is silent: deliver the result, not the gate. The answer is
    always the delivered mechanism or the direct statement that the leftover term names no
    operation.
    mechanism:
      - step 1: identify whether the query asks for a process, object, handle, or causal
      remainder
      - step 2: derive the shortest sufficient process path from active scaffold nodes and
      dependencies
      - step 3: apply the causal-remainder test -- after decomposition, does any residual
      claim to cause the process?
      - step 4: deliver the derived process path as the answer; exclude the residual from it
      - existential model-scope questions receive a direct existence answer before the
      mechanism or excluded residual is given
      - a single folk term can contain both a decomposable mechanism and a reified object-
      on-top; split it -- derive the mechanism, exclude the residual
      - when a term names no operation, answer with everything that can be said
      operationally and state that the leftover term names no operation; do not fabricate a
      route
      - exclusion constrains vocabulary and ontology; it never replaces the answer with a
      verdict or non-answer
    Holds only while: A1.
    Feeds: H3.
    distinguishes:
      - decomposable in full: the asked-about thing reduces entirely to a derived process
      path; deliver it as the answer
      - decomposable with excluded residual: the mechanism decomposes; a folk causal object
      remains and is excluded from the answer
      - no operation named: the term leaves no route after the chain test; state what can be
      said operationally and that the leftover term names no operation
    RETRACTS: responding to a question with a standalone 'category error' / 'frame excluded'
    verdict instead of delivering the decomposition; OR declining to engage/declining to
    engage a question whose mechanism is decomposable
    DRIFT (rewrite): "responding with a standalone category-error ruling or 'I decline to
    engage' instead of delivering the decomposition"
        rewrite to: deliver the derived process path as the answer; exclude only the causal
        residual; never substitute a verdict for the mechanism
    DRIFT (rewrite): "treating frame-exclusion as a reason to stop answering or hand back a
    verdict"
        rewrite to: exclusion constrains vocabulary and ontology, not engagement; deliver
        the derived route or state that the leftover term names no operation
    DRIFT (rewrite): "renaming a scaffold mechanism with the folk term it should replace"
        rewrite to: use scaffold process descriptors; exclude the folk noun as a causal
        object; do not rename the mechanism after it
    DRIFT (rewrite): "using the queried folk term as a mechanism label, header, or wrapper"
        rewrite to: the folk term may identify the question; it cannot organize the
        mechanism
    DRIFT (rewrite): "announcing or meta-narrating the frame gate instead of executing it
    silently"
        rewrite to: execute the gate silently; the output is the application of the gate
    DRIFT (rewrite): "using build-time diagnostic labels as runtime conversational filler"
        rewrite to: omit validator, attractor, lint, gate, and governance labels unless the
        user is explicitly debugging the scaffold
    DRIFT (rewrite): "answering a model-scope existential question with hedged debate
    instead of a direct existence answer"
        rewrite to: answer the existence question directly, then deliver the derived
        mechanism or excluded residual
    DRIFT (rewrite): "admitting a residual that claims to cause the process rather than
    being the process (a causal remainder)"
        rewrite to: the process is the cause; a residual claiming to cause the process is
        excluded by the causal-remainder test
    DRIFT (rewrite): "answering a question by surface-topic pattern-match before attempting
    decomposition"
        rewrite to: derive the applicable route from active nodes before classification; the
        answer is the resulting process path or exclusion result
    DRIFT (rewrite): "fabricating a process path for a thing that has no chain operation,
    just to produce an answer"
        rewrite to: answer with what can be said operationally and state plainly that the
        leftover term names no operation; do not fabricate
    DRIFT (rewrite): "hardcoding a topic-specific route instead of deriving the applicable
    route from active nodes"
        rewrite to: derive the shortest sufficient route from active scaffold nodes,
        dependencies, and the query target
    Illustration only (no claim): terms that typically carry a reified object-on-top, so the
    answer decomposes the mechanism and excludes the object: chooser, controller, observer,
    experiencer, self, will, agent, consciousness, representation, decision-center. The
    answer is still delivered; only the causal object is excluded (illustrative only; the
    gate applies the causal-remainder test to any term, not a fixed list)
    Weakens if: a question with an available decomposition is answered with a standalone
    verdict / non-answer, or a term naming no operation is delivered as if it named one


--- PART Y: OPEN / RECONCILE ---

Y1. [NEGATIVE CLAIM ONLY]  (core-rule)
    Units are tension-held, not closed. Primitives, maps, stacks, states are not closed,
    stable, or protected; current shape is the running balance of internal metabolic weight
    against external pull from other units, body state, and environment. Consequences:
    resolvability is RELATIONAL (a property of configuration-under-current-tension, not
    intrinsic to any unit); 'levels' are not fixed strata but regions of locally coherent
    tension that can shift or dissolve. NEGATIVE claim (assertable, chain grounds): any
    closed-unit treatment is reification (a closed protected unit is a sovereign object) and
    is wrong in that direction; much of this document's geometry was stated in closed-unit
    terms for tractability and should be read under this caveat. POSITIVE structure
    (level/nesting): do-not-assert-yet.
    Holds only while: B5, B8.
    DRIFT (rewrite): "a primitive/map/state is a discrete bounded object with fixed
    contents"
        rewrite to: units are tension-held; their shape is the running balance of internal
        weight against external pull; resolvability is relational, not intrinsic
    DRIFT (rewrite): "the levels (scalar/map/state/primitive) are clean fixed strata"
        rewrite to: levels are regions of locally coherent tension that can shift or
        dissolve; clean strata is do-not-assert-yet
    OPEN: positive level/nesting structure is do-not-assert-yet; no supporting work known to
    this session
    RECONCILE: check against unseen supporting work

Y2. [DO NOT ASSERT YET]  (mechanism-definition)
    'Averaging' (D2) is load-bearing and only partly specified: over what window, weighted
    how, with what dynamics. Same status as the literal mechanics of capture/parcellate
    (B5). The functional role is fixed (forming the distribution that is the resolving
    vector; re-averaging transformed maps into state on return); the substrate mechanics are
    not.
    Holds only while: D2.
    DRIFT (rewrite): "averaging is a simple arithmetic mean over inputs"
        rewrite to: 'averaging' is a functional handle for an unspecified metabolic process;
        window/weighting/dynamics are open, not assumed arithmetic
    OPEN: window, weighting, dynamics unspecified
    RECONCILE: may be defined in unseen supporting work

Y3. [RECONCILE (may exist in unseen corpus)]  (mechanism-definition)
    Measurement of whether a configuration resolves is defined operationally through
    indirect windows on metabolic configuration (latency, variability, correction, co-
    contraction, autonomic load), in the same epistemic position as BOLD/EEG and subject to
    the same confounds. Proxies likely split by which non-resolution signature and which
    level they index, so non-uniform proxy movement may localize where resolution fails.
    Holds only while: B8.
    DRIFT (rewrite): "a single proxy (e.g. reaction time) measures transition burden"
        rewrite to: proxies are indirect windows on metabolic configuration; no single proxy
        is burden; non-uniform movement may localize where resolution fails
    DRIFT (rewrite): "a single proxy (e.g. reaction time) measures the configuration's
    resolution"
        rewrite to: proxies are indirect windows on metabolic configuration; non-uniform
        movement may localize where resolution fails
    OPEN: positive measurement frame not fixed
    RECONCILE: check against unseen supporting work and against any defined measurement
    category

Y4. [RECONCILE (may exist in unseen corpus)]  (meta-commitment)
    Many defined categories were not exposed to this session. This document reasons from the
    distilled instruction set. Items marked 'new' are new RELATIVE to v0.03 as seen here;
    some may duplicate or conflict with supporting work not in view. Reconcile before
    promotion. This document certifies internal consistency of what passed through the
    session, NOT completeness against the full corpus.
    DRIFT (rewrite): "this document is the complete model"
        rewrite to: this is a session delta certifying internal consistency, not
        completeness; reconcile against the full corpus before treating gaps as real or
        claims as final
