gbrain: sync converted org-mode brain files

projects/passepartout/DESIGN_DECISIONS.org

@@ -1,4 +1,4 @@
-# Passepartout Design Decisions
+#+TITLE: Passepartout Design Decisions
 
 This document captures the rationale behind key architectural choices. It is not a specification — it is a thinking medium for future architects and contributors who need to understand why the system is built this way, not just how.
 

projects/passepartout/architecture/ann-neuromorphic-symbolic-comparison.org

@@ -0,0 +1,40 @@
+:PROPERTIES:
+:CREATED:  [2026-06-01 Mon]
+:ID:       a7b8c9d0-1e2f-3a4b-5c6d-7e8f90abcdef
+:END:
+#+title: ANN vs Neuromorphic vs Symbolic — When Each Mathematics Fits
+#+filetags: :passepartout:architecture:neurosymbolic:math:
+
+**ANN vs Neuromorphic vs Symbolic**
+
+**Core insight**
+
+The gap between ANNs and biology is not substrate (binary vs analog). Both are continuous mathematics running on discrete hardware. The real differences are architectural:
+
+1. Memory-binding: ANNs store weights separately from compute (von Neumann bottleneck). Biology co-locates weight and signal at the synapse.
+2. Local vs global learning: ANNs need a global error signal backpropagated through every layer. Biology uses purely local plasticity (STDP) — each synapse adjusts based on its own pre/post partners.
+3. Time: Biology is asynchronous, continuous, with rich temporal dynamics. ANNs are synchronous — everything computed in lockstep. Recurrence is an awkward addition.
+4. One substrate, many functions: A biological synapse does memory, signal propagation, temporal integration, and plasticity in one structure. ANNs separate these across different passes and optimizers.
+
+**When each mathematics is appropriate**
+
+| Mathematics | Naturally good at | Awkward at |
++------------+-------------------+------------+
+| ANN / gradient descent | Smooth function approximation, interpolation, pattern completion from dense data | Symbolic reasoning, exact constraints, sparse data, multi-step verification |
+| Neuromorphic / spiking dynamics | Temporal pattern recognition, event-driven control, low-power always-on sensing | Complex multi-step planning, precise arithmetic, storing large lookup tables |
+| Symbolic / deduction | Exact reasoning, proof, constraint satisfaction, verifiable behavior | Learning from raw data, generalization, handling noisy inputs |
+
+**How Passepartout uses all three**
+
+- LLM (ANN on GPU) handles the noisy real world — language, vision, imperfect input
+- Screamer (symbolic constraint search on CPU) handles combinatorial reasoning — "find valid configuration"
+- ACL2 (deductive proof) handles the verifiable kernel — "prove this decision follows from rules"
+- P150 (RISC-V parallel accelerator, in-between arch) handles ambient awareness, parallel dispatch, anomaly detection
+
+Each mathematics where it belongs. The failure mode of both pure ANN and pure symbolic approaches is forcing one mathematics to do what the other is better at.
+
+**The neuromorphic opportunity**
+
+A neuromorphic chip (Loihi-level) would add unsupervised temporal learning — learning daily rhythms, behavioral patterns, and detecting deviations without training, labels, or LLM involvement. This is the difference between responding to commands and anticipating needs.
+
+But the P150 gets 80% there with programmable cores controlled directly, without waiting for neuromorphic hardware to mature.

projects/passepartout/architecture/biomimicry-in-passepartout.org

@@ -0,0 +1,137 @@
+:PROPERTIES:
+:CREATED:  [2026-06-01 Mon]
+:ID:       f6a7b8c9-0d1e-2f3a-4b5c-6d7e8f90abcd
+:END:
+#+title: Biomimicry in Passepartout — Architecture and Roadmap
+#+filetags: :passepartout:architecture:neurosymbolic:biomimicry:p150:
+
+**Biomimicry in Passepartout**
+
+**What already exists (real biomimicry, not metaphor)**
+
+| Feature | Biological analog | Implementation |
+|---------+-------------------+----------------|
+| Three-layer reasoning | Reptilian → limbic → neocortex | LLM (intuition) → Screamer (constrained search) → ACL2 (verified reasoning) |
+| Verdict-overrides-LLM | Somatic markers override conscious deliberation | Gate outputs overrule LLM proposals, not the other way |
+| Dream cycle | Sleep consolidation | gbrain dream cycle: replay and re-index daily experience offline |
+| Delegate subagents | Cognitive recruitment | delegate_task — spawns specialized subprocesses for subproblems |
+| Memory as two systems | Declarative vs procedural | Fact store (explicit) vs skills (implicit/procedural) |
+
+**What is missing — and how to fill it**
+
+***1. Peripheral nervous system (P150 slot)***
+
+Biology does not poll. The brain does not run ~while true: check if_finger_hot()~. Dedicated low-power circuits (nociceptors, proprioceptors) monitor continuously and only signal the CNS on deviation.
+
+Passepartout polls everything — cron output, filesystem, user messages. A P150 running 72 parallel event-driven monitors would dedicate:
+
+- One core to "is the user typing on Signal?"
+- One to "did the weekly model discovery fail?"
+- One to "is ZFS ARC thrashing?"
+- One to "is the test build running longer than usual?"
+
+Each sleeps until something meaningful happens. Only then does it signal the symbolic system. Zero LLM involvement for routine monitoring.
+
+This changes Passepartout from a system that responds to commands to a system that notices things on its own. The difference between a calculator and a research assistant.
+
+***2. Associative activation (spreading activation)***
+
+In the brain, activating one concept (ACL2) automatically pre-activates related concepts (SP3, proof, Lisp, verification). No clean-slate search.
+
+Passepartout has no equivalent. Every query is a fresh search. A biomimetic fact store would:
+
+- Pre-fetch linked pages when one is loaded
+- Prime caches based on current conversation context
+- Use the graph structure to predict what will be needed next
+
+The brain does not pre-fetch — it primes — so the next thought is faster. Passepartout could prime its caches so facts most likely needed next are already loaded.
+
+***3. Error-driven learning with local credit assignment***
+
+The brain does not backpropagate. Errors trigger local corrections at the synapse that made the mistake.
+
+Passepartout's Gate decisions today are either right or wrong, but nothing locally adjusts. A biomimetic Gate would:
+
+- Track which rules fired during a wrong decision
+- Locally adjust confidence scores of only those rules
+- No global retrain — just the specific rule that fired
+
+This is STDP at the symbolic level.
+
+***4. Sleep consolidation (dream cycle upgrade)***
+
+The gbrain dream cycle already replays daily experience. It could go further during offline cycles:
+
+- Replay the day's decisions, identify which Gate checks were slow
+- Regenerate ACL2 proof caches for rules that changed
+- Prune skills that never fired (neurogenesis pruning counterpart)
+- Re-index fact store based on actual usage, not static linking
+- Propose new skills for repeated multi-step tasks discovered during the day
+
+***5. Graceful degradation***
+
+Biology has redundant fallbacks at every level. Passepartout has single points of failure.
+
+A biomimetic approach:
+
+- Gate offline? Fall back to cached rule set
+- LLM offline? Fall back to smaller local model
+- ACL2 busy? Use previously verified boundaries
+- Never go silent — get slower and dumber until primary returns
+- P150 cores can run degraded modes independently
+
+**The P150's role**
+
+The P150 (72 Tensix cores, 32GB GDDR6, QSFP-DD 800G interconnect) fills a slot nothing else in the build covers:
+
+- Not for fast inference (2x 3090s are faster and cheaper for that)
+- Not for baremetal Lisp Machine (FPGA is the right tool for tagged memory + hardware GC)
+- For ambient awareness, parallel verification dispatch, fact store indexing, anomaly detection
+
+The P150 is the system's peripheral nervous system — always-on monitoring behind the scenes.
+
+**Revised architecture**
+
+| Component | Role |
+|-----------+------|
+| 2x RTX 3090 | Fast LLM inference |
+| EPYC (main cores) | ACL2, Screamer, PDS, Gate orchestration |
+| P150 | Always-on temporal awareness, parallel constraint search, fact store indexing, anomaly detection |
+| FPGA (future) | Stage 3 Lisp Machine (tagged memory, hardware GC) |
+
+**Temporal awareness: explicit vs ambient**
+
+Passepartout today reasons about time (reading logs, comparing timestamps, understanding "before X happened" from context) but has no sense of time.
+
+Explicit (current): Reads a cron schedule, orders log events, answers "when did X happen."
+
+Ambient (with P150): Notices the build took 3x longer than usual without being asked, flags that message frequency dropped at 3AM, anticipates the user will want the weekly report before they ask.
+
+The P150 makes ambient temporal processing economically viable because 72 independent cores running statistical monitors consume near-zero power. Running the same monitors on the EPYC competes with ACL2 and the PDS. Running them on the 3090s wastes bandwidth on non-matrix work.
+
+**Relationship to the Pinker/Marcus critique**
+
+Pinker and Marcus argue that neural networks (spiking or otherwise) lack compositional syntax and systematic reasoning. A network that learns "A fires before B" through STDP has learned a temporal correlation, not a rule. It cannot distinguish causation, correlation, and coincidence.
+
+This critique does not apply to Passepartout because Passepartout is not a pure neural network. It is a hybrid system:
+
+| Problem | Mathematics | Where it runs |
+|---------+------------+---------------|
+| Temporal intuition | Statistical pattern detection | P150 |
+| Compositional time (before/after/during) | Symbolic reasoning | Gate + Screamer on CPU |
+| Sequential patterns from data | ANN attention | GPU |
+
+The neuromorphic layer gives the system a sense of time. The symbolic layer gives it understanding of time. Both are necessary. Neither one replaces the other.
+
+**What biomimicry means here**
+
+The real gains come not from replicating brain details (spiking neurons, STDP, ion channels) but from adopting organizational principles that biology evolved:
+
+- Specialized subsystems for different time/resource regimes (PNS vs CNS)
+- Asynchronous event-driven communication instead of synchronous polling
+- Redundant fallbacks at every level
+- Local learning that does not require global retraining
+- Offline consolidation separate from online inference
+- Parallel associative retrieval rather than sequential search
+
+Passepartout already adopts some of these. The P150 and an upgraded cron/dream cycle would add the rest.

projects/passepartout/hardware/_index.org

@@ -0,0 +1,6 @@
+:PROPERTIES:
+:CREATED:  [2026-06-01 Mon]
+:ID:       d4e5f6a7-8b9c-0d1e-2f3a-4b5c6d7e8f90
+:END:
+#+title: Hardware
+#+filetags: :index:hardware:

projects/passepartout/hardware/server-build-bom.org

@@ -0,0 +1,38 @@
+:PROPERTIES:
+:CREATED:  [2026-06-01 Mon]
+:ID:       e5f6a7b8-9c0d-1e2f-3a4b-5c6d7e8f90ab
+:END:
+#+title: Passepartout Server — Build BOM and Phased Plan
+#+filetags: :passepartout:hardware:homelab:build:
+
+**Passepartout Server — Build BOM & Phased Plan**
+
+- Chassis: CX4712 ($439 Sliger)
+- CPU: EPYC 7002 Rome SP3 (~$100-200 used)
+- Board: Supermicro H11SSL-i (~$150 used)
+- Cooler: Asetek 836SA-M1 AIO ($250 Sliger add-on)
+- GPUs: 2x used RTX 3090 (~$750 ea)
+- RAM: 256GB via 8x 32GB Crucial DDR4-3200 ECC ($210/ea)
+- PSU: Corsair RM1000e 1000W ($148)
+- Fans: 3x Noctua NF-A12x25 PWM ($75 Sliger)
+- Rails: Sliger 20" rack slides ($109)
+- HBA: LSI 9300-8i IT mode ($75)
+- Boot NVMe: 1TB (~$60)
+- ZFS special vdev: 2x 512GB NVMe mirrored (~$50/ea)
+- HDDs: 6x 20-24TB recertified (~$250-350/ea)
+
+Total estimate: ~$5,900
+
+**Phased buying plan (~$1K per phase)**
+
+1. EPYC CPU + SP3 motherboard (~$250) — test boot
+2. CX4712 + PSU + fans + AIO + rails + NVMe boot + HBA (~$1,156)
+3. 128GB RAM (4x32GB Crucial) + 1st RTX 3090 (~$1,590)
+4. 4x 20-22TB HDDs recertified (~$1,200)
+5. 128GB more RAM + 2nd RTX 3090 + 2x 512GB NVMe (~$1,690)
+
+**Stages**
+
+- Now: All-in-one (compute + storage + inference)
+- Future: Proxmox secondary node when 3 better nodes appear
+- Final: Backup server (just HDDs + ZFS)