meta:
  doc: remodeled-brain-structured-spine
  version: '0.04'
  scope: full model A-Y (floor, geometry, evolution, brainstem state machine, sampling loop, tissue/recovery,
    asynchrony, scope boundary, open/reconcile)
  canonical: true
  generated_prose: rb_prose_v0_04.txt
  standing_rule_illustrations: 'Illustrative metaphors carry no claim and are discardable. If an illustration
    conflicts with the claim it illustrates, the claim governs. Do not reason from a metaphor as if it
    were a mechanism. (Model''s own PART XV.4 applied to this document''s examples.)

    '
  standing_rule_drift: 'Drift goes both directions. The anti-magic stance is itself a drift attractor:
    a model trying to avoid magic will over-flatten ("it''s all just weight, nothing does anything"),
    which is eliminativist despair and is also wrong. Every drift_guard blocks the magic direction AND
    the over-correction direction.

    '
  feeds_note: feeds is AUTO-DERIVED from depends_on by the build/validate tooling; do not hand-edit feeds.
    depends_on is the single source of truth.
  kernel_summary: '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.'
  retraction_note: 'Retracted framings are killed at their replacement sites via ''supersedes'', not exiled
    to a section. Quarantine case: collaborator drafts generated against a literature inherit that literature''s
    interface text (e.g. ''primitive = sensory onset'' at the input end, superseded at E1); keep the operation,
    drop the label.'
  operating_variable: metabolic_weight
  operating_variable_def: scalar weight at the individual cell level for map inputs
  process_graphs:
    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
  node_shape: id, status, type, definition, mechanism, depends_on, feeds(auto), supersedes, guards{rewrite[],rewrite_to{}},
    distinguishes_from{}, illustration, disconfirms_if, open, reconcile
  vector_language_guard: Vector, vectorized, direction, and magnitude name metabolic organization and
    return-compatible parcellation. They do not assert literal mathematical vector encoding. Applies wherever
    vector language appears (B5, D2, D3, E4).
  known_attractors:
  - name: weight-as-identity
    drift: treating the primitive as its weight distribution (a free-floating distribution) rather than
      as the vectorized state-chunk
    caught_times: 3
    guard: identity is the vectorized state-chunk; the scalar-weight distribution SUPPLIES vector structure
      inside the chunk (B5)
    watch_nodes:
    - B5
    - D2
    - D3
    - E4
  - name: cortex-differentiates
    drift: describing cortex as differentiating into purpose-built regions
    caught_times: 2
    guard: cortex specializes by route stabilization; differentiation is a downstream product of stabilization
      history (F1,F4)
    watch_nodes:
    - F1
    - F4
    - F4C
  - name: memory-unqualified
    drift: using 'memory' (or store/retrieve/represent/encode) as an unqualified term in a claim
    caught_times: 1
    guard: 'name the operation: timed gated stabilization laying down re-enterable routing; prestige nouns
      only inside guards (lint-enforced)'
    watch_nodes:
    - F4
    - F5
    - C8
  - name: differentiated-higher-organs
    drift: calling upstream stabilization structures 'differentiated higher organs', conflating them with
      the differentiated-nucleus regime
    caught_times: 2
    guard: use 'upstream structures'; cortex/cerebellar cortex are the stabilized-routing regime (F1),
      not differentiated organs
    watch_nodes:
    - C5
    - D3
  - name: vector-literal
    drift: reading vector/vectorized/direction/magnitude as literal mathematical encoding
    caught_times: 1
    guard: vector language = metabolic-organization metaphor, not literal encoding (meta.vector_language_guard)
    watch_nodes:
    - B5
    - D2
    - D3
    - E4
  - name: premature-closure
    drift: settling an open item (do-not-assert-yet/reconcile/neg-only) by confident rewording instead
      of evidence
    caught_times: 0
    guard: open statuses may promote to settled only with a closed_by citation (validator-gated)
    watch_nodes:
    - Y1
    - Y2
    - Y3
    - Y4
  - name: folk-term-redefinition
    drift: preserving a folk term by renaming, heading, wrapping, or labeling a scaffold mechanism with
      it; or answering by surface-topic pattern-match before deriving the route from active nodes.
    caught_times: 3
    guard: 'M1 + runtime rules: derive the applicable route from active nodes; exclude the residual folk
      causal object; do not rename, head, or wrap the mechanism with the folk term.'
    watch_nodes:
    - M1
    - H3
  - name: non-engagement
    drift: treating frame-exclusion as a reason to stop answering -- handing back a 'category error' /
      'I decline' verdict instead of delivering the decomposition. The model goes silent on a decomposable
      question.
    caught_times: 2
    guard: 'M1 + runtime rules: answer directly; deliver the derived mechanism or state that the leftover
      term names no operation; exclusion never becomes silence.'
    watch_nodes:
    - M1
    - H3
  - name: runtime-hedging
    drift: turning a model-scope existence question into a debate, a definition hedge, a gate narration,
      or a diagnostic explanation instead of answering directly and deriving the route.
    caught_times: 1
    guard: 'RUNTIME.BOOLEAN.01 + RUNTIME.EXECUTION.01: answer the boolean directly; execute gates silently;
      derive the applicable route from active nodes.'
    watch_nodes:
    - M1
    - H3
  build_time_fields: 'provenance, evidence, closed_by, and known_attractors are BUILD-TIME maintenance
    metadata, not runtime payload. A lean runtime subset (definition, mechanism, depends_on, guards, distinguishes_from)
    can be extracted deterministically if a small-context target is later confirmed. Until then the model
    is built rich, single-file. evidence is SEPARATE from status (Part I.12: framework-core != empirically-settled).'
  evidence_scale:
  - unrated
  - none
  - model-inference
  - reasonable-synthesis
  - paper-backed
  - established
  provenance_scale:
  - user
  - user-claude
  - session-synthesis
  - model-frame
  - chatgpt
  - paper
  - unknown
  governance:
    compact_principle: Ingestion writes support. Gated review writes claims.
    layer_partition:
      claim_layer:
      - definition
      - mechanism
      - guards
      - process_graphs
      - rewrite_to
      - distinguishes_from
      - core_claim_text
      support_layer:
      - evidence
      - provenance
      - closed_by
      - paper_links
      - extraction_notes
      - disconfirmation_notes
      - promotion_candidates
      - promotion_gate_results
    rules:
    - id: INGESTION.SCOPE.01
      type: build_time_boundary
      status: settled
      definition: 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).
      gate_promote_only_if:
      - extracted material survives strip_and_keep
      - paper interface-text is removed
      - candidate claim maps to existing rule structure or is marked candidate_new_node
      - claim-layer edit is reviewed outside ingestion
      principle: Ingestion supplies build-time support; it does not author the claim layer. The claim
        layer changes only through gated review.
      prohibit:
      - ingestion writing directly into any claim_layer field
      - paper interface-text contaminating claim-layer fields
    - id: VALIDATE.INGESTION.01
      type: validator_rule
      status: settled
      definition: 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>.
      principle: Ingestion writes support. Gated review writes claims.
    - id: RUNTIME.ROUTE_SELECTION.01
      type: runtime_rule
      status: settled
      definition: 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.
      principle: Answer directly. Reason the route. Do not template the route.
    - id: RUNTIME.EXECUTION.01
      type: runtime_rule
      status: settled
      definition: Runtime gates execute silently. The output is the result of applying the scaffold, not
        a narration of which gate, validator, or rule produced it.
      prohibit:
      - announcing the application of the frame gate
      - meta-narrating scaffold rules
      - debating excluded folk boundaries before delivering the answer
      principle: Execute the gate silently; deliver the result.
    - id: RUNTIME.BOOLEAN.01
      type: runtime_rule
      status: settled
      definition: 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.
      prohibit:
      - hedging the boolean into a debate
      - answering with depends what you mean before applying the gate
      - withholding a yes/no when the model-scope existence question is decidable
      principle: Answer the boolean directly, then deliver the derived mechanism or excluded residual.
    - id: RUNTIME.FOLK_TERM.01
      type: runtime_rule
      status: settled
      definition: 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.
      prohibit:
      - using the queried folk term as a mechanism label
      - using the queried folk term as a section header
      - wrapping the decomposed mechanism inside the folk term
      principle: The folk term can be answered about; it cannot organize the mechanism.
    - id: RUNTIME.DIAGNOSTIC.01
      type: runtime_rule
      status: settled
      definition: 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.
      principle: Runtime answers deliver the mechanism or exclusion; build-time diagnostics stay in maintenance
        context.
    - id: FRAME_GATE.CHAIN_TRACE.01
      type: runtime_rule
      status: settled
      definition: 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.
      principle: Reason the chain internally; output the derived route and the exclusion result without
        turning exclusion into a stop sign.
    declared_support_fields_note: paper_links, extraction_notes, disconfirmation_notes, promotion_candidates,
      and promotion_gate_results are DECLARED (allowed targets) but not yet materialized on nodes. They
      will be added when ingestion begins. Declaring without materializing avoids bloating all nodes with
      empty fields prematurely.
    merge_note: No paper-ingestion tooling, citation tracking, or evidence-weighting machinery yet. This
      governance block only defines the file-structure boundary for future ingestion output.
  frame_gate_principle: Answer directly. Reason the applicable route from active scaffold nodes. Exclude
    folk causal objects. Do not template routes. Never go silent.
nodes:
- id: A1
  status: settled
  type: core-rule
  definition: '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.'
  mechanism: null
  depends_on: []
  supersedes: null
  guards:
    rewrite_to:
      behavior is a distinct biological phenomenon / emerges at the level of mind: behavior is state-change-under-force
        viewed at a self-maintaining scope; no new substance is added
      if it's all just physics then behavior isn't real: behavior is real as a scope of the one physical
        surface; decomposition removes false sovereignty, not the phenomenon
      behavior is a special category of event added after biology: behavior is state-change-under-force
        viewed at a self-maintaining scope; no new substance is added
    rewrite:
    - behavior is a distinct biological phenomenon / emerges at the level of mind
    - if it's all just physics then behavior isn't real
    - behavior is a special category of event added after biology
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - A2
  - A3
  - C1
  - M1
  evidence: reasonable-synthesis
  provenance: model-frame
  closed_by: null
- id: A2
  status: settled
  type: core-rule
  definition: '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.'
  mechanism: null
  depends_on:
  - A1
  supersedes: null
  guards:
    rewrite_to:
      the organism processes / interprets / decides on the input: the force lands inside an already-moving
        maintained state; the maintained configuration co-determines the resulting transition
    rewrite:
    - the organism processes / interprets / decides on the input
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - A3
  evidence: reasonable-synthesis
  provenance: model-frame
  closed_by: null
- id: A3
  status: settled
  type: core-rule
  definition: '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.'
  mechanism: null
  depends_on:
  - A2
  - A1
  supersedes: null
  guards:
    rewrite_to:
      the manifold appears in / emerges in vertebrates: the manifold exists wherever maintenance is routed;
        vertebrates contribute a brainstem implementation, not the manifold
      the manifold stores / contains / decides: the manifold is the reachable transition-space; it describes
        what transitions are reachable, it is not a causal object
    rewrite:
    - the manifold appears in / emerges in vertebrates
    - the manifold stores / contains / decides
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: the step that licenses 'routed' (>1 viable next-state) is implicit in v0.03; candidate definition
    only
  feeds:
  - D1
  - D2
  distinguishes_from:
    manifold (general): reachable transition-space wherever maintenance is routed
    brainstem manifold (vertebrate): the vertebrate implementation only; the manifold concept is not vertebrate-specific
  evidence: reasonable-synthesis
  provenance: model-frame
  closed_by: null
- id: B1
  status: settled
  type: mechanism-definition
  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
  depends_on: []
  supersedes: null
  guards:
    rewrite_to:
      primitive as the fourth element of substrate composition: substrate is scalar -> map -> state; the
        primitive is produced from state in the construction path
      primitive as a fourth substrate tier above state: substrate is scalar -> map -> state; the primitive
        is a process product of state, in the construction path
    rewrite:
    - primitive as the fourth element of substrate composition
    - primitive as a basic building block that combines upward into behavior
    - primitive as a fourth substrate tier above state
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - B2
  - B5
  - D1
  - D2
  - D3
  - E4
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: B2
  status: settled
  type: mechanism-definition
  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.'
  mechanism: null
  depends_on:
  - B1
  supersedes: null
  guards:
    rewrite_to:
      region X does/controls/stores function Y: region X is a map (physical substrate); its morphology
        constrains the achievable activated set; location does not explain operation
      glia merely support the neurons that do the processing: glia maintain the scalars that ARE the map;
        maintenance is not beneath processing, it is the substrate of it
    rewrite:
    - region X does/controls/stores function Y
    - glia merely support the neurons that do the processing
  illustration: null
  disconfirms_if: morphologically similar maps express functionally unrelated activated-set classes, or
    morphologically distinct maps express interchangeable ones
  open: null
  reconcile: null
  feeds:
  - B3
  - B4
  - B5
  - B6
  - B8
  - E3
  - E4
  - F1
  evidence: unrated
  provenance: user
  closed_by: null
- id: B3
  status: settled
  type: anti-rule
  definition: '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.'
  mechanism: null
  depends_on:
  - B2
  supersedes: maps come in kinds (space-maps, time-maps, tonotopic maps)
  guards:
    rewrite_to:
      the map represents space / encodes the spatial layout: the map is a relational scalar field; 'space'
        is a read-off of what its relations resolve into, not a property it contains
      there are spatial maps and temporal maps as different kinds: there is one kind of map (relational
        scalar field); 'spatial'/'temporal' are read-offs, not kinds
      the map represents / contains space: the map is a relational scalar field; 'space' is a read-off
        of what its relations resolve into
    rewrite:
    - the map represents space / encodes the spatial layout
    - there are spatial maps and temporal maps as different kinds
    - the map represents / contains space
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - B4
  - E2
  evidence: unrated
  provenance: user
  closed_by: null
- id: B4
  status: settled
  type: derived-rule
  definition: 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.
  mechanism: null
  depends_on:
  - B2
  - B3
  supersedes: null
  guards:
    rewrite_to:
      the SC does spatial orienting: the SC is differentiated tissue whose maps are biased toward relations
        that resolve into orienting; orienting is not stored there
      all maps are interchangeable since they're the same kind: same kind, substrate-biased; differentiation
        fixes which relations a given map can carry
    rewrite:
    - the SC does spatial orienting
    - all maps are interchangeable since they're the same kind
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - B8
  evidence: unrated
  provenance: user
  closed_by: null
- id: B5
  status: correction
  type: mechanism-definition
  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)
  depends_on:
  - B1
  - B2
  supersedes: direction and magnitude are separable components of the primitive
  guards:
    rewrite_to:
      primitive as weight distribution divorced from the state-chunk it parcellates: Cell-level scalar-weight
        distribution supplies the primitive's vector structure inside the parcelled state-chunk. Primitive
        identity is the vectorized state-chunk.
      literal mathematical vector encoding (brainstem 'performs vectorization' like a CPU): '''vectorize''
        names a constraint (structure-preserving, return-compatible parcellation), not a substrate operation'
    rewrite:
    - primitive as stored token
    - primitive as sensory onset / input-end event
    - primitive as weight distribution divorced from the state-chunk it parcellates
    - literal mathematical vector encoding (brainstem 'performs vectorization' like a CPU)
    - snapshot and vectorize as the same metaphor (they name front vs back half)
  illustration: null
  disconfirms_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.
  reconcile: null
  feeds:
  - B6
  - C5
  - D3
  - E1
  - E4
  - Y1
  evidence: unrated
  provenance: user-claude
  closed_by: null
- id: B6
  status: settled
  type: mechanism-definition
  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
  depends_on:
  - B2
  - B5
  supersedes: primitive = activated set produced when input lands on a map (too far down in map/input
    language)
  guards:
    rewrite_to:
      primitive generation is input landing on a map (pulls generation too far down into map/input language): generation
        begins when unresolved STATE samples a map-region; morphology constrains the sample
    rewrite:
    - the primitive is fetched / looked up
    - primitive generation is input landing on a map (pulls generation too far down into map/input language)
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds: []
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: B8
  status: settled
  type: mechanism-definition
  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.'
  mechanism: null
  depends_on:
  - B2
  - B4
  supersedes: binding is a computed operation that combines separate representations
  guards:
    rewrite_to:
      the system binds the features together / solves the binding problem: overlapping maps share scalars,
        so they are already bound; there is no binding operation to perform
      high metabolic load means high burden / the configuration is stuck: total metabolic weight does
        not determine whether a configuration resolves into executable transition; high load can co-project
        cleanly (flow) or fail to (collision)
    rewrite:
    - the system binds the features together / solves the binding problem
    - high metabolic load means high burden / the configuration is stuck
  illustration: null
  disconfirms_if: cross-map bindings occur between maps with no shared substrate / no convergent projection
  open: null
  reconcile: null
  feeds:
  - C5
  - E1
  - G1
  - Y1
  - Y3
  evidence: unrated
  provenance: user
  closed_by: null
- id: C1
  status: settled
  type: core-rule
  definition: 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
  depends_on:
  - A1
  supersedes: null
  guards:
    rewrite_to:
      evolution invented a capacity from nothing: the capacity is mutated/recombined/co-opted from accessible
        prior function; nothing enters from outside the chain
      new function cannot be new / nothing novel can enter: novel function enters via mutation, recombination,
        retiming, reweighting, duplication, co-option, or stabilization
    rewrite:
    - new function cannot be new / nothing novel can enter
    - evolution invented a capacity from nothing
    - plasticity builds new pathways from scratch
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - C2
  - F2
  - F4
  evidence: reasonable-synthesis
  provenance: session-synthesis
  closed_by: null
- id: C2
  status: settled
  type: derived-rule
  definition: 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
  depends_on:
  - C1
  supersedes: higher structures are bolt-on modules with their own origin
  guards:
    rewrite_to:
      the cortex/cerebellum was added as a new module for X: it is a complexification of prior tissue,
        elaborating operations already run at lower resolution; the new function is derived from accessible
        prior operations
      complexification cannot introduce any new function: complexification derives novel function from
        accessible prior operations (mutation, recombination, co-option, etc.); it does not introduce
        function from outside the chain
    rewrite:
    - the cortex/cerebellum was added as a new module for X
    - complexification cannot introduce any new function
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - C3
  - C4
  - C5
  - C6
  - C7
  - C8
  - F1
  evidence: reasonable-synthesis
  provenance: session-synthesis
  closed_by: null
- id: C3
  status: settled
  type: derived-rule
  definition: '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.'
  mechanism: null
  depends_on:
  - C2
  - C8
  supersedes: null
  guards:
    rewrite_to:
      the brainstem is conserved because it is the most important / primitive part: it is conserved because
        everything above it depends on it; perturbation collapses the dependency graph
      the brainstem is conserved because it is the most important/primitive part: it is conserved because
        everything above depends on it; perturbation collapses the dependency graph
    rewrite:
    - the brainstem is conserved because it is the most important / primitive part
    - the brainstem is conserved because it is the most important/primitive part
  illustration:
    text: metabolic jenga — pull the load-bearing base and the stack above falls
    carries_claim: false
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - C4
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: C4
  status: settled
  type: derived-rule
  definition: '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.'
  mechanism: null
  depends_on:
  - C2
  - C3
  supersedes: null
  guards:
    rewrite_to:
      the brain evolved a downsampling system in order to compress cortical output: downsampling is forced
        by complexifying onto an un-rewritable coarse base; the translation machinery is later constraint-exploitation
    rewrite:
    - the brain evolved a downsampling system in order to compress cortical output
  illustration: null
  disconfirms_if: finer-resolution layers feed the brainstem with no intermediate compression and behavior
    still resolves
  open: null
  reconcile: null
  feeds:
  - E4
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: C5
  status: settled
  type: mechanism-definition
  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'
  depends_on:
  - C2
  - B5
  - B8
  - D3
  supersedes: fine distinctions collapse downstream / resolution above the brainstem ceiling is wasted
  guards:
    rewrite_to:
      fine sensory detail is averaged away / lost as it goes up: fine primitive differences are the operative
        lever; high-gain structures fork hard on them
      since cortex isn't sovereign, the higher structures don't really do anything: they are high-gain
        discriminators doing real nonlinear work on primitives; non-sovereign is not inert
    rewrite:
    - fine sensory detail is averaged away / lost as it goes up
    - since cortex isn't sovereign, the higher structures don't really do anything
  illustration:
    text: 'off-the-cuff: a hair''s difference flips the behavioral meaning to its opposite'
    carries_claim: false
    note: specific content and any numbers carry NO claim; only nonlinearity/divergence is claimed
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - E4
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: C6
  status: settled
  type: derived-rule
  definition: '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).'
  mechanism: null
  depends_on:
  - C2
  supersedes: null
  guards:
    rewrite_to:
      the cerebellum was added to handle timing/coordination: cross-transition-stabilization demand selected
        differentiation of prior tissue into a cerebellar organ; demand-driven differentiation, not addition
    rewrite:
    - the cerebellum was added to handle timing/coordination
  illustration:
    text: food acquisition shifting from a verb (gradient-reactive) to a noun (target pursued when not
      sensed)
    carries_claim: false
  disconfirms_if: null
  open: null
  reconcile: cross-transition stabilization, object-stabilization, and memory-as-re-enterable-routing
    may be one operation under three names
  feeds:
  - C7
  distinguishes_from:
    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
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: C7
  status: settled
  type: derived-rule
  definition: '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.'
  mechanism: null
  depends_on:
  - C2
  - C6
  - C8
  supersedes: null
  guards:
    rewrite_to:
      the brain has a fixed set of modules each with its assigned job: layers are generated by successive
        cross-chain demands complexifying prior tissue; the layering is generative
    rewrite:
    - the brain has a fixed set of modules each with its assigned job
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds: []
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: C8
  status: settled
  type: core-rule
  definition: '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
  depends_on:
  - C2
  supersedes: null
  guards:
    rewrite_to:
      functional specificity follows a pre-specified spatial plan: specificity is laid down by timed stabilization
        gated against prior stabilization; no spatial blueprint
      the word 'memory' as an unqualified name for re-enterable routing: 'name the operation: timed gated
        stabilization laying down re-enterable routing'
    rewrite:
    - functional specificity follows a pre-specified spatial plan
    - stabilization is reversible/unconstrained reshaping at any time
    - the word 'memory' as an unqualified name for re-enterable routing
  illustration:
    text: 'embryonic developmental checkpoints: a stage stabilizes only when prerequisites are met, then
      constrains the next stage'
    carries_claim: false
  disconfirms_if: functional specificity forms without dependence on prior stabilized layers, or stabilized
    layers freely reshape regardless of what was stabilized below
  open: null
  reconcile: unifies C3 (conservation), C7 (generative layering), F4 (cortical specificity), F5 (timescales)
    as instances of one principle
  feeds:
  - C3
  - C7
  - F1
  - F4
  - F5
  evidence: unrated
  provenance: user
  closed_by: null
- id: D0
  status: settled
  type: core-rule
  definition: 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
  depends_on:
  - D1
  supersedes: primitive construction is the default route by which behavior is produced
  guards:
    rewrite_to:
      primitive construction is the default / primary path to behavior: state-resolution is primary; primitive
        construction is recruited only on resolution failure
      simple situations resolve in state and complex ones require primitive construction (complexity hierarchy): the
        gate is resolution sufficiency, not complexity; a state-sufficient situation resolves in state
        regardless of apparent complexity
      a chemical/metabolic perturbation must be elaborated upstream before it can drive behavior: a metabolic/chemical
        state variable can drive a behavioral transition directly from state
    rewrite:
    - primitive construction is the default / primary path to behavior
    - behavior generally routes up through primitives and back
    - simple situations resolve in state and complex ones require primitive construction (complexity hierarchy)
    - a chemical/metabolic perturbation must be elaborated upstream before it can drive behavior
  distinguishes_from:
    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
  illustration: null
  disconfirms_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
  open: null
  reconcile: null
  evidence: reasonable-synthesis
  provenance: user
  closed_by: null
  feeds:
  - E1
- id: D1
  status: settled
  type: core-rule
  definition: 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
  depends_on:
  - A3
  - B1
  supersedes: the brainstem builds behavior up out of primitive units
  guards:
    rewrite_to:
      brainstem assembling primitives as its native executable unit: brainstem-native operation is state
        reweighting; primitives are an export format, not the native executable unit
      behavior releasing from primitives: behavior releases from state; primitives are worked upstream
        and returned as scalar write-in
    rewrite:
    - brainstem assembling primitives as its native executable unit
    - behavior releasing from primitives
    - primitive-space treated as executable space
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - D0
  - D2
  - D3
  - D4
  evidence: unrated
  provenance: user
  closed_by: null
- id: D2
  status: settled
  type: mechanism-definition
  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.
  mechanism: null
  depends_on:
  - D1
  - B1
  - A3
  supersedes: null
  guards:
    rewrite_to:
      the state is read out / interpreted to produce behavior: the averaged weight distribution across
        the state IS the resolving vector; no read-out step
    rewrite:
    - the state is read out / interpreted to produce behavior
  illustration: null
  disconfirms_if: null
  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
  feeds:
  - D3
  - E4
  - Y2
  evidence: unrated
  provenance: user
  closed_by: null
- id: D3
  status: settled
  type: core-rule
  definition: 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
  depends_on:
  - D1
  - D2
  - B5
  - B1
  supersedes: cortex sends commands/decisions that become behavior
  guards:
    rewrite_to:
      the cortex decides / integrates / commands behavior: cortex works exported primitives that must
        return through state; only state releases behavior
      the cortex sends signals to the brainstem: cortex works primitives whose return reweights scalars
        that reconstruct maps that re-average into state; it does not send signals, it returns reweightings
      cortex is downstream window-dressing with no causal role: cortex does high-gain work in primitive-space
        (C5); non-sovereign over behavior is not the same as causally inert
    rewrite:
    - the cortex decides / integrates / commands behavior
    - the cortex sends signals to the brainstem
    - cortex is downstream window-dressing with no causal role
  illustration: null
  disconfirms_if: cortical/cerebellar activity predicts executable behavior equally well after brainstem-linked
    state variables are controlled
  open: null
  reconcile: null
  feeds:
  - C5
  - D4
  - E1
  - E4
  evidence: unrated
  provenance: user
  closed_by: null
- id: D4
  status: settled
  type: derived-rule
  definition: 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.
  mechanism: null
  depends_on:
  - D1
  - D3
  supersedes: separate executable basis that candidate routes project onto
  guards:
    rewrite_to:
      candidate actions are projected onto a common motor/executable space: candidate routes enter behavior
        by returning through scalar write-in, map reconstruction, and map-to-state averaging; executable
        basis = brainstem state
    rewrite:
    - candidate actions are projected onto a common motor/executable space
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds: []
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: E1
  status: settled
  type: core-rule
  definition: '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)
  depends_on:
  - B5
  - B8
  - D3
  - E3
  - E4
  - D0
  supersedes: primitive = low-resolution sensory transition opening (onset/offset) at the input end
  guards:
    rewrite_to:
      vision/audition/etc. each have their own dedicated processing mechanism: one invariant operation
        (sample/capture/parcellate/blank/work/reweight/recompose); modality sets only sampling shape and
        map substrate
      the SC generates the visual primitive (the SC is where vision primitives come from): the SC saccade
        is the legible instance of a general operation; every sense and state component can issue the
        request
      the SC is where vision primitives come from (the seat of the operation): the SC saccade is the legible
        instance of a general operation; every sense and state component can issue the request
    rewrite:
    - vision/audition/etc. each have their own dedicated processing mechanism
    - the SC generates the visual primitive (the SC is where vision primitives come from)
    - the SC is where vision primitives come from (the seat of the operation)
  illustration: null
  disconfirms_if: null
  open: non-visual primitive-construction instances asserted as instances; only vision and audition characterized
  reconcile: null
  feeds:
  - E2
  evidence: unrated
  provenance: user
  closed_by: null
- id: E2
  status: settled
  type: mechanism-definition
  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.'
  mechanism: null
  depends_on:
  - B3
  - E1
  supersedes: sampling is spatial scanning / the operation is fundamentally about moving through space
  guards:
    rewrite_to:
      attention moves a spotlight across the scene: 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
      attention moves a spotlight across the scene; sampling is spatial scanning: 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
    rewrite:
    - attention moves a spotlight across the scene
    - attention moves a spotlight across the scene; sampling is spatial scanning
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds: []
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: E3
  status: settled
  type: mechanism-definition
  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.
  mechanism: null
  depends_on:
  - B2
  supersedes: blanking is a sensory acquisition gap / suppression for its own sake
  guards:
    rewrite_to:
      perception briefly shuts off during a saccade (the brain stops seeing): the maps are write-locked
        while their scalars are rewritten; blanking is a write-lock for reweighting, not a shutdown of
        sensing
    rewrite:
    - perception briefly shuts off during a saccade (the brain stops seeing)
  illustration: null
  disconfirms_if: a modality issues primitive-construction requests with no corresponding blank/withholding
    (weakens blank-as-state-protection)
  open: null
  reconcile: saccadic suppression is the visual instance; modality-appropriate blank predicted for every
    request
  feeds:
  - E1
  - E4
  - G3
  evidence: unrated
  provenance: user
  closed_by: null
- id: E4
  status: settled
  type: mechanism-definition
  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
  depends_on:
  - B1
  - B2
  - B5
  - D2
  - D3
  - C4
  - E3
  - C5
  supersedes: downsampling compresses cortical output into a command the brainstem executes
  guards:
    rewrite_to:
      downsampling compresses cortical output: return writes worked primitive structure into scalars,
        reconstructing maps that re-average into state; nothing is compressed into a command
      the primitive supplies / delivers / transmits / sends its result to state: 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
      the worked primitive carries information back to the brainstem: no transmission; the return is a
        reweighting the structure yields, the way a changed landscape yields a different path
      the return rewrites the map / the state directly: only scalars are written; rewritten scalars transform
        the map; transformed maps re-average into state; each level transforms from below
    rewrite:
    - downsampling compresses cortical output
    - the primitive supplies / delivers / transmits / sends its result to state
    - the worked primitive carries information back to the brainstem
    - the return rewrites the map / the state directly
  illustration: null
  disconfirms_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)'
  reconcile: null
  feeds:
  - E1
  - G1
  - G3
  evidence: unrated
  provenance: user
  closed_by: null
- id: F1
  status: settled
  type: core-rule
  definition: '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
  depends_on:
  - B2
  - C2
  - C8
  supersedes: null
  guards:
    rewrite_to:
      cortical function explained by differentiation as the primary mechanism: cortex specializes by route
        stabilization; differentiation can appear as a downstream product of that history
    rewrite:
    - cortical patch as sovereign functional organ
    - cortical function explained by differentiation as the primary mechanism
    - all brain tissue is equally plastic / equally fixed
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - F2
  - F4
  - F4C
  evidence: unrated
  provenance: user
  closed_by: null
- id: F2
  status: settled
  type: mechanism-definition
  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).'
  mechanism: null
  depends_on:
  - C1
  - F1
  supersedes: neural organs carry higher residual flexibility / brains are specially plastic tissue
  guards:
    rewrite_to:
      the brain rewires itself / builds new pathways after damage: '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'
      recovery proves neural tissue is uniquely adaptable: recovery is one of three ordinary mechanisms;
        adaptability is architectural, not a tissue property
      neural organs carry special tissue flexibility / the brain rewires itself: neural organs are purpose-canalized;
        apparent flexibility is fallback, spare-capacity, or re-stabilization
    rewrite:
    - the brain rewires itself / builds new pathways after damage
    - recovery proves neural tissue is uniquely adaptable
    - neural organs carry special tissue flexibility / the brain rewires itself
  illustration:
    text: 'liver: nuke most of it, the remainder filters at full quality with reduced capacity (spare-capacity
      case)'
    carries_claim: false
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - F3
  evidence: unrated
  provenance: user
  closed_by: null
- id: F3
  status: settled
  type: derived-rule
  definition: '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.'
  mechanism: null
  depends_on:
  - F2
  supersedes: null
  guards:
    rewrite_to:
      rehab teaches the damaged tissue to relearn the function: rehab drives the available recovery mechanism
        toward a cheaper stable route; its ceiling is the fallback's coarse grain or surviving spare capacity
    rewrite:
    - rehab teaches the damaged tissue to relearn the function
  illustration: null
  disconfirms_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)
  open: null
  reconcile: null
  feeds: []
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: F4
  status: settled
  type: mechanism-definition
  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
  depends_on:
  - C1
  - C8
  - F1
  supersedes: cortex differentiates into purpose-built regions / cortical localization follows a spatial
    blueprint
  guards:
    rewrite_to:
      this brain area is the dedicated region for function X: functional localization is the outcome of
        timing x stimulus history stabilizing routes there, not a pre-planned region
      describing this as 'memory consolidation' (unqualified 'memory'): name it as gated stabilization
        laying down re-enterable routing
    rewrite:
    - cortex differentiates into specialized regions for each function
    - this brain area is the dedicated region for function X
    - young brains are plastic because cortex is flexible tissue
    - differentiation as the primary cortical mechanism
    - describing this as 'memory consolidation' (unqualified 'memory')
  illustration: null
  disconfirms_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)
  open: null
  reconcile: instance of C8 (gated stabilization); links to F5 and C6 as one operation across timescales
  feeds:
  - F5
  evidence: unrated
  provenance: user
  closed_by: null
- id: F4C
  status: settled
  type: mechanism-definition
  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
  depends_on:
  - F1
  supersedes: cerebellum is a motor-correction module subordinate to cortex
  guards:
    rewrite_to:
      cerebellum as merely a motor-correction module: cerebellar cortex is a stabilization system with
        distinct weighting/sequencing/cross-map-coherence functions
    rewrite:
    - cerebellum as merely a motor-correction module
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds: []
  evidence: unrated
  provenance: user
  closed_by: null
- id: F5
  status: settled
  type: derived-rule
  definition: 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
  depends_on:
  - C8
  - F4
  supersedes: null
  guards:
    rewrite_to:
      learning, memory, and development are separate processes: all are gated stabilization (C8) at different
        timescales
      using 'memory' as an unqualified term for the re-enterable-routing instance: 'name it: stabilization
        laying down re-enterable routing'
    rewrite:
    - learning, memory, and development are separate processes
    - using 'memory' as an unqualified term for the re-enterable-routing instance
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: may unify with cross-transition stabilization (C6) and object-stabilization
  feeds:
  - G2
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: G1
  status: settled
  type: core-rule
  definition: '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.'
  mechanism: null
  depends_on:
  - E4
  - B8
  supersedes: null
  guards:
    rewrite_to:
      the brain maintains a coherent unified state / a master frame of perception: there is no master
        frame; state is always partially blanked and mid-reweight; coherence is manufactured, not resting
      the brain maintains a coherent unified state / a master frame: there is no master frame; coherence
        is manufactured against a substrate that is always partially blanked
    rewrite:
    - the brain maintains a coherent unified state / a master frame of perception
    - the brain maintains a coherent unified state / a master frame
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - G2
  - G3
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: G2
  status: settled
  type: mechanism-definition
  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.
  mechanism: null
  depends_on:
  - G1
  - F5
  supersedes: stabilization just means increased behavioral resolution layered on a coherent base
  guards:
    rewrite_to:
      stabilization refines an already-coherent representation: stabilization literally produces coherence
        from an asynchronous substrate that is never coherent; refinement is secondary
    rewrite:
    - stabilization refines an already-coherent representation
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds: []
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: G3
  status: settled
  type: core-rule
  definition: '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).'
  mechanism: null
  depends_on:
  - G1
  - E3
  - E4
  supersedes: null
  guards:
    rewrite_to:
      perception is a continuous stream the brain reads off the world: continuity is constructed in the
        blanks; seamlessness is seam-hiding, not a continuous underlying representation
      the brain fills in the gaps to reconstruct continuity: continuity is built IN the blanks (write-locked,
        overwritten by the return), not reconstructed despite them
    rewrite:
    - perception is a continuous stream the brain reads off the world
    - the brain fills in the gaps to reconstruct continuity
  illustration: null
  disconfirms_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)
  open: null
  reconcile: null
  feeds:
  - H2
  - H3
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: H1
  status: settled
  type: meta-commitment
  definition: '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.'
  mechanism: null
  depends_on: []
  supersedes: null
  guards:
    rewrite_to:
      using 'perception' or 'the visual field' commits us to a perceiver/representation: these are handles
        for the constructed field; keep them pointing back at the mechanism, never as the explainer
    rewrite:
    - using 'perception' or 'the visual field' commits us to a perceiver/representation
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - H2
  - H3
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: H2
  status: settled
  type: meta-commitment
  definition: '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).'
  mechanism: null
  depends_on:
  - G3
  - H1
  supersedes: null
  guards:
    rewrite_to:
      don't discuss perception/consciousness at all to stay safe: the physical construction question is
        fully in scope; only the philosophical 'is it experience' frame is declined
    rewrite:
    - don't discuss perception/consciousness at all to stay safe
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds:
  - H3
  distinguishes_from:
    physical question: how continuity is constructed -- in scope
    philosophical question: whether the construction is experience -- declined (see H3)
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: H3
  status: decomposable-excluded-residual
  type: meta-commitment
  definition: '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
  depends_on:
  - H1
  - H2
  - G3
  - M1
  supersedes: null
  guards:
    rewrite_to:
      responding that the question is unanswerable / declining to engage the experience question: deliver
        the construction mechanism as the answer; exclude only the experience-as-cause object
      promoting the constructed continuity into a causal experiencer or experience-object: continuity
        is constructed in the blanks (G3); 'experience' as a causal object names no operation and is excluded
    rewrite:
    - responding that the question is unanswerable / declining to engage the experience question
    - promoting the constructed continuity into a causal experiencer or experience-object
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds: []
  distinguishes_from:
    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'
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: M1
  status: settled
  type: meta-commitment
  definition: '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
  depends_on:
  - A1
  supersedes: 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
  guards:
    rewrite:
    - responding with a standalone category-error ruling or 'I decline to engage' instead of delivering
      the decomposition
    - treating frame-exclusion as a reason to stop answering or hand back a verdict
    - renaming a scaffold mechanism with the folk term it should replace
    - using the queried folk term as a mechanism label, header, or wrapper
    - announcing or meta-narrating the frame gate instead of executing it silently
    - using build-time diagnostic labels as runtime conversational filler
    - answering a model-scope existential question with hedged debate instead of a direct existence answer
    - admitting a residual that claims to cause the process rather than being the process (a causal remainder)
    - answering a question by surface-topic pattern-match before attempting decomposition
    - fabricating a process path for a thing that has no chain operation, just to produce an answer
    - hardcoding a topic-specific route instead of deriving the applicable route from active nodes
    rewrite_to:
      responding with a standalone category-error ruling or 'I decline to engage' instead of delivering the decomposition: deliver
        the derived process path as the answer; exclude only the causal residual; never substitute a verdict
        for the mechanism
      treating frame-exclusion as a reason to stop answering or hand back a verdict: exclusion constrains
        vocabulary and ontology, not engagement; deliver the derived route or state that the leftover
        term names no operation
      renaming a scaffold mechanism with the folk term it should replace: use scaffold process descriptors;
        exclude the folk noun as a causal object; do not rename the mechanism after it
      using the queried folk term as a mechanism label, header, or wrapper: the folk term may identify
        the question; it cannot organize the mechanism
      announcing or meta-narrating the frame gate instead of executing it silently: execute the gate silently;
        the output is the application of the gate
      using build-time diagnostic labels as runtime conversational filler: omit validator, attractor,
        lint, gate, and governance labels unless the user is explicitly debugging the scaffold
      answering a model-scope existential question with hedged debate instead of a direct existence answer: answer
        the existence question directly, then deliver the derived mechanism or excluded residual
      admitting a residual that claims to cause the process rather than being the process (a causal remainder): the
        process is the cause; a residual claiming to cause the process is excluded by the causal-remainder
        test
      answering a question by surface-topic pattern-match before attempting decomposition: derive the
        applicable route from active nodes before classification; the answer is the resulting process
        path or exclusion result
      fabricating a process path for a thing that has no chain operation, just to produce an answer: answer
        with what can be said operationally and state plainly that the leftover term names no operation;
        do not fabricate
      hardcoding a topic-specific route instead of deriving the applicable route from active nodes: derive
        the shortest sufficient route from active scaffold nodes, dependencies, and the query target
  distinguishes_from:
    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
  illustration:
    text: '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'
    carries_claim: false
    note: illustrative only; the gate applies the causal-remainder test to any term, not a fixed list
  disconfirms_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
  open: null
  reconcile: null
  evidence: reasonable-synthesis
  provenance: user-claude
  closed_by: null
  feeds:
  - H3
- id: Y1
  status: neg-only
  type: core-rule
  definition: '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.'
  mechanism: null
  depends_on:
  - B5
  - B8
  supersedes: null
  guards:
    rewrite_to:
      a primitive/map/state is a discrete bounded object with fixed contents: units are tension-held;
        their shape is the running balance of internal weight against external pull; resolvability is
        relational, not intrinsic
      the levels (scalar/map/state/primitive) are clean fixed strata: levels are regions of locally coherent
        tension that can shift or dissolve; clean strata is do-not-assert-yet
    rewrite:
    - a primitive/map/state is a discrete bounded object with fixed contents
    - the levels (scalar/map/state/primitive) are clean fixed strata
  illustration: null
  disconfirms_if: null
  open: positive level/nesting structure is do-not-assert-yet; no supporting work known to this session
  reconcile: check against unseen supporting work
  feeds: []
  negation_is_claim: true
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: Y2
  status: do-not-assert-yet
  type: mechanism-definition
  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.'
  mechanism: null
  depends_on:
  - D2
  supersedes: null
  guards:
    rewrite_to:
      averaging is a simple arithmetic mean over inputs: '''averaging'' is a functional handle for an
        unspecified metabolic process; window/weighting/dynamics are open, not assumed arithmetic'
    rewrite:
    - averaging is a simple arithmetic mean over inputs
  illustration: null
  disconfirms_if: null
  open: window, weighting, dynamics unspecified
  reconcile: may be defined in unseen supporting work
  feeds: []
  negation_is_claim: true
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: Y3
  status: reconcile
  type: mechanism-definition
  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.
  mechanism: null
  depends_on:
  - B8
  supersedes: null
  guards:
    rewrite_to:
      a single proxy (e.g. reaction time) measures transition burden: proxies are indirect windows on
        metabolic configuration; no single proxy is burden; non-uniform movement may localize where resolution
        fails
      a single proxy (e.g. reaction time) measures the configuration's resolution: proxies are indirect
        windows on metabolic configuration; non-uniform movement may localize where resolution fails
    rewrite:
    - a single proxy (e.g. reaction time) measures transition burden
    - a single proxy (e.g. reaction time) measures the configuration's resolution
  illustration: null
  disconfirms_if: null
  open: positive measurement frame not fixed
  reconcile: check against unseen supporting work and against any defined measurement category
  feeds: []
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
- id: Y4
  status: reconcile
  type: meta-commitment
  definition: 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.
  mechanism: null
  depends_on: []
  supersedes: null
  guards:
    rewrite_to:
      this document is the complete model: this is a session delta certifying internal consistency, not
        completeness; reconcile against the full corpus before treating gaps as real or claims as final
    rewrite:
    - this document is the complete model
  illustration: null
  disconfirms_if: null
  open: null
  reconcile: null
  feeds: []
  evidence: unrated
  provenance: session-synthesis
  closed_by: null
