Store reproduction and web application source

source/.gitignore

@@ -0,0 +1,10 @@
+data/
+runs/
+web/model/
+node_modules/
+dist/
+.venv/
+__pycache__/
+*.pyc
+.env
+*.log

source/AGENTS.md

@@ -0,0 +1,9 @@
+# Fly XOX
+
+- Source authoring only on this computer. Do not install dependencies, download datasets/checkpoints, run training, or create local build/cache output.
+- Run installation, data preparation, tests, training, and export on the authorized Vast.ai instance.
+- Pilot spending ceiling: USD 5, including compute, storage, and transfer. Check costs and stop compute when done. Preserve remote artifacts until storage/export is resolved.
+- Preserve the retained MaleCNS neuron graph. Disclose retention filters, engineered input/output mappings, rate dynamics, and trained internal parameters. Do not call this a living brain or biological learning.
+- Browser moves must come from the exported graph executing in WebGPU. No minimax, lookup table, or server policy fallback at inference.
+- Record training, validation, and symmetry-grouped held-out test results separately. Report failures and compare against the untrained model.
+- Keep credentials out of code, artifacts, version control, and logs.

source/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fly XOX contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

source/PROGRESS.md

@@ -0,0 +1,115 @@
+# Fly XOX — resume here
+
+Last updated: 2026-09-14 07:45 UTC. Training and WGSL validation completed; private artifact upload and cleanup pending.
+
+## Latest result (supersedes older pending notes below)
+
+- Training completed: 1,200 updates, ~42.8 seconds reported training-loop duration. Best validation checkpoint at step 1,100.
+- Training optimal-move accuracy: 98.17% on 3,560 positions.
+- Validation optimal-move accuracy: 90.04% on 492 positions.
+- **Held-out test: 91.67% on 468 positions, versus 62.82% for the untrained same model and 56.91% uniform-random expected optimal-move rate.**
+- Fixed input/output interfaces unchanged. Internal parameters changed: 153,090 gains, 165,455 biases, 165,455 leaks.
+- 500,100 trainable internal parameters; ~1.01 GB peak GPU allocation. One seed only, no biological/superiority claim.
+- Tool installation completed. `train/evaluate_games.py`, `train/export.py`, `train/verify_webgpu.py` have been launched sequentially remotely; inspect their process/output before relaunching.
+- Source `train/verify_webgpu.py` and all web files uploaded. Local source remains dependency/data free.
+- Complete-game evaluation (500 games each): vs random, fly first **474 W / 26 D / 0 L**, fly second **425 W / 70 D / 5 L**; vs minimax, fly first **0 W / 500 D / 0 L**, fly second **0 W / 480 D / 20 L**. Game trajectories can include training positions; this is separate from the held-out-position score.
+- Export completed: **224,749,428 bytes** (~225 MB), retaining every edge, 16 MiB chunks.
+- **Exact browser WGSL passed wgpu-native verification** on all 12 golden boards; all moves match PyTorch, max absolute logit difference **0.00000500679**.
+- Native validation adapter is **software Vulkan / llvmpipe (CPU)**, not the RTX GPU. Median ~762 ms is a software-backend timing, NOT expected browser GPU latency. Browser/device performance remains unmeasured.
+- Remote apt installed old Node 12, which rejected valid optional chaining during syntax checks. Obtain a current Node binary on the REMOTE host only, then rerun JS checks. Do not rewrite modern browser code merely to accommodate old Node.
+
+## User's requirements and authorization
+
+- Build a tic-tac-toe (XOX) player using the actual MaleCNS fly connectome, inspired by the September 2026 fly-brain projects.
+- Train internal model parameters, rather than only putting a normal game AI behind a fly graphic.
+- Train on Vast.ai. **USD 5 total pilot ceiling**, including compute, storage, transfer.
+- Author source locally in `/Users/n4ze3m/personal/fun/fly-xox`.
+- **Do not install dependencies, download datasets/checkpoints, or run training locally.** All dependencies, model files, preparation, tests, training, and exports belong on the remote machine.
+- Finished browser application should execute the model via WebGPU.
+- Keep model and checkpoints in a **private Hugging Face repository**. User explicitly chose private. Do not make the repository or artifacts public.
+- User asked for this progress file because the session may end soon.
+
+## Active infrastructure — CHECK FIRST ON RESUME
+
+- Vast.ai instance: **50989186**, label `fly-xox-pilot-5usd`.
+- GPU: RTX 3090, 24 GiB VRAM; about 43 GB available host RAM; 30 GB rented disk.
+- Offer 30239913, quoted total **$0.1388888889/hour** including disk. Disk component **$0.0055555556/hour** continues when stopped.
+- Container: `pytorch/pytorch:2.8.0-cuda12.8-cudnn9-runtime`.
+- Direct SSH: `ssh -p 44245 root@77.48.24.240`.
+- Proxy SSH: `ssh -p 29186 root@ssh8.vast.ai`.
+- Existing local `~/.ssh/id_ed25519` is registered. Do not print private key material.
+- Remote project: `/workspace/fly-xox`.
+- Port 8080 is mapped to host port 44232; do NOT use public unauthenticated serving for private model assets.
+- Vast CLI is already installed at `/Users/n4ze3m/.local/bin/vastai` and authenticated. Use `--raw`, and filter account output to avoid printing identity/credentials.
+- Credit before creating this instance: **$9.1766269051**. No other instances were present. Budget floor for this pilot: $4.1766269051, with a safety margin above that.
+- A local detached fallback command was started near creation: `sleep 10800; vastai stop instance 50989186 --raw`. It is only a fallback (local sleep/offline can delay it), not a durable cloud budget cap. Stop compute yourself when done. Do not assume stopping deletes disk charges.
+- Do not destroy the instance until remote artifacts have been verified on Hugging Face; then destroy it to stop all charges.
+
+## Hugging Face
+
+- Existing local `hf` CLI and authenticated account `n4ze3m`; `hf auth whoami` successfully refreshed existing OAuth credentials.
+- Existing token file: `~/.cache/huggingface/token`; **never print it or store it in project files**.
+- Created private model repository: **https://huggingface.co/n4ze3m/fly-xox-malecns**.
+- At this checkpoint it has no uploaded model artifacts yet.
+- `remote/publish_hf.py` uploads directly from Vast, requires a token on stdin only, and refuses if the model repository isn't private.
+- If uploading via SSH, pipe the existing refreshed token to the remote process stdin. Never include it in command arguments, logs, Git, or persistent remote files. No dataset/checkpoint bytes should pass through local files.
+
+## Completed so far
+
+- Read Vast.ai skill and relevant Sites guidance. User's no-local-install/download rule overrides normal local scaffolding/install steps. Native HTML/JS/WGSL source has no browser package dependencies.
+- Created source under `fly-xox/`, with task constraints also in `AGENTS.md`.
+- Remote dependency installation succeeded: PyTorch 2.8.0+cu128, numpy 2.2.6, scipy 1.15.3, pandas 2.2.3, pyarrow 20.0.0, wgpu 0.24.0.
+- Downloaded three official MaleCNS v1.0 Feather files **on Vast only**. Checked upstream MD5 when supplied and recorded SHA256 source lock.
+- Prepared graph: **166,700 neurons, 25,582,938 directed neuron-pair edges, 124,177,617 retained synaptic contacts**, 17,937 annotated sensory neurons.
+- Retention: assigned nonempty superclass, excluding explicit Glia; all released connections between retained IDs; no extra edge threshold.
+- Remote `python train/test_core.py`: **3 tests passed** (exact game solver, 4,520 nonterminal reachable positions with symmetry-grouped split/legality, sparse forward and state gradients vs dense reference).
+- Initial pilot hit a float64 readout vs float32 state mismatch; fixed by casting the normalized readout to float32 in `train/model.py`, uploaded fix, and restarted.
+- Remote installation of Vulkan loader/Mesa/nodejs and huggingface_hub was launched separately for WebGPU validation and upload. Check its log for completion.
+
+## Training design
+
+- Full retained sparse graph is present for every forward pass. No normal-policy/minimax fallback in the browser.
+- Engineered **symbolic board input**: 27 one-hot channels (empty/self/opponent for each square), fixed random projection into annotated sensory neurons. **This is not pixel vision.**
+- Signed, incoming-normalized contact weights. GABA/glutamate are assigned negative signs, others/unknown positive; this is a disclosed crude assumption, not receptor physiology.
+- Four recurrent softsign rate updates, reset state each move. No biological time claim.
+- Learn three internal parameters per neuron: incoming gain, offset, leak (**500,100 trainable parameters**). Graph topology and external input/output adapters stay fixed.
+- Gain is 0.1 + 5.9*sigmoid(raw); leak is 0.05 + 0.9*sigmoid(raw).
+- Readout: fixed signed random projection of 2,048 non-sensory neurons selected by response variance on training boards only; nine move scores.
+- Exact minimax teacher is training/evaluation only. Loss maximizes total probability of all tied optimal legal moves.
+- Train/validation/test split groups player-relative rotations/reflections by SHA256, roughly 80/10/10.
+- Training invocation currently launched: `python -u train/pilot.py --updates 1200 --seconds 2400`, default batch 32 and LR 0.025.
+- Select best checkpoint on validation only; held-out test evaluated after selection. Compare against untrained same model and uniform random optimal-move rate.
+
+## Remote logs / outputs
+
+- Setup: `/workspace/fly-xox-bootstrap.log` (completed data import).
+- Training: `/workspace/fly-xox-training.log`.
+- Vulkan/node/HF tool setup: `/workspace/fly-xox-tools.log`.
+- Graph: `/workspace/fly-xox/data/graph/`.
+- Boards: `/workspace/fly-xox/data/boards.npz`.
+- Checkpoints/results: `/workspace/fly-xox/runs/pilot/` (`untrained.pt`, `best.pt`, `last.pt`, history/results when generated).
+- Exports will be `/workspace/fly-xox/web/model/`. **Do not rsync this back locally.**
+
+## Source files and next actions
+
+1. Check instance status and current training/tool logs. Ensure no duplicate training process is started.
+2. `train/pilot.py`: bounded training, validation selection, final held-out results. Do not assert successful learning until results exist.
+3. After source uploads finish, run remotely:
+   - `python train/evaluate_games.py` — 500 random/minimax games per side using cached model predictions inside evaluator only.
+   - `python train/export.py` — bakes gains into effective graph weights and encoder, writes 16 MiB binary chunks, manifest, 12 golden positions.
+   - `python train/verify_webgpu.py` — runs the app's exact WGSL through wgpu-native, compares PyTorch logits/moves, records actual adapter and timing. Not browser end-to-end testing.
+4. `web/brain.wgsl`, `web/readout.wgsl`: full sparse graph + fixed output projection. Seven storage bindings in brain shader; largest buffer ~102 MB, fits typical 128 MiB binding limit (verify actual device).
+5. `web/engine.js`: streamed chunks with SHA256 checks, WebGPU device/buffer validation, identical update loop, legal-move masking. Loads `./model/` by default. Model assets must be served with authenticated access or bundled into a private host; don't leak a HF token into client code.
+6. `web/index.html`, `style.css`, `app.js`: authored game UI, actual activity bars, legal turns, win/draw handling, model loading/error states, reset and fly-first controls. **Not yet runtime-validated.**
+7. `remote/publish_hf.py`: preserve exports, checkpoints, graph, source directly on private HF after checks pass. Verify remote contents/hashes before deleting Vast disk.
+8. Run JavaScript syntax checks remotely (node is being installed). Add focused frontend/state tests as needed. Do not install/test locally.
+9. Finish README with actual results, reproduction, limitations, and spending. Update this file with final status and instance cleanup.
+
+## Open issues / cautions
+
+- Successful learning has not yet been established. Pilot accuracy and WebGPU parity are pending.
+- Native WebGPU initially found no adapters because libvulkan was absent. NVIDIA ICD and 610.57.04 graphics libraries are present; remote apt installation of libvulkan1/mesa-vulkan-drivers should resolve. Prefer NVIDIA adapter; report if only software Vulkan is available.
+- HF is private by explicit choice. Do not silently expose model chunks on public HTTP, public Spaces, or public Sites.
+- A private static Hugging Face Space is a possible way to host the game without an embedded token or paid inference server. Official docs say Static Spaces are free and support private access. This has NOT been created or promised yet; user selected HF as artifact storage, not explicitly a Space.
+- No local node_modules, graph/model/checkpoint downloads, training runs, build outputs, or Python environments were created. Local SSH known-hosts entries and existing HF OAuth token refresh are normal connection metadata.
+- Browser play itself eventually fetches model bytes into the visitor's memory; user was informed of this distinction. Do not open the game on their computer automatically during this no-download development phase.

source/README.md

@@ -0,0 +1,79 @@
+# Fly XOX
+
+A tic-tac-toe experiment using the retained MaleCNS v1.0 fruit-fly wiring, with internal parameters trained on Vast.ai and full-graph inference written in WebGPU.
+
+**This folder contains source only. Do not install dependencies or download model data here.**
+
+See [PROGRESS.md](PROGRESS.md) for current infrastructure, the USD 5 budget, results, and resume instructions.
+
+## Pilot result
+
+One training seed; 1,200 optimizer updates on an RTX 3090. Best checkpoint selected using validation only.
+
+| Evaluation | Result |
+| --- | --- |
+| Held-out optimal moves, before training | 62.82% |
+| Held-out optimal moves, after training | 91.67% |
+| Uniform random expected optimal-move rate | 56.91% |
+| Held-out positions | 468 |
+| Validation positions | 492 |
+| Training positions | 3,560 |
+| Trainable internal parameters | 500,100 |
+| Peak allocated CUDA memory | 1.01 GB |
+
+Rotations and reflections of player-relative board states stay in the same split. The exact solver supplies labels only during training/evaluation. Browser inference has no solver or policy lookup fallback.
+
+| Opponent / fly order | Wins | Draws | Losses |
+| --- | ---: | ---: | ---: |
+| Random / first | 474 | 26 | 0 |
+| Random / second | 425 | 70 | 5 |
+| Minimax / first | 0 | 500 | 0 |
+| Minimax / second | 0 | 480 | 20 |
+
+These complete games can traverse training boards; they are not a second unseen-data test. Perfect play is not established.
+
+## What is biological, engineered, and trained
+
+- **Measured structure:** 166,700 retained neurons, 25,582,938 directed neuron-pair connections, 124,177,617 retained synaptic contacts. All released edges between retained neurons remain.
+- **Engineered input:** 27 symbolic board channels, fixed random mapping into 17,937 sensory neurons. No optical vision claim.
+- **Engineered dynamics:** signed, incoming-normalized contact weights; four recurrent softsign rate updates; zero initial state each move. Approximate transmitter signs, without receptor-specific dynamics or biological timing.
+- **Trained inside the graph:** per-neuron incoming gains, offsets, and leak rates. Effective connection strengths change while topology stays fixed.
+- **Fixed output:** random projection from 2,048 downstream neurons selected using training response variance. Neither input nor output adapter is trained.
+
+This is not a recreated living fly or a validated model of biological learning. The pilot does not show that fly wiring outperforms a conventional network or shuffled wiring.
+
+## Remote reproduction
+
+Use a CUDA-enabled remote container with Python 3.11 and PyTorch 2.8.0. From `/workspace/fly-xox`:
+
+```sh
+bash remote/bootstrap.sh
+python train/test_core.py
+python -u train/pilot.py --updates 1200 --seconds 2400
+python train/evaluate_games.py
+python train/export.py
+XDG_RUNTIME_DIR=/tmp python train/verify_webgpu.py
+```
+
+Vulkan loader/driver support is needed for the WGSL check. The pilot used wgpu 0.24.0 with software Vulkan because the NVIDIA Vulkan adapter was not exposed. The exact WGSL matched PyTorch on 12 positions (maximum logit error ~5e-6, identical selected moves). This is **not browser end-to-end verification or a browser GPU speed measurement**.
+
+## Web application
+
+`web/` is a dependency-free HTML/CSS/JavaScript app with WGSL compute shaders. Serve the directory over authenticated HTTPS (or localhost) with the remote export in `web/model/`.
+
+- Browser requests a compatible WebGPU adapter, checks its buffer limits, downloads SHA256-checked chunks, and uploads them to GPU memory.
+- Each move executes the complete retained graph. Legal-move masking and game rules are ordinary application code.
+- Activity bars are actual sampled model rate states; captions are scripted jokes.
+- The float32 export is ~225 MB. Browser/device memory requirements and GPU speed must be measured; mobile compatibility is not promised.
+- Model load happens only after pressing **Wake the fly**. Do not automatically open/load the model on the development computer under the user's no-download constraint.
+- Keep the pilot private. Never embed a Hugging Face access token into browser code.
+
+## Storage and attribution
+
+Private artifact destination: https://huggingface.co/n4ze3m/fly-xox-malecns
+
+Remote uploader reads an existing authorized token from stdin and uploads directly from Vast. It verifies private visibility and required paths. Do not delete the rented disk before verifying the saved artifacts.
+
+MaleCNS data: HHMI Janelia/FlyEM, University of Cambridge, MRC Laboratory of Molecular Biology, Google Research, and collaborators. [Dataset and licensing](https://male-cns.janelia.org/), CC BY 4.0. Source URLs, retention policies, and SHA256 hashes are recorded in the exported manifest. This implementation was informed by the published descriptions of [Fly OCR](https://github.com/jerryjliu/fly_ocr), [DOOMFLY](https://github.com/nftechie/doomfly), and [Flyhard](https://github.com/MarkUnthank/flyhard); it does not reproduce their dynamics or claim their validation.
+
+Original project source is MIT licensed; dataset rights remain separate.

source/remote/bootstrap.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd /workspace/fly-xox
+test -n "${CONTAINER_ID:-}" || test -f /.dockerenv || { echo 'Run on the remote training container only'; exit 1; }
+python -m pip install --no-cache-dir -r requirements-remote.txt
+python -c 'import torch; assert torch.cuda.is_available(); print(torch.cuda.get_device_name(0))'
+python -u train/prepare.py

source/remote/publish_hf.py

@@ -0,0 +1,44 @@
+"""Upload from Vast directly to a PRIVATE Hugging Face repo. Token via stdin only."""
+import argparse
+import hashlib
+import json
+import sys
+from pathlib import Path
+from huggingface_hub import HfApi,CommitOperationAdd
+
+ROOT=Path(__file__).resolve().parents[1]
+
+def main():
+    p=argparse.ArgumentParser();p.add_argument('--repo',default='n4ze3m/fly-xox-malecns');args=p.parse_args()
+    token=sys.stdin.readline().strip()
+    if not token:raise SystemExit('Pass a token on stdin; never in source or command arguments')
+    api=HfApi(token=token)
+    info=api.repo_info(args.repo,repo_type='model')
+    if not info.private:raise SystemExit('Refusing upload: repository must be private')
+    api.upload_folder(repo_id=args.repo,folder_path=ROOT/'web/model',path_in_repo='webgpu',commit_message='Add measured-graph WebGPU export and validation')
+    api.upload_folder(repo_id=args.repo,folder_path=ROOT/'runs/pilot',path_in_repo='training',ignore_patterns=['*.partial'],commit_message='Preserve pilot checkpoints and results')
+    api.upload_folder(repo_id=args.repo,folder_path=ROOT/'data/graph',path_in_repo='graph',commit_message='Preserve retained graph and fixed board adapter')
+    api.upload_folder(repo_id=args.repo,folder_path=ROOT,path_in_repo='source',ignore_patterns=['data/**','runs/**','web/model/**','__pycache__/**','*.pyc','.git/**','*.log'],commit_message='Store reproduction and web application source')
+    api.upload_file(repo_id=args.repo,path_or_fileobj=ROOT/'web/model/README.md',path_in_repo='README.md')
+    files=api.list_repo_files(args.repo)
+    required=['webgpu/manifest.json','webgpu/webgpu-verification.json','training/best.pt','training/results.json','graph/connectome.npz','source/web/engine.js']
+    if not all(f in files for f in required):raise RuntimeError('Remote file verification failed')
+    metadata={f.rfilename:f for f in api.repo_info(args.repo,files_metadata=True).siblings}
+    verified=0
+    for prefix,folder in [('webgpu',ROOT/'web/model'),('training',ROOT/'runs/pilot'),('graph',ROOT/'data/graph')]:
+        for path in folder.rglob('*'):
+            if not path.is_file() or path.suffix=='.partial':continue
+            name=prefix+'/'+path.relative_to(folder).as_posix(); remote=metadata[name]
+            if remote.size!=path.stat().st_size:raise RuntimeError('Uploaded size mismatch: '+name)
+            if remote.lfs:
+                digest=hashlib.sha256()
+                with path.open('rb') as f:
+                    while block:=f.read(8*1024*1024):digest.update(block)
+                if digest.hexdigest()!=remote.lfs.sha256:raise RuntimeError('Uploaded SHA256 mismatch: '+name)
+            else:
+                blob=path.read_bytes(); expected=hashlib.sha1(b'blob '+str(len(blob)).encode()+b'\0'+blob).hexdigest()
+                if expected!=remote.blob_id:raise RuntimeError('Uploaded Git blob mismatch: '+name)
+            verified+=1
+    print(json.dumps({'repo':args.repo,'private':api.repo_info(args.repo).private,'files':len(files),'required_files_verified':True,'artifact_hashes_verified':verified}),flush=True)
+
+if __name__=='__main__':main()

source/remote/test_web.mjs

@@ -0,0 +1,32 @@
+// Run with Node >=22 on Vast only. Tests actual app handlers with a controlled
+// inference boundary; WGSL math is independently tested by verify_webgpu.py.
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import vm from 'node:vm';
+import {fileURLToPath} from 'node:url';
+
+class Element {
+  constructor(){this.children=[];this.handlers={};this.attributes={};this.disabled=false;this.classes=new Set();this.width=640;this.height=280;this.textContent='';this.innerHTML='';this.classList={add:(x)=>this.classes.add(x),remove:(x)=>this.classes.delete(x),toggle:(x,on)=>on?this.classes.add(x):this.classes.delete(x)};}
+  append(x){this.children.push(x);}setAttribute(k,v){this.attributes[k]=v;}addEventListener(k,fn){this.handlers[k]=fn;}
+  getContext(){return {clearRect(){},beginPath(){},moveTo(){},lineTo(){},stroke(){},fillRect(){}};}
+  click(){return this.handlers.click?.();}
+}
+const elements=new Map();const get=id=>{if(!elements.has(id))elements.set(id,new Element());return elements.get(id);};
+let moves=[4,6];let calls=[];let fail=false;
+class FakeEngine {
+  async load(_,progress){progress(1);return {neurons:166700,edges:25582938,total_bytes:224749428,results:{test:{optimal_move_rate:.9167},untrained_test:{optimal_move_rate:.6282}}};}
+  async predict(board,turn){calls.push({board:board.slice(),turn});if(fail)throw new Error('GPU disconnected');return {move:moves.shift(),logits:Array(9).fill(0),activity:new Float32Array(128),milliseconds:10};}
+  destroy(){}
+}
+const context=vm.createContext({document:{getElementById:get,createElement:()=>new Element()},console,Float32Array,Array,Math,Number,Error});
+const dependency=new vm.SyntheticModule(['FlyEngine'],function(){this.setExport('FlyEngine',FakeEngine);},{context});
+const source=await fs.readFile(fileURLToPath(new URL('../web/app.js',import.meta.url)),'utf8');
+const app=new vm.SourceTextModule(source,{context});await app.link(()=>dependency);await app.evaluate();
+const cells=get('board').children;assert.equal(cells.length,9);assert(cells.every(c=>c.disabled));
+await get('load').click();assert(!cells[0].disabled);assert.equal(get('status').textContent,'Your move. You are X.');
+await cells[0].click();assert.equal(cells[0].textContent,'X');assert.equal(cells[4].textContent,'O');assert.equal(calls.length,1);assert.equal(calls[0].turn,-1);
+await cells[0].click();assert.equal(calls.length,1,'occupied square must not invoke the model');
+await cells[1].click();await cells[2].click();assert(get('status').textContent.startsWith('You win'));assert(cells.every(c=>c.disabled));assert.equal(calls.length,2,'terminal game must not invoke the model');
+get('reset').click();assert(cells.every(c=>c.textContent===''));assert(cells.every(c=>!c.disabled));
+fail=true;await cells[0].click();assert.equal(get('status').textContent,'GPU disconnected');assert(cells.every(c=>c.disabled));assert.equal(get('load').hidden,false);
+console.log('PASS: load, legal alternating turns, occupied-cell rejection, terminal win, reset, GPU failure recovery');

source/requirements-remote.txt

@@ -0,0 +1,6 @@
+# Install on Vast.ai only. PyTorch is supplied by the pinned container image.
+numpy==2.2.6
+scipy==1.15.3
+pandas==2.2.3
+pyarrow==20.0.0
+wgpu==0.24.0

source/train/evaluate_games.py

@@ -0,0 +1,38 @@
+"""Game evaluation using cached model predictions, only within this evaluator."""
+import argparse
+import json
+from pathlib import Path
+import numpy as np
+import torch
+from model import FlyBrain
+from pilot import evaluate
+from game import targets,winner
+
+ROOT=Path(__file__).resolve().parents[1]
+
+def main():
+    p=argparse.ArgumentParser();p.add_argument('--name',default='pilot');args=p.parse_args()
+    torch.set_num_threads(6); run=ROOT/'runs'/args.name
+    cp=torch.load(run/'best.pt',weights_only=False); net=FlyBrain(ROOT/'data/graph',steps=cp['steps']);net.load_state_dict(cp['model'])
+    data=dict(np.load(ROOT/'data/boards.npz')); _,scores=evaluate(net,data,np.arange(len(data['boards'])))
+    index={tuple(b):i for i,b in enumerate(data['boards'])}
+    rng=np.random.default_rng(9014); results={}
+    for opponent in ['random','minimax']:
+        for side in [1,-1]:
+            counts={'wins':0,'draws':0,'losses':0}
+            for _ in range(500):
+                board=(0,)*9;turn=1
+                while not winner(board) and not all(board):
+                    legal=np.flatnonzero(np.array(board)==0)
+                    if turn==side:
+                        logits=scores[index[board]];move=int(legal[np.argmax(logits[legal])])
+                    elif opponent=='random': move=int(rng.choice(legal))
+                    else: move=int(rng.choice(np.flatnonzero(targets(board,turn)[0])))
+                    board=board[:move]+(turn,)+board[move+1:];turn=-turn
+                w=winner(board);counts['draws' if w==0 else 'wins' if w==side else 'losses']+=1
+            results[f'{opponent}_fly_{"first" if side==1 else "second"}']=counts
+    result=json.loads((run/'results.json').read_text());result['games']=results
+    result['games_note']='500 games per opponent and side, deterministic learned policy, seeded random opponent/tie choices. Complete games can include training boards; held-out position accuracy is reported separately.'
+    (run/'results.json').write_text(json.dumps(result,indent=2));print(json.dumps(results),flush=True)
+
+if __name__=='__main__':main()

source/train/export.py

@@ -0,0 +1,61 @@
+"""Bake trained gains into measured edges, export chunked WebGPU buffers remotely."""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import numpy as np
+import scipy.sparse as sp
+import torch
+from model import FlyBrain
+
+ROOT=Path(__file__).resolve().parents[1]
+
+def write_array(root,name,array):
+    data=np.ascontiguousarray(array).tobytes(); parts=[]; chunk=16*1024*1024
+    for start in range(0,len(data),chunk):
+        block=data[start:start+chunk]; filename=f'{name}.{start//chunk:03}.bin'
+        (root/filename).write_bytes(block)
+        parts.append({'file':filename,'bytes':len(block),'sha256':hashlib.sha256(block).hexdigest()})
+    return {'bytes':len(data),'dtype':str(array.dtype),'shape':list(array.shape),'parts':parts}
+
+def main():
+    p=argparse.ArgumentParser(); p.add_argument('--name',default='pilot'); args=p.parse_args()
+    run=ROOT/'runs'/args.name; dest=ROOT/'web/model'; dest.mkdir(parents=True,exist_ok=True)
+    cp=torch.load(run/'best.pt',map_location='cpu',weights_only=False)
+    net=FlyBrain(ROOT/'data/graph',steps=cp['steps']); net.load_state_dict(cp['model']); net.eval()
+    state=cp['model']; gain=(.1+5.9*torch.sigmoid(state['gain'])).numpy()
+    leak=(.05+.9*torch.sigmoid(state['leak'])).numpy(); bias=state['bias'].numpy()
+    matrix=sp.load_npz(ROOT/'data/graph/connectome.npz')
+    row_ids=np.repeat(np.arange(net.n,dtype=np.int32),np.diff(matrix.indptr))
+    # Internal learned incoming gains become effective weights, preserving every edge.
+    matrix.data*=gain[row_ids]
+    arrays={
+        'rowptr':matrix.indptr.astype('<u4'),'column':matrix.indices.astype('<u4'),'weight':matrix.data.astype('<f4'),
+        'encoder':(state['encoder'].numpy()*gain[:,None]).astype('<f4'),
+        'parameters':np.stack((bias,leak),axis=1).astype('<f4'),
+        'neurons':state['readout_ids'].numpy().astype('<u4'),'projection':state['readout'].numpy().astype('<f4'),
+    }
+    files={name:write_array(dest,name,a) for name,a in arrays.items()}
+    boards=dict(np.load(ROOT/'data/boards.npz')); ids=np.flatnonzero(boards['split']==2)[:12]
+    with torch.no_grad():
+        logits=net(torch.tensor(boards['x'][ids],device='cuda')).cpu().numpy()
+    golden={'boards':boards['boards'][ids].tolist(),'turns':boards['turns'][ids].tolist(),'inputs':boards['x'][ids].tolist(),'logits':logits.tolist()}
+    (dest/'golden.json').write_text(json.dumps(golden))
+    source=json.loads((ROOT/'data/graph/manifest.json').read_text())
+    results=json.loads((run/'results.json').read_text())
+    manifest={'format':'fly-xox-webgpu-v1','neurons':net.n,'edges':int(matrix.nnz),'steps':net.steps,
+        'readout_count':len(state['readout_ids']),'activity_samples':128,'arrays':files,
+        'total_bytes':sum(f['bytes'] for f in files.values()),'source':source,'results':results,
+        'dynamics':'Four recurrent softsign rate updates by default; reset each move; no biological timing claim.',
+        'learned':'Internal per-neuron incoming gain, bias, and leak. Fixed input and output adapters.',
+        'webgpu_verified':False}
+    (dest/'manifest.json').write_text(json.dumps(manifest,indent=2))
+    (dest/'README.md').write_text('# Fly XOX — experimental MaleCNS game model\n\n'
+        'Full retained MaleCNS graph with trained internal rate-model parameters for tic-tac-toe. '
+        'Symbolic board input; engineered fixed input/output mappings. Not a living fly, validated biological dynamics, or evidence of connectome superiority.\n\n'
+        'Source data: HHMI Janelia/FlyEM, Cambridge, MRC LMB, Google Research and collaborators. '
+        'https://male-cns.janelia.org/ — CC BY 4.0. Original code: MIT.\n\n'
+        'See manifest.json for exact retention, source hashes, assumptions, held-out scores, and WebGPU verification.\n')
+    print(json.dumps({'export_bytes':manifest['total_bytes'],'neurons':net.n,'edges':int(matrix.nnz),'destination':str(dest)}),flush=True)
+
+if __name__=='__main__': main()

source/train/game.py

@@ -0,0 +1,60 @@
+"""Exact teacher and symmetry-grouped dataset. Never shipped as the game policy."""
+from functools import lru_cache
+import hashlib
+import numpy as np
+
+LINES = ((0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6))
+
+def winner(b):
+    for a,c,d in LINES:
+        if b[a] and b[a] == b[c] == b[d]: return b[a]
+    return 0
+
+@lru_cache(None)
+def value(b, turn):
+    w = winner(b)
+    if w: return w * turn
+    if all(b): return 0
+    return max(-value(b[:i]+(turn,)+b[i+1:], -turn) for i in range(9) if not b[i])
+
+def targets(b, turn):
+    scores = np.full(9, -2, dtype=np.float32)
+    for i in range(9):
+        if not b[i]: scores[i] = -value(b[:i]+(turn,)+b[i+1:], -turn)
+    return (scores == scores.max()).astype(np.float32), scores
+
+def encode(b, turn):
+    # Each cell: empty, current player's mark, opponent's mark.
+    b = np.asarray(b) * turn
+    return np.stack((b == 0, b == 1, b == -1), axis=1).astype(np.float32).reshape(27)
+
+def canonical(b, turn):
+    a = (np.asarray(b).reshape(3,3) * turn).astype(int)
+    return min(tuple(x.reshape(-1)) for k in range(4) for x in (np.rot90(a,k), np.fliplr(np.rot90(a,k))))
+
+def dataset():
+    seen = set(); records = []
+    def visit(b, turn):
+        if b in seen: return
+        seen.add(b)
+        if winner(b) or all(b): return
+        key = canonical(b, turn)
+        bucket = int(hashlib.sha256(bytes(v+1 for v in key)).hexdigest()[:8],16) % 10
+        split = 0 if bucket < 8 else 1 if bucket == 8 else 2
+        y, q = targets(b, turn)
+        records.append((b,turn,encode(b,turn),y,q,split,key))
+        for i in range(9):
+            if not b[i]: visit(b[:i]+(turn,)+b[i+1:],-turn)
+    visit((0,)*9,1)
+    return {
+        'boards':np.asarray([r[0] for r in records],np.int8),
+        'turns':np.asarray([r[1] for r in records],np.int8),
+        'x':np.asarray([r[2] for r in records],np.float32),
+        'optimal':np.asarray([r[3] for r in records],np.float32),
+        'q':np.asarray([r[4] for r in records],np.float32),
+        'split':np.asarray([r[5] for r in records],np.int8),
+        'canonical':np.asarray([r[6] for r in records],np.int8),
+    }
+
+if __name__ == '__main__':
+    d=dataset(); print({s:int((d['split']==i).sum()) for i,s in enumerate(['train','validation','test'])})

source/train/model.py

@@ -0,0 +1,66 @@
+"""Trainable rate dynamics over the retained graph; no trainable external head."""
+from pathlib import Path
+import numpy as np
+import scipy.sparse as sp
+import torch
+from torch import nn
+
+class FixedSparse(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, x, matrix, transpose):
+        ctx.transpose=transpose
+        return torch.sparse.mm(matrix,x)
+    @staticmethod
+    def backward(ctx, grad):
+        # Only dense state gradients; never materialize an N x N derivative.
+        return torch.sparse.mm(ctx.transpose,grad.contiguous()),None,None
+
+def csr(m,device):
+    return torch.sparse_csr_tensor(
+        torch.as_tensor(m.indptr.astype(np.int32),device=device),
+        torch.as_tensor(m.indices.astype(np.int32),device=device),
+        torch.as_tensor(m.data,device=device),size=m.shape,device=device)
+
+class FlyBrain(nn.Module):
+    def __init__(self,graph,device='cuda',steps=4,readout_ids=None):
+        super().__init__(); graph=Path(graph)
+        matrix=sp.load_npz(graph/'connectome.npz').astype(np.float32)
+        self.n=matrix.shape[0]; self.steps=steps
+        self.register_buffer('graph',csr(matrix,device),persistent=False)
+        self.register_buffer('transpose',csr(matrix.T.tocsr(),device),persistent=False)
+        self.register_buffer('encoder',torch.tensor(np.load(graph/'encoder.npy'),device=device))
+        # Incoming connection gains, cell offsets, and leaks are internal parameters.
+        self.gain=nn.Parameter(torch.full((self.n,),-0.2,device=device))
+        self.bias=nn.Parameter(torch.zeros(self.n,device=device))
+        self.leak=nn.Parameter(torch.zeros(self.n,device=device))
+        if readout_ids is None:
+            readout_ids=np.flatnonzero(~np.load(graph/'sensory.npy'))[:2048]
+        self.register_buffer('readout_ids',torch.tensor(readout_ids,dtype=torch.long,device=device))
+        rng=np.random.default_rng(903)
+        readout=(rng.choice([-1.,1.],size=(9,len(readout_ids)))/np.sqrt(len(readout_ids))).astype(np.float32)
+        self.register_buffer('readout',torch.tensor(readout,device=device))
+
+    def states(self,x):
+        stimulus=self.encoder@x.T
+        state=torch.zeros_like(stimulus)
+        gain=(0.1+5.9*torch.sigmoid(self.gain))[:,None]
+        leak=(0.05+0.9*torch.sigmoid(self.leak))[:,None]
+        bias=self.bias[:,None]
+        for _ in range(self.steps):
+            message=FixedSparse.apply(state,self.graph,self.transpose)
+            drive=gain*(message+stimulus)+bias
+            candidate=drive/(1+drive.abs()) # softsign, identical in WGSL
+            state=(1-leak)*state+leak*candidate
+        return state
+
+    def forward(self,x):
+        return (8.0*(self.readout@self.states(x)[self.readout_ids])).T
+
+    @torch.no_grad()
+    def select_readout(self,x,sensory,count=2048):
+        # Selection uses training boards only. Output weights remain fixed.
+        s=self.states(x)
+        variance=s.var(dim=1); variance[torch.tensor(sensory,device=s.device)]=-1
+        chosen=variance.topk(min(count,int((~sensory).sum()))).indices
+        self.readout_ids=chosen
+        return chosen.cpu().numpy()

source/train/pilot.py

@@ -0,0 +1,94 @@
+"""Bounded train/validate/test cycle. Execute only on the rented GPU."""
+import argparse
+import json
+import time
+from pathlib import Path
+import numpy as np
+import torch
+from model import FlyBrain
+
+ROOT=Path(__file__).resolve().parents[1]
+
+@torch.no_grad()
+def evaluate(net,data,indices,batch=32):
+    logits=[]
+    for part in np.array_split(indices,max(1,int(np.ceil(len(indices)/batch)))):
+        logits.append(net(torch.tensor(data['x'][part],device='cuda')).cpu().numpy())
+    logits=np.concatenate(logits)
+    legal=data['boards'][indices]==0
+    moves=np.where(legal,logits,-1e9).argmax(1)
+    optimal=data['optimal'][indices,np.arange(9)[moves]]
+    return {'positions':len(indices),'optimal_move_rate':float(optimal.mean()),'illegal_moves':0},logits
+
+def checkpoint(path,net,optimizer,step,score):
+    tmp=path.with_suffix('.partial')
+    torch.save({'model':net.state_dict(),'optimizer':optimizer.state_dict(),'step':step,'score':score,
+                'steps':net.steps,'torch_rng':torch.get_rng_state(),'cuda_rng':torch.cuda.get_rng_state()},tmp)
+    tmp.replace(path)
+
+def main():
+    p=argparse.ArgumentParser(); p.add_argument('--steps',type=int,default=4)
+    p.add_argument('--updates',type=int,default=1200); p.add_argument('--seconds',type=int,default=2400)
+    p.add_argument('--batch',type=int,default=32); p.add_argument('--lr',type=float,default=.025)
+    p.add_argument('--resume',action='store_true'); p.add_argument('--name',default='pilot')
+    args=p.parse_args(); torch.set_num_threads(6); torch.manual_seed(140926)
+    torch.backends.cuda.matmul.allow_tf32=False
+    if not torch.cuda.is_available(): raise SystemExit('CUDA training is required; do not train locally')
+    run=ROOT/'runs'/args.name; run.mkdir(parents=True,exist_ok=True)
+    d=dict(np.load(ROOT/'data/boards.npz')); train=np.flatnonzero(d['split']==0); val=np.flatnonzero(d['split']==1); test=np.flatnonzero(d['split']==2)
+    net=FlyBrain(ROOT/'data/graph',steps=args.steps)
+    net.select_readout(torch.tensor(d['x'][train[:64]],device='cuda'),np.load(ROOT/'data/graph/sensory.npy'))
+    optimizer=torch.optim.Adam(net.parameters(),lr=args.lr)
+    start_step=0; best=-1.; began=time.monotonic(); rng=np.random.default_rng(140926)
+    initial={k:v.detach().clone() for k,v in net.state_dict().items()}
+    if args.resume:
+        cp=torch.load(run/'last.pt',weights_only=False); net.load_state_dict(cp['model']); optimizer.load_state_dict(cp['optimizer']); start_step=cp['step']; best=cp['score']
+    else:
+        before,_=evaluate(net,d,val)
+        checkpoint(run/'untrained.pt',net,optimizer,0,before['optimal_move_rate'])
+        (run/'before.json').write_text(json.dumps(before,indent=2))
+        print('BEFORE',json.dumps(before),flush=True)
+    history=[]
+    x=torch.tensor(d['x'],device='cuda'); y=torch.tensor(d['optimal'],device='cuda'); legal=torch.tensor(d['boards']==0,device='cuda')
+    first_update=time.monotonic()
+    for step in range(start_step+1,args.updates+1):
+        if time.monotonic()-began>args.seconds: print('Training time limit reached',flush=True); break
+        idx=torch.tensor(rng.choice(train,args.batch),device='cuda')
+        optimizer.zero_grad(set_to_none=True)
+        logits=net(x[idx]).masked_fill(~legal[idx],-1e9)
+        # Probability mass on ALL optimal actions; never penalize a tied best move.
+        loss=(torch.logsumexp(logits,1)-torch.logsumexp(logits.masked_fill(y[idx]==0,-1e9),1)).mean()
+        loss.backward()
+        if not torch.isfinite(loss): raise ValueError('Nonfinite training loss')
+        grad_norm=torch.nn.utils.clip_grad_norm_(net.parameters(),5.)
+        if not torch.isfinite(grad_norm): raise ValueError('Nonfinite gradient')
+        optimizer.step()
+        if step==1:
+            torch.cuda.synchronize()
+            print('BENCHMARK',json.dumps({'first_update_seconds':time.monotonic()-first_update,'peak_gpu_gb':torch.cuda.max_memory_allocated()/1e9,
+                   'gain_nonzero_gradients':int((net.gain.grad!=0).sum()),'bias_nonzero_gradients':int((net.bias.grad!=0).sum()),'leak_nonzero_gradients':int((net.leak.grad!=0).sum())}),flush=True)
+        if step%50==0 or step==args.updates:
+            scores,_=evaluate(net,d,val)
+            record={'step':step,'loss':float(loss),'seconds':round(time.monotonic()-began,2),**scores}
+            history.append(record); print(json.dumps(record),flush=True)
+            if scores['optimal_move_rate']>best:
+                best=scores['optimal_move_rate']; checkpoint(run/'best.pt',net,optimizer,step,best)
+            checkpoint(run/'last.pt',net,optimizer,step,best)
+            (run/'history.json').write_text(json.dumps(history,indent=2))
+    if not (run/'best.pt').exists(): checkpoint(run/'best.pt',net,optimizer,step,best)
+    cp=torch.load(run/'best.pt',weights_only=False); net.load_state_dict(cp['model'])
+    result={'validation_selected_step':cp['step'],'elapsed_seconds':time.monotonic()-began,'training':evaluate(net,d,train)[0],
+            'validation':evaluate(net,d,val)[0],'test':evaluate(net,d,test)[0],
+            'trainable_parameters':sum(p.numel() for p in net.parameters()),
+            'changed_internal_parameters':{k:int((net.state_dict()[k]!=initial[k]).sum()) for k in ['gain','bias','leak']},
+            'fixed_interfaces_unchanged':all(torch.equal(net.state_dict()[k],initial[k]) for k in ['encoder','readout','readout_ids']),
+            'one_training_seed':True,'split':'D4 symmetry groups of player-relative boards, SHA256 bucket; 80/10/10 approximate',
+            'device':torch.cuda.get_device_name(0),'peak_gpu_gb':torch.cuda.max_memory_allocated()/1e9}
+    result['uniform_random_optimal_rate']=float((d['optimal'][test].sum(1)/(d['boards'][test]==0).sum(1)).mean())
+    # Compare the same held-out boards to the untrained network after selection ends.
+    net.load_state_dict(torch.load(run/'untrained.pt',weights_only=False)['model'])
+    result['untrained_test']=evaluate(net,d,test)[0]
+    net.load_state_dict(cp['model'])
+    (run/'results.json').write_text(json.dumps(result,indent=2)); print('RESULT',json.dumps(result),flush=True)
+
+if __name__=='__main__': main()

source/train/prepare.py

@@ -0,0 +1,103 @@
+"""Download and prepare MaleCNS on the remote machine only."""
+from pathlib import Path
+import base64
+import hashlib
+import json
+import os
+import urllib.request
+import numpy as np
+import pandas as pd
+import pyarrow.feather as feather
+import scipy.sparse as sp
+from game import dataset
+
+ROOT = Path(__file__).resolve().parents[1]
+BASE = 'https://storage.googleapis.com/flyem-male-cns/v1.0/connectome-data/flat-connectome/'
+FILES = {
+    'annotations': 'body-annotations-male-cns-v1.0-minconf-0.5.feather',
+    'neurotransmitters': 'body-neurotransmitters-male-cns-v1.0.feather',
+    'edges': 'connectome-weights-male-cns-v1.0-minconf-0.5.feather',
+}
+
+def download(folder):
+    manifest = {}
+    for short,name in FILES.items():
+        path=folder/(short+'.feather'); url=BASE+name
+        if not path.exists():
+            print('Downloading remotely:', short, flush=True)
+            with urllib.request.urlopen(url,timeout=120) as response, path.with_suffix('.partial').open('wb') as out:
+                expected = dict(x.strip().split('=',1) for x in response.headers.get('x-goog-hash','').split(',') if '=' in x).get('md5')
+                digest=hashlib.md5()
+                while chunk:=response.read(8*1024*1024): out.write(chunk); digest.update(chunk)
+            if expected and base64.b64encode(digest.digest()).decode()!=expected:
+                raise ValueError('Upstream MD5 mismatch: '+short)
+            path.with_suffix('.partial').replace(path)
+        digest=hashlib.sha256()
+        with path.open('rb') as f:
+            while chunk:=f.read(8*1024*1024): digest.update(chunk)
+        manifest[short]={'url':url,'bytes':path.stat().st_size,'sha256':digest.hexdigest()}
+    lock=folder/'source-lock.json'
+    if lock.exists() and json.loads(lock.read_text())!=manifest: raise ValueError('Source lock changed')
+    lock.write_text(json.dumps(manifest,indent=2))
+    return manifest
+
+def main():
+    if not Path('/.dockerenv').exists() and not os.environ.get('FLY_XOX_REMOTE'):
+        raise SystemExit('Run on the Vast.ai container only.')
+    raw=ROOT/'data/raw'; raw.mkdir(parents=True,exist_ok=True)
+    manifest=download(raw)
+    out=ROOT/'data/graph'; out.mkdir(parents=True,exist_ok=True)
+    if (out/'manifest.json').exists(): print('Prepared graph already exists.'); return
+    a=feather.read_feather(raw/'annotations.feather')
+    nt=feather.read_feather(raw/'neurotransmitters.feather')
+    keep=a['superclass'].notna() & a['superclass'].astype(str).ne('') & a['status'].ne('Glia')
+    a=a.loc[keep].sort_values('bodyId').reset_index(drop=True)
+    ids=a.bodyId.to_numpy(dtype=np.int64)
+    assert len(np.unique(ids))==len(ids)
+    print('Retained neurons:',len(ids),'classes:',a.superclass.value_counts().to_dict(),flush=True)
+    e=feather.read_feather(raw/'edges.feather',columns=['body_pre','body_post','weight'])
+    raw_edges=len(e); raw_contacts=int(e.weight.sum())
+    pre=np.searchsorted(ids,e.body_pre.to_numpy()); post=np.searchsorted(ids,e.body_post.to_numpy())
+    valid=(pre<len(ids)) & (post<len(ids))
+    valid &= ids[np.minimum(pre,len(ids)-1)]==e.body_pre.to_numpy()
+    valid &= ids[np.minimum(post,len(ids)-1)]==e.body_post.to_numpy()
+    counts=e.weight.to_numpy()[valid].astype(np.float32)
+    pre=pre[valid].astype(np.int32); post=post[valid].astype(np.int32)
+    assert np.isfinite(counts).all() and (counts>0).all()
+    contact_total=int(counts.sum(dtype=np.float64)); del e,valid
+    # Incoming normalized contact counts, not measured physiological efficacy.
+    matrix=sp.csr_matrix((counts,(post,pre)),shape=(len(ids),len(ids)),dtype=np.float32)
+    matrix.sum_duplicates(); matrix.sort_indices()
+    incoming=np.asarray(matrix.sum(axis=1)).ravel()
+    rows=np.repeat(np.arange(len(ids),dtype=np.int32),np.diff(matrix.indptr))
+    matrix.data/=np.maximum(incoming[rows],1)
+    # A crude sign convention; actual receptors/modulators are not reconstructed.
+    labels=a.bodyId.map(nt.set_index('body').consensus_nt).fillna('unknown').astype(str)
+    inhibitory=labels.str.lower().isin(['gaba','glutamate'])
+    signs=np.where(inhibitory,-1.,1.).astype(np.float32)
+    matrix.data*=signs[matrix.indices]
+    np.save(out/'ids.npy',ids)
+    sp.save_npz(out/'connectome.npz',matrix)
+    sensory=a.superclass.astype(str).str.contains('sensory',case=False).to_numpy()
+    if not sensory.any(): raise ValueError('No annotated sensory neurons')
+    rng=np.random.default_rng(140926)
+    encoder=np.zeros((len(ids),27),np.float32)
+    # Symbolic board adapter, not a claim of reconstructed fly vision.
+    encoder[sensory]=rng.normal(0,0.65,size=(int(sensory.sum()),27)).astype(np.float32)
+    np.save(out/'encoder.npy',encoder)
+    np.save(out/'sensory.npy',sensory)
+    np.savez(ROOT/'data/boards.npz',**dataset())
+    report={
+        'dataset':'MaleCNS v1.0','source':'https://male-cns.janelia.org/download/',
+        'license':'CC BY 4.0','sources':manifest,'neurons':len(ids),'edges':int(matrix.nnz),
+        'retained_synaptic_contacts':contact_total,'raw_edge_rows':raw_edges,'raw_contacts':raw_contacts,
+        'sensory_neurons':int(sensory.sum()),'neurotransmitters':labels.value_counts().to_dict(),
+        'retention':'Assigned nonempty neuronal superclass; exclude explicit Glia. All released connections between retained IDs; no extra threshold.',
+        'sign_assumption':'GABA and glutamate negative; all other or unknown transmitters positive. Receptor-specific effects and neuromodulation unmodeled.',
+        'input':'Fixed random projection of 27 symbolic board channels into annotated sensory neurons. No learned input adapter; not optical vision.',
+        'biological_dynamics_validated':False,
+    }
+    (out/'manifest.json').write_text(json.dumps(report,indent=2))
+    print(json.dumps({k:report[k] for k in ['neurons','edges','retained_synaptic_contacts','sensory_neurons']}),flush=True)
+
+if __name__=='__main__': main()

source/train/test_core.py

@@ -0,0 +1,35 @@
+"""Run on Vast, with no local installation or test caches."""
+import unittest
+import numpy as np
+import torch
+from game import dataset,targets,value,winner,canonical,encode
+from model import FixedSparse,csr
+import scipy.sparse as sp
+
+class GameTests(unittest.TestCase):
+    def test_solver(self):
+        self.assertEqual(value((0,)*9,1),0)
+        b=(1,1,0,-1,-1,0,0,0,0)
+        self.assertEqual(targets(b,1)[0][2],1)
+        self.assertEqual(winner((1,1,1,0,0,0,0,0,0)),1)
+    def test_split_and_legality(self):
+        d=dataset(); groups={}
+        self.assertEqual(len(d['boards']),4520)
+        for b,t,y,s,c in zip(d['boards'],d['turns'],d['optimal'],d['split'],d['canonical']):
+            self.assertFalse(winner(b)); self.assertGreater(y.sum(),0)
+            self.assertTrue(np.all(y[b!=0]==0))
+            key=tuple(c); self.assertEqual(groups.setdefault(key,int(s)),int(s))
+            self.assertEqual(canonical(b,t),canonical(np.rot90(b.reshape(3,3)).reshape(-1),t))
+            self.assertEqual(encode(b,t).sum(),9)
+    def test_sparse_state_gradient(self):
+        device='cuda' if torch.cuda.is_available() else 'cpu'
+        a=np.array([[0,.2,-.7],[1,0,.3],[0,0,.1]],np.float32)
+        m=sp.csr_matrix(a); x=torch.randn(3,4,device=device,requires_grad=True)
+        actual=FixedSparse.apply(x,csr(m,device),csr(m.T.tocsr(),device))
+        expected=torch.tensor(a,device=device)@x
+        self.assertTrue(torch.allclose(actual,expected,atol=1e-6))
+        g1=torch.autograd.grad(actual.square().sum(),x,retain_graph=True)[0]
+        g2=torch.autograd.grad(expected.square().sum(),x)[0]
+        self.assertTrue(torch.allclose(g1,g2,atol=1e-6))
+
+if __name__=='__main__': unittest.main()

source/train/verify_webgpu.py

@@ -0,0 +1,58 @@
+"""Execute the app's exact WGSL via wgpu-native on the remote machine."""
+import hashlib
+import json
+import time
+from pathlib import Path
+import numpy as np
+import wgpu
+
+ROOT=Path(__file__).resolve().parents[1]
+
+def main():
+    folder=ROOT/'web/model'; manifest=json.loads((folder/'manifest.json').read_text())
+    adapter=wgpu.gpu.request_adapter_sync(power_preference='high-performance')
+    largest=max(a['bytes'] for a in manifest['arrays'].values())
+    d=adapter.request_device_sync(required_limits={'max-storage-buffer-binding-size':largest,'max-buffer-size':largest,'max-storage-buffers-per-shader-stage':7})
+    buffers={}
+    for name,spec in manifest['arrays'].items():
+        blocks=[]
+        for part in spec['parts']:
+            data=(folder/part['file']).read_bytes()
+            assert len(data)==part['bytes'] and hashlib.sha256(data).hexdigest()==part['sha256']
+            blocks.append(data)
+        buffers[name]=d.create_buffer_with_data(data=b''.join(blocks),usage=wgpu.BufferUsage.STORAGE)
+    states=[d.create_buffer(size=manifest['neurons']*4,usage=wgpu.BufferUsage.STORAGE|wgpu.BufferUsage.COPY_DST) for _ in range(2)]
+    config=d.create_buffer(size=128,usage=wgpu.BufferUsage.UNIFORM|wgpu.BufferUsage.COPY_DST)
+    out_config=d.create_buffer_with_data(data=np.array([manifest['readout_count'],manifest['activity_samples'],0,0],np.uint32),usage=wgpu.BufferUsage.UNIFORM)
+    result=d.create_buffer(size=(9+manifest['activity_samples'])*4,usage=wgpu.BufferUsage.STORAGE|wgpu.BufferUsage.COPY_SRC)
+    def pipeline(file):
+        module=d.create_shader_module(code=(ROOT/'web'/file).read_text())
+        return d.create_compute_pipeline(layout='auto',compute={'module':module,'entry_point':'main'})
+    brain=pipeline('brain.wgsl'); readout=pipeline('readout.wgsl')
+    def group(pipe,bs):
+        return d.create_bind_group(layout=pipe.get_bind_group_layout(0),entries=[{'binding':i,'resource':{'buffer':b}} for i,b in enumerate(bs)])
+    groups=[group(brain,[buffers['rowptr'],buffers['column'],buffers['weight'],states[i],states[1-i],buffers['parameters'],buffers['encoder'],config]) for i in range(2)]
+    out_group=group(readout,[states[manifest['steps']%2],buffers['neurons'],buffers['projection'],result,out_config])
+    golden=json.loads((folder/'golden.json').read_text()); outputs=[]; times=[]
+    for features in golden['inputs']:
+        cfg=bytearray(128); np.frombuffer(cfg,dtype=np.uint32)[0]=manifest['neurons']; np.frombuffer(cfg,dtype=np.float32,offset=16)[:27]=features
+        d.queue.write_buffer(config,0,cfg)
+        encoder=d.create_command_encoder(); encoder.clear_buffer(states[0]); encoder.clear_buffer(states[1]); start=time.perf_counter()
+        for step in range(manifest['steps']):
+            p=encoder.begin_compute_pass(); p.set_pipeline(brain); p.set_bind_group(0,groups[step%2]); p.dispatch_workgroups((manifest['neurons']+63)//64); p.end()
+        p=encoder.begin_compute_pass(); p.set_pipeline(readout); p.set_bind_group(0,out_group); p.dispatch_workgroups(max(9,manifest['activity_samples'])); p.end()
+        d.queue.submit([encoder.finish()]); outputs.append(np.frombuffer(d.queue.read_buffer(result),np.float32)[:9].copy()); times.append((time.perf_counter()-start)*1000)
+    actual=np.asarray(outputs); expected=np.asarray(golden['logits']); error=float(np.abs(actual-expected).max())
+    legal=np.array(golden['boards'])==0
+    moves=np.where(legal,actual,-1e9).argmax(1); reference=np.where(legal,expected,-1e9).argmax(1)
+    report={'adapter':dict(adapter.info),'positions':len(actual),'maximum_absolute_logit_error':error,'all_moves_match':bool(np.array_equal(moves,reference)),
+            'median_move_ms':float(np.median(times[1:])),'cold_move_ms':times[0],
+            'backend':'wgpu-native executing the browser WGSL; not a browser end-to-end test',
+            'passed':bool(error<.002 and np.array_equal(moves,reference))}
+    (folder/'webgpu-verification.json').write_text(json.dumps(report,indent=2))
+    manifest['webgpu_verified']=report['passed']; manifest['webgpu_verification']=report
+    (folder/'manifest.json').write_text(json.dumps(manifest,indent=2))
+    print(json.dumps(report),flush=True)
+    if not report['passed']: raise SystemExit('WebGPU parity failed')
+
+if __name__=='__main__': main()

source/web/app.js

@@ -0,0 +1,15 @@
+import {FlyEngine} from './engine.js';
+const $=id=>document.getElementById(id);
+const lines=[[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]];
+let board=Array(9).fill(0),engine=null,ready=false,busy=false,ended=false,flyTurn=false;
+const cells=board.map((_,i)=>{const b=document.createElement('button');b.className='cell';b.disabled=true;b.setAttribute('aria-label',`Row ${Math.floor(i/3)+1}, column ${i%3+1}, empty`);b.addEventListener('click',()=>human(i));$('board').append(b);return b;});
+const scoreCells=board.map((_,i)=>{const div=document.createElement('div');div.className='score';div.innerHTML=`<span>${i+1}</span><span>—</span>`;$('scores').append(div);return div;});
+function render(){cells.forEach((cell,i)=>{cell.textContent=board[i]===1?'X':board[i]===-1?'O':'';cell.classList.toggle('o',board[i]===-1);cell.disabled=!ready||busy||ended||flyTurn||board[i]!==0;cell.setAttribute('aria-label',`Row ${Math.floor(i/3)+1}, column ${i%3+1}, ${board[i]===1?'your X':board[i]===-1?'fly O':'empty'}`);});$('reset').disabled=!ready||busy;$('first').disabled=!ready||busy;}
+function finish(){const win=lines.find(([a,b,c])=>board[a]&&board[a]===board[b]&&board[a]===board[c]);if(win){ended=true;win.forEach(i=>cells[i].classList.add('win'));const fly=board[win[0]]===-1;$('status').textContent=fly?'The fly wins. Take a moment.':'You win. The banana is safe.';$('quip').textContent=fly?'“Put that on my résumé.”':'“I have other talents.”';}else if(board.every(Boolean)){ended=true;$('status').textContent='A draw. Both species retain their dignity.';$('quip').textContent='“Same time tomorrow?”';}render();return ended;}
+async function human(i){if(!ready||busy||ended||flyTurn||board[i])return;board[i]=1;if(!finish())await moveFly();}
+async function moveFly(){busy=true;flyTurn=true;render();$('status').textContent='The fly is thinking…';$('brain-status').textContent='COMPUTING A MOVE';try{const prediction=await engine.predict(board,-1);if(prediction.move<0||board[prediction.move])throw new Error('No legal model move.');const old=board.slice();showScores(prediction.logits,old,prediction.move);draw(prediction.activity);$('latency').textContent=`${Math.round(prediction.milliseconds)} ms`;cells.forEach(c=>c.classList.remove('chosen'));cells[prediction.move].classList.add('chosen');board[prediction.move]=-1;$('brain-status').textContent='BRAIN ONLINE';$('quip').textContent='“That square looked delicious.”';}catch(error){$('status').textContent=error.message;ready=false;$('load').hidden=false;$('load').disabled=false;$('load').textContent='Reconnect the fly';$('brain-status').textContent='CONNECTION LOST';$('dot').classList.remove('awake');}finally{busy=false;flyTurn=false;if(ready&&!finish())$('status').textContent='Your move. You are X.';render();}}
+function newGame(first=false){if(busy||!ready)return;board.fill(0);ended=false;flyTurn=false;cells.forEach(c=>c.classList.remove('win','chosen'));scoreCells.forEach((c,i)=>{c.className='score';c.innerHTML=`<span>${i+1}</span><span>—</span>`;});$('status').textContent='Your move. You are X.';render();if(first)moveFly();}
+function showScores(logits,old,pick){const legal=logits.filter((_,i)=>!old[i]);const max=Math.max(...legal);const total=legal.reduce((s,v)=>s+Math.exp(v-max),0);scoreCells.forEach((cell,i)=>{cell.className=`score ${old[i]?'used':''} ${i===pick?'picked':''}`;cell.innerHTML=`<span>${i+1}</span><span>${old[i]?'—':`${Math.round(100*Math.exp(logits[i]-max)/total)}%`}</span>`;});}
+function draw(activity=new Float32Array(128)){const canvas=$('activity'),ctx=canvas.getContext('2d');ctx.clearRect(0,0,canvas.width,canvas.height);const gap=3,width=(canvas.width-gap*127)/128;ctx.strokeStyle='#344137';ctx.beginPath();ctx.moveTo(0,140);ctx.lineTo(640,140);ctx.stroke();activity.forEach((v,i)=>{ctx.fillStyle=v>=0?'#d4fc6b':'#e8a879';const h=Math.max(2,Math.abs(v)*130);ctx.fillRect(i*(width+gap),v>=0?140-h:140,width,h);});}
+$('load').addEventListener('click',async()=>{if(busy)return;busy=true;$('load').disabled=true;$('progress').hidden=false;$('status').textContent='Loading the fly model…';try{engine?.destroy();engine=new FlyEngine();const manifest=await engine.load('./model/',p=>{$('progress').value=p;$('status').textContent=`Loading the fly model… ${Math.round(p*100)}%`;});$('neuron-count').textContent=manifest.neurons.toLocaleString();$('edge-count').textContent=`${(manifest.edges/1e6).toFixed(1)}m`;$('evaluation').textContent=`One pilot run. Held-out optimal moves: ${(manifest.results.test.optimal_move_rate*100).toFixed(1)}%; untrained: ${(manifest.results.untrained_test.optimal_move_rate*100).toFixed(1)}%. No claim of perfect play or a biological advantage.`;$('brain-status').textContent='BRAIN ONLINE';$('dot').classList.add('awake');$('load').hidden=true;$('progress').hidden=true;$('download-note').textContent=`${(manifest.total_bytes/1e6).toFixed(0)} MB loaded · moves now run on your GPU.`;ready=true;busy=false;newGame();}catch(error){engine?.destroy();engine=null;$('status').textContent=error.message;$('load').disabled=false;$('progress').hidden=true;}finally{busy=false;render();}});
+$('reset').addEventListener('click',()=>newGame());$('first').addEventListener('click',()=>newGame(true));draw();

source/web/brain.wgsl

@@ -0,0 +1,26 @@
+struct Config { n: u32, unused0: u32, unused1: u32, unused2: u32, board: array<vec4<f32>, 7> }
+@group(0) @binding(0) var<storage, read> rowptr: array<u32>;
+@group(0) @binding(1) var<storage, read> column: array<u32>;
+@group(0) @binding(2) var<storage, read> weight: array<f32>;
+@group(0) @binding(3) var<storage, read> previous: array<f32>;
+@group(0) @binding(4) var<storage, read_write> next: array<f32>;
+@group(0) @binding(5) var<storage, read> parameters: array<vec2<f32>>;
+@group(0) @binding(6) var<storage, read> encoder: array<f32>;
+@group(0) @binding(7) var<uniform> config: Config;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+  let i = id.x;
+  if (i >= config.n) { return; }
+  var drive = 0.0;
+  for (var edge = rowptr[i]; edge < rowptr[i + 1u]; edge++) {
+    drive += weight[edge] * previous[column[edge]];
+  }
+  for (var channel = 0u; channel < 27u; channel++) {
+    drive += encoder[i * 27u + channel] * config.board[channel / 4u][channel % 4u];
+  }
+  drive += parameters[i].x;
+  let candidate = drive / (1.0 + abs(drive));
+  let leak = parameters[i].y;
+  next[i] = (1.0 - leak) * previous[i] + leak * candidate;
+}

source/web/engine.js

@@ -0,0 +1,91 @@
+// The move policy executes the retained graph in WebGPU. No solver fallback.
+export class FlyEngine {
+  constructor() { this.buffers=[]; this.busy=false; this.lost=false; }
+  async load(base='./model/',progress=()=>{}) {
+    if (!globalThis.isSecureContext) throw new Error('WebGPU needs HTTPS or localhost.');
+    if (!navigator.gpu) throw new Error('This browser does not expose WebGPU. Try a browser with WebGPU enabled.');
+    this.base=new URL(base,location.href);
+    const response=await fetch(new URL('manifest.json',this.base));
+    if (!response.ok) throw new Error('Model unavailable. This private pilot needs its exported model served alongside the app.');
+    const m=await response.json(); this.manifest=m;
+    if (m.format!=='fly-xox-webgpu-v1') throw new Error('Unsupported model format');
+    const adapter=await navigator.gpu.requestAdapter({powerPreference:'high-performance'});
+    if (!adapter) throw new Error('No suitable WebGPU adapter was found.');
+    const largest=Math.max(...Object.values(m.arrays).map(a=>a.bytes),m.neurons*4);
+    if (adapter.limits.maxStorageBufferBindingSize<largest || adapter.limits.maxBufferSize<largest)
+      throw new Error('This GPU cannot fit a required model buffer. The full connectome is retained.');
+    this.device=await adapter.requestDevice({requiredLimits:{maxStorageBufferBindingSize:largest,maxBufferSize:largest,maxStorageBuffersPerShaderStage:7}});
+    this.device.lost.then(()=>{this.lost=true;});
+    const d=this.device; let loaded=0; const arrays={};
+    for (const [name,info] of Object.entries(m.arrays)) {
+      const buffer=this.buffer(info.bytes,GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST);
+      let offset=0;
+      for (const part of info.parts) {
+        const res=await fetch(new URL(part.file,this.base));
+        if (!res.ok) throw new Error(`Model download failed (${res.status}).`);
+        const bytes=await res.arrayBuffer();
+        if (bytes.byteLength!==part.bytes) throw new Error('Model file is incomplete.');
+        const digest=await crypto.subtle.digest('SHA-256',bytes);
+        const hex=Array.from(new Uint8Array(digest),b=>b.toString(16).padStart(2,'0')).join('');
+        if (hex!==part.sha256) throw new Error('Model checksum mismatch.');
+        d.queue.writeBuffer(buffer,offset,bytes); offset+=bytes.byteLength;
+        loaded+=bytes.byteLength; progress(loaded/m.total_bytes);
+      }
+      if (offset!==info.bytes) throw new Error('Model manifest size mismatch');
+      arrays[name]=buffer;
+    }
+    this.states=[0,1].map(()=>this.buffer(m.neurons*4,GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST));
+    this.config=this.buffer(128,GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST);
+    this.outConfig=this.buffer(16,GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST);
+    this.resultSize=(9+m.activity_samples)*4;
+    this.result=this.buffer(this.resultSize,GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_SRC);
+    this.readback=this.buffer(this.resultSize,GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST);
+    d.queue.writeBuffer(this.outConfig,0,new Uint32Array([m.readout_count,m.activity_samples,0,0]));
+    const sources=await Promise.all(['brain.wgsl','readout.wgsl'].map(async file=>{
+      const res=await fetch(new URL(file,import.meta.url)); if (!res.ok) throw new Error('Shader unavailable'); return res.text();
+    }));
+    this.brain=await this.pipeline(sources[0]); this.readout=await this.pipeline(sources[1]);
+    this.brainGroups=[0,1].map(i=>this.group(this.brain,[arrays.rowptr,arrays.column,arrays.weight,this.states[i],this.states[1-i],arrays.parameters,arrays.encoder,this.config]));
+    this.outputGroup=this.group(this.readout,[this.states[m.steps%2],arrays.neurons,arrays.projection,this.result,this.outConfig]);
+    await d.queue.onSubmittedWorkDone();
+    return m;
+  }
+  buffer(size,usage) { const b=this.device.createBuffer({size:Math.max(4,size),usage}); this.buffers.push(b); return b; }
+  group(pipeline,buffers) { return this.device.createBindGroup({layout:pipeline.getBindGroupLayout(0),entries:buffers.map((buffer,binding)=>({binding,resource:{buffer}}))}); }
+  async pipeline(code) {
+    const module=this.device.createShaderModule({code});
+    const info=await module.getCompilationInfo();
+    if (info.messages.some(m=>m.type==='error')) throw new Error(info.messages.filter(m=>m.type==='error').map(m=>m.message).join('\n'));
+    return this.device.createComputePipelineAsync({layout:'auto',compute:{module,entryPoint:'main'}});
+  }
+  async predict(board,turn) {
+    if (this.lost) throw new Error('GPU connection lost. Reload to reconnect.');
+    if (this.busy) throw new Error('A move is already being computed.');
+    this.busy=true;
+    const started=performance.now();
+    try {
+      const m=this.manifest,d=this.device; const cfg=new ArrayBuffer(128);
+      new Uint32Array(cfg)[0]=m.neurons;
+      const features=new Float32Array(cfg,16);
+      for(let i=0;i<9;i++) features[i*3+(board[i]===0?0:board[i]===turn?1:2)]=1;
+      d.queue.writeBuffer(this.config,0,cfg);
+      const encoder=d.createCommandEncoder();
+      encoder.clearBuffer(this.states[0]); encoder.clearBuffer(this.states[1]);
+      for(let step=0;step<m.steps;step++) {
+        const pass=encoder.beginComputePass(); pass.setPipeline(this.brain); pass.setBindGroup(0,this.brainGroups[step%2]);
+        pass.dispatchWorkgroups(Math.ceil(m.neurons/64)); pass.end();
+      }
+      const out=encoder.beginComputePass(); out.setPipeline(this.readout); out.setBindGroup(0,this.outputGroup);
+      out.dispatchWorkgroups(Math.max(9,m.activity_samples)); out.end();
+      encoder.copyBufferToBuffer(this.result,0,this.readback,0,this.resultSize); d.queue.submit([encoder.finish()]);
+      await this.readback.mapAsync(GPUMapMode.READ);
+      const values=new Float32Array(this.readback.getMappedRange()).slice(); this.readback.unmap();
+      const logits=Array.from(values.slice(0,9));
+      if (!logits.every(Number.isFinite)) throw new Error('The model returned invalid scores.');
+      const legal=board.map((v,i)=>v===0?i:-1).filter(i=>i>=0);
+      const move=legal.reduce((best,i)=>best<0||logits[i]>logits[best]?i:best,-1);
+      return {move,logits,activity:values.slice(9),milliseconds:performance.now()-started};
+    } finally { this.busy=false; }
+  }
+  destroy() { for(const b of this.buffers) b.destroy(); this.device?.destroy(); }
+}

source/web/index.html

@@ -0,0 +1,39 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="description" content="Play tic-tac-toe against an experimental model built from a fruit fly's measured neural wiring. Inference runs in your browser with WebGPU.">
+  <meta name="color-scheme" content="dark"><title>Fly XOX · one very small opponent</title>
+  <link rel="stylesheet" href="./style.css">
+</head>
+<body>
+  <main>
+    <header><a class="wordmark" href="./">FLY / XOX <span>🪰</span></a><span class="tag">MALECNS EXPERIMENT 01</span></header>
+    <section class="game-layout" aria-label="Tic-tac-toe game">
+      <div class="play-area">
+        <div class="eyebrow">YOU VS. A FRUIT FLY</div>
+        <h1>Pick on someone<br>your own size.</h1>
+        <div class="players"><span><b class="x">X</b> YOU</span><span class="versus">VS</span><span><b class="o">O</b> THE FLY</span></div>
+        <div id="board" class="board" role="group" aria-label="Tic-tac-toe board"></div>
+        <p id="status" role="status" aria-live="polite">Wake the fly to start a game.</p>
+        <div class="actions"><button id="load" class="primary">Wake the fly <span>↗</span></button><button id="reset" disabled>New game</button><button id="first" disabled>Let the fly start</button></div>
+        <progress id="progress" value="0" max="1" aria-label="Model loading" hidden></progress>
+        <p id="download-note" class="small">The first load fetches the full model into your browser. No game server chooses its moves.</p>
+      </div>
+      <aside>
+        <div class="panel-top"><span class="dot" id="dot"></span><span id="brain-status">BRAIN ASLEEP</span><span class="small">WEBGPU</span></div>
+        <div class="brain-label">A little activity.</div>
+        <canvas id="activity" width="640" height="280" aria-label="Measured activity of 128 selected model neurons"></canvas>
+        <p class="small">128 selected model neurons · actual computed rate states</p>
+        <div class="stats"><div><strong id="neuron-count">—</strong><span>neurons</span></div><div><strong id="edge-count">—</strong><span>connections</span></div><div><strong id="latency">—</strong><span>last move</span></div></div>
+        <div class="score-heading">WHERE IT WANTS TO GO <span>relative move scores</span></div>
+        <div id="scores" class="scores"></div>
+        <blockquote id="quip">“I was promised a banana.”</blockquote>
+        <details><summary>What is actually running?</summary><p>The measured MaleCNS wiring, with simplified rate dynamics. Internal neuron gains, offsets, and leaks were trained for XOX. The board input and move decoder are engineered, fixed mappings. This is an experimental model, not a recreated living fly.</p><p id="evaluation">Evaluation loads with the model.</p><p><a href="https://male-cns.janelia.org/" target="_blank" rel="noreferrer">MaleCNS dataset ↗</a> · CC BY 4.0</p></details>
+      </aside>
+    </section>
+    <footer><span>166,000-ish neurons. Nine squares. No pressure.</span><span>REAL WIRING / EXPERIMENTAL LEARNING</span></footer>
+  </main>
+  <script type="module" src="./app.js"></script>
+</body>
+</html>

source/web/readout.wgsl

@@ -0,0 +1,18 @@
+struct Config { count: u32, samples: u32, unused0: u32, unused1: u32 }
+@group(0) @binding(0) var<storage, read> state: array<f32>;
+@group(0) @binding(1) var<storage, read> neurons: array<u32>;
+@group(0) @binding(2) var<storage, read> projection: array<f32>;
+@group(0) @binding(3) var<storage, read_write> result: array<f32>;
+@group(0) @binding(4) var<uniform> config: Config;
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+  let i = id.x;
+  if (i < 9u) {
+    var score = 0.0;
+    for (var j = 0u; j < config.count; j++) {
+      score += projection[i * config.count + j] * state[neurons[j]];
+    }
+    result[i] = 8.0 * score;
+  }
+  if (i < config.samples) { result[9u + i] = state[neurons[i]]; }
+}

source/web/style.css

@@ -0,0 +1 @@
+:root{font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;color:#f4f3eb;background:#101311;--green:#d4fc6b;--muted:#9aaba1;--line:#344137}*{box-sizing:border-box}body{margin:0}button,a{touch-action:manipulation}button{font:inherit;cursor:pointer}button:disabled{cursor:default;opacity:.4}button:focus-visible,a:focus-visible,summary:focus-visible{outline:3px solid var(--green);outline-offset:5px}main{max-width:1280px;margin:0 auto;padding:0 48px}header{height:100px;display:flex;align-items:center;justify-content:space-between;border-bottom:1px solid var(--line)}.wordmark{font-size:23px;font-weight:850;letter-spacing:-1px;text-decoration:none;color:inherit}.wordmark span{font-size:30px;margin-left:8px}.tag,.eyebrow,.panel-top,.score-heading,footer{font:12px ui-monospace,SFMono-Regular,Consolas,monospace;letter-spacing:1px}.tag{color:var(--muted)}.game-layout{display:grid;grid-template-columns:minmax(360px,1fr) minmax(300px,430px);gap:90px;padding:56px 0 46px}.eyebrow{color:var(--green)}h1{font-size:clamp(34px,4vw,52px);font-weight:600;line-height:1.06;letter-spacing:-2px;margin:18px 0 32px}.players{display:flex;align-items:center;gap:22px;font-size:13px;font-weight:600;letter-spacing:1px;margin-bottom:18px}.players span{display:flex;align-items:center;gap:10px}.players b{font-size:25px}.x{color:var(--green)}.o{color:#e8a879}.versus{color:#68776c;font-size:12px}.board{display:grid;grid-template-columns:repeat(3,1fr);gap:2px;background:var(--line);max-width:410px;aspect-ratio:1}.cell{border:0;background:#171e18;color:var(--green);font-size:clamp(40px,5vw,68px);font-weight:400;line-height:1;transition:background .15s}.cell:not(:disabled):hover{background:#253321}.cell:disabled{opacity:1}.cell.o{color:#e8a879}.cell.win{background:#344427}.cell.chosen{box-shadow:inset 0 0 0 2px #e8a879}#status{font-size:16px;min-height:24px;margin:20px 0}.actions{display:flex;gap:10px;flex-wrap:wrap}.actions button{padding:12px 15px;border:1px solid var(--line);background:transparent;border-radius:5px;color:inherit;font-size:14px}.actions .primary{background:var(--green);border-color:var(--green);color:#101311;font-weight:650;min-width:175px;display:flex;justify-content:space-between;gap:18px}progress{width:100%;max-width:410px;margin-top:18px;accent-color:var(--green)}.small{font-size:12px;line-height:1.6;color:var(--muted);letter-spacing:0}#download-note{max-width:410px;margin-top:14px}aside{align-self:start;border:1px solid var(--line);padding:24px;border-radius:10px;background:#151b16;margin-top:3px}.panel-top{display:flex;align-items:center;gap:8px;color:var(--green)}.panel-top .small{margin-left:auto}.dot{width:7px;height:7px;border-radius:50%;background:#6b796c}.dot.awake{background:var(--green);box-shadow:0 0 12px #d4fc6b44}.brain-label{font-size:27px;letter-spacing:-1px;margin-top:35px}canvas{width:100%;height:170px;display:block;margin-top:16px;border-bottom:1px solid var(--line)}.stats{display:grid;grid-template-columns:repeat(3,1fr);gap:10px;margin:28px 0;padding-bottom:28px;border-bottom:1px solid var(--line)}.stats strong{display:block;font-size:23px;letter-spacing:-.8px;font-weight:500}.stats span{display:block;color:var(--muted);font-size:12px;margin-top:6px}.score-heading{display:flex;justify-content:space-between;align-items:center;font-size:11px;gap:12px}.score-heading span{font-size:11px;letter-spacing:0;color:var(--muted)}.scores{display:grid;grid-template-columns:repeat(3,1fr);gap:5px;margin-top:14px}.score{padding:12px;background:#202920;color:#9daf9d;border-radius:3px;font:13px ui-monospace,monospace;display:flex;justify-content:space-between}.score.picked{background:var(--green);color:#101311}.score.used{opacity:.35}blockquote{font-size:20px;line-height:1.4;margin:32px 0 25px;font-style:italic;color:#d2dacd}details{border-top:1px solid var(--line);padding-top:18px}summary{font-size:14px;color:var(--muted);cursor:pointer}details p{font-size:14px;line-height:1.7;color:var(--muted)}details a{color:var(--green)}footer{border-top:1px solid var(--line);padding:22px 0 30px;color:var(--muted);display:flex;justify-content:space-between;gap:20px;font-size:11px;line-height:1.8}@media(max-width:900px){main{padding:0 24px}.game-layout{gap:30px;grid-template-columns:1fr 1fr}aside{padding:18px}.stats strong{font-size:19px}.score-heading{flex-direction:column;align-items:flex-start;gap:6px}}@media(max-width:680px){header{height:75px}.tag{font-size:10px}.game-layout{grid-template-columns:1fr;padding-top:32px;gap:35px}.board{max-width:none}.play-area{max-width:470px;width:100%;margin:auto}h1{font-size:42px}.cell{font-size:64px}aside{max-width:470px;width:100%;margin:auto}footer{flex-direction:column;gap:4px}.score-heading{flex-direction:row}.stats strong{font-size:24px}}@media(prefers-reduced-motion:reduce){*{transition:none!important}}