Research

Research Workflow — Modelless Inference, Freeze/Thaw, Latent-to-Latent

This repo (katgpt-rs) + riir-ai (freeze/thaw runtime + adaptive NPCs + game systems) + riir-chain (neuro-symbolic chain transport, LatCal) + riir-neuron-db (NeuronShard, BLAKE3/Merkle, freeze/thaw envelope) ship runtime + latent-space operations. The inference substrate (weights, quant formats, kernels, encoders, loaders) lives in riir-infer; decision-engine serving + comparison (calibration, abstention, arenas) lives in riir-reflex — both opened public 2026-09-23 as the first sanctioned Research-003 exceptions. Training-method research lives in riir-train. If a paper's value is its training loop → riir-train (see §3.5 Path 0.5 — applicable training papers get a Plan, not a lazy redirect). If its value is a latent-space insight, a routing trick, a freeze/thaw pattern, a chain-commitment bridge, a neuron-shard primitive, or a modelless inference primitive → distill here. If it's about how trained weights are REPRESENTED and run (quant, kernels, encoder forwards, loaders) → riir-infer; if it's about how a MODELLESS decision is SERVED (calibration, abstention, comparison arenas) → riir-reflex; if it's a TRAINED-ENCODER serving arm (encoder lane product, per-suite winners/vessels, serving posture) → riir-rethink (private forever — reflex gets at most an owner-gated public comparison lane).

When to use

Reading/fetching/summarizing ML/AI/systems papers · deciding which repo a paper belongs to · creating .research/ notes or .plans/ files · implementing modelless inference primitives · designing freeze/thaw cycles, adapter hot-swap, runtime adapter routing · designing latent-to-latent ops (dot-product projections, sigmoid gating, manifold geometry, spectral methods) · designing MMORPG-scale game AI (thousands of concurrent NPCs, 20Hz tick, fog-of-war, emergent social/economic behavior).

Do NOT activate for: pure refactor, bug fixes with no research angle, or ordinary feature work.

Repos

Canonical count + membership: katgpt-rs/AGENTS.md §"Repo count" — the product/distillation set is 7 (first block below); the workspace is 27 contract repos at the 2026-10-07 read (all with a root BOUNDARY.md; the Instinct/Rethink carve added two 2026-10-03 — this file's typed counts have rotted before, so derive the set, never trust this or any number here):

cd /Users/katopz/git && for d in */; do
  case "$d" in *.wprobe/) continue;; esac   # probe artifacts carry BOUNDARY.md + .git but are not repos (naive derive returns 28)
  [ -f "$d/BOUNDARY.md" ] && [ -d "$d/.git" ] && echo "${d%/}"
done

The product/distillation set (7):

• katgpt-rs/ — public MIT engine. Generic modelless inference primitives. No game/chain/shard IP.
• riir-ai/ — private game product. Freeze/thaw runtime, self-learn, game systems. Hosts the .docs/ moat book.
• riir-chain/ — private neuro-symbolic chain transport. LatCal, riir-chaind, economics, asset lifecycle, catchup/ (Turso/libSQL, quorum). Re-exports riir-neuron-db under neuron_db feature; canonical shard source is riir-neuron-db/.
• riir-neuron-db/ — private leaf. NeuronShard (Pod, zero-copy mmap), ShardIndex (lock-free papaya), generic MerkleTree/MerkleProof, MerkleFrozenEnvelope, MAPE-K, Raven/δ-Mem consolidation, AnyRAG gateway, vibe KG triples, spectral init, ShardCompactor, dendritic LoRA branch. No chain dep — usable standalone.
• riir-train/ — private training vault. As of 2026-08-06: actively pursued, not lazily redirected. Applicable training papers get a Plan in riir-train/.plans/ per §3.5 Path 0.5. read_file riir-train/.docs/02_pipelines/training_data_pipeline.md before any training-paper verdict.
• riir-game-sdk/ — private facade + dev-tool workspace; downstream consumer, rarely a distillation target.
• riir-dapps/ — private dApp layer (added 2026-08-20). Game outcome → generic chain settlement (Settlement, MultiClaimEscrow composition) + the KAT ledger/service SERVER plane (kat_ledger, epoch settle, payment rails, CF worker/DO shell). Route settlement-composition + service-economy papers here, NOT riir-chain.

**The wider workspace (the other 20 — route here only when the insight is inseparable from that surface; the first three entries are first-class PUBLIC distillation targets, not last resorts):

• riir-refine/ — private multi-domain code healer. Fusion priority #2 (see the ladder below) — the workspace's densest latent-state consumer per LOC; healer-domain distills file their .research/ notes HERE (renamed riir-refine -> riir-refine 2026-10-01) (MOAT row below).
• riir-infer/ — PUBLIC LLM-inference substrate (carved from riir-ai 2026-09-22; opened public 2026-09-23 — the first sanctioned Research-003 exception). Workspace: riir-infer-core at the repo root (CPU substrate: weights/quant/architectures/loaders — quant/ EXL3-trellis lane, deltanet/ GDN lane, Bonsai2 rotation, gguf_loader.rs/safetensors_loader.rs/tokenizer.rs, simd/) + crates/riir-infer-gpu (wgpu/CubeCL GPU layer) + crates/riir-infer-laya (the pinned-checkpoint encoder lane: CPU + macOS Metal + non-macOS CUDA backends — reflex's comparison-lane substrate). Zero riir- deps — upstream of the engine.* Quant/weight-format/kernel/encoder/loader papers distill HERE (a real target; its .research/ is created on first use).
• riir-reflex/ — PUBLIC decision-engine serving + comparison + contribution (opened public 2026-09-23, same day). Serves decision_wire (choice/score/noul, abstention first-class) modellessly: hashed-feature embedding (embed.rs) → pick_domain corpus routing → Lz4FlexDrafter corpus-is-the-model option scoring → sigmoid normalization → SigmoidGateCalibrator → fused abstain (CorpusDistanceGate). GOAT gates G1–G5 (G5 laya-parity must pass before ANY published laya number); the honest-metrics harness (harness/, 9 dataset suites, corpus-cap levers) + comparison lanes (lanes/: laya CPU/Metal/CUDA, CLM, GLiNER, AgentJev). Calibrated-decision-serving / abstention / selective-prediction / comparison-arena papers route here. The laya lane SUBSTRATE lives in riir-infer — reflex consumes + measures it.
• riir-instinct/ — PUBLIC open lane (carved from the moat 2026-10-03, Instinct/Rethink split): the L1→L3 decision-serving stack crate — suites, the lane-backend seam (riir_instinct::server::{LaneBackend, ExtBoots, install_ext_boots} + the AnySuiteServer::Ext seat), arena game heads, and the one-definition home of the escalation grammar (riir_instinct::arsenal::EscalateSpec; riir-refine Plan 202 R1 — rethink byte-pins it, never forks it). Open-stack/lane-seating/escalation-grammar/arena-head papers route here; the enforcement + product posture live rethink-side.
• riir-rethink/ — PRIVATE FOREVER (the carve's moat, seeded from riir-instinct/moat/): the trained-encoder decision product — L3 encoder serving rung (serving-weights sizing: F16/Q8 adopted/Q4 FAIL), ESC enforcement (the manifest escalate table is the only ARMING surface; RIIR_RETHINK_ESC=0 demote-only; rolling-rate guard), the HOSTED-ONLY vessel reader (the vessel feature never joins a public build — the A10 moat law), the decstat economy-capture plane, and the ESC-depth research line (.research/001 population-scaling). ESC/escalation-lane/depth-lane/population-scaling/serving-economy papers route here. Visibility: git@github.com:gist-rs/* private; nothing here may leak through a public-repo distill.
• riir-auth/ — private. Latent-space session recording (SessionFingerprint → NeuronShard) + 3-pillar ban quorum + the account_key Ed25519 identity substrate. Behavioral-identity/fingerprinting/escalation papers route here.
• riir-dao/ — private KAT tokenomics agent (signals → strategy → guards → advisory → commit; modelless Elo + Beta-LCB selection). Tokenomics/governance/mechanism-design papers route here.
• riir-kat/ — private KAT network CLIENT + wire-protocol plane (spun out of riir-refine 2026-09-10, issue 088). Service-protocol papers only; rarely a target.
• riir-deployer/ — private manifest-driven deploy orchestrator (genesis ceremony, ops ladder, freeze-lineage probe). Ops/infra papers; rarely a target.
• riir-esp32/ — private POC/fun, not prod: the ESP32 Satellite device tier (esp-hal firmware, on-device crypto timing). Device-tier papers only.
• riir-viewbridge/ — private Unity FFI seam, PARKED 2026-09-03 (Bevy is the shipping render path). FFI raw/latent-wall papers only; expect no consumer until unfreeze.
• katgpt-web/ — PUBLIC explainer site ("The Anatomy of KatGPT-RS"). Presentation surface only — nothing private may ever appear here; never a distillation target.
• riir-shader/ — private shader surface (workspace member per scripts/repo_set.txt; no established research routing yet).
• (riir-armageddon/ sat in the product set until it was retired 2026-09-02, owner act — the directory is gone; do not route to it.)
• Also on disk, never routed by name: riir-mmorpg-examples, riir-llm, mmorpg-editor, mmorpg-remake, mmorpg-remaster, riir-reflexer, reflex-site — consumers/leaf/presentation surfaces, targets of last resort (riir-mmorpg-examples is the reference game consumer; reflex-site is the public bench-publish front).

Routing rule of thumb: if it's about how a shard is structured/committed/frozen/consolidated/retrieved/projected → riir-neuron-db. If it's about how a shard crosses quorum or bridges to LatCal fixed-point → riir-chain. If it's about code retrieval / fix trajectories / rule corpora / healer selection → riir-refine. If it's about settlement composition or the service economy → riir-dapps (economy governance/tuning → riir-dao; the client/wire protocol → riir-kat). If it's about how trained weights are represented and run — quant formats, kernels, encoder forwards, loaders → riir-infer. If it's about how a MODELLESS decision is served — calibration, abstention, comparison arenas → riir-reflex; a lane that SERVES product decisions from a trained encoder (encoder lane product, per-suite winners/vessels, serving-weights posture) is riir-rethink's charter even when the proposal says "Reflex" — reflex gets at most an owner-gated public comparison lane. If it's about the escalating decision ladder, suite/arena seating, or the open serving stack's grammar → riir-instinct (open stack + EscalateSpec one-definition) / riir-rethink (private enforcement + depth economics; split by the carve law: grammar and stack in instinct, product posture and enforcement in rethink, lockstep edits in ONE family).

⛔ Family ≠ repo (the 2026-10-07 encoder-lane instance, 6th of the challenge-rescue class; the record lives in the private tier): the ladder reflex→instinct→rethink is a product family spanning THREE repos, and input documents routinely name "the Reflex family/stack" as host. Route by RUNG, never by the document's own name for its host: modelless floor + public arenas = reflex; open grammar/seam/arena heads = instinct; trained-encoder serving + enforcement + economy = rethink. The decisive question for any encoder/decision-lane proposal: is this a public comparison lane or a private serving arm?

Commercial strategy (inline short version)

What = public. How = private. Training how → riir-train. Runtime how → riir-ai. Chain how → riir-chain. Shard how → riir-neuron-db. When unsure → default private (safe to keep private; never safe to un-leak public). Toy 2D games (bomber, monopoly, go, fft) are NOT product IP — public. *_runtime suffix = private GOAT composition layer; bare-name = public primitive. FV moat: ~79 Lean 4 theorems across 4 .proofs/ instances.

Public exceptions (2026-09-23, owner-sanctioned Research-003 amendments): riir-infer (the model-based inference substrate — weights/quant/kernels/loaders; the substrate tier of track c) and riir-reflex (decision-engine serving + comparison arenas). They are routing targets with their own MOAT rows (§1.6), not leaks — runtime/chain/shard/train IP stays private.

Pre-flight — MANDATORY before any verdict/file

Do all five before creating any file:

1. read_file the product-set READMEs (katgpt-rs, riir-ai, riir-chain, riir-neuron-db, riir-train, riir-game-sdk, riir-dapps) + riir-ai/.docs/README.md + riir-refine/AGENTS.md (the healer — fusion priority #2) + riir-infer/AGENTS.md + riir-reflex/AGENTS.md (the public inference-substrate + decision-serving surfaces) + riir-instinct/AGENTS.md + riir-rethink/AGENTS.md (the ladder split — reading these two is what separates a reflex public comparison lane from a rethink private serving arm) + (for training papers) riir-train/.docs/02_pipelines/training_data_pipeline.md — defines scope boundaries. Skipping = #1 cause of false Super-GOAT claims + false PASS on training papers.
2. list_directory every .research/ folder in the workspace — derive it (ls -d /Users/katopz/git/*/.research), never trust a typed count: 15 today (katgpt-rs, riir-ai, riir-auth, riir-chain, riir-refine, riir-dao, riir-infer, riir-instinct, riir-neuron-db, riir-reflex, riir-rethink, riir-shader, riir-train, riir-viewbridge, seal-online-remaster); create missing ones on first use.
3. list_directory the 6 runtime/chain/db/substrate/serving src trees — module names are vocab. Skipping = #2 cause of false Super-GOATs.
4. web_search for published prior art on the paper's headline technique (see §4). Skipping = #4 false-novelty failure mode. Internal-first rule (GRAM/058 lesson, 2026-09-25): before any web search, grep every workspace .research/ folder for the paper's arXiv ID AND its title verbatim — a prior distillation is the controlling constraint, and a content grep that stops at page 1 of matches does not find it (Research 058 was missed exactly this way at note-590 round 1; caught only by the verdict reviewer).
5. grep ALL repos for existing training/model-based/self-adaptive code — the system is three-track, not modelless-only. Skipping = #5 false-PASS mode (canonical failure: arXiv:2511.18538 Code LLM survey was falsely PASSed because the agent only checked riir-train for training code, missing quest_grammar's LoRA training in riir-ai + TernaryDraftModel in riir-refine + self_evolve). Grep patterns: *_training.rs|*_train*.rs|LoRA|SFT|GRPO|DPO|ternary|TernaryDraftModel|self_evolve|with_weights|\.bits across riir-ai/crates/**/src/, riir-refine/src/, riir-neuron-db/src/. Training pipelines ship OUTSIDE riir-train — the three tracks are: (a) modelless inference, (b) self-adaptive runtime latent updates, (c) model-based trained weights.

list_directory the src trees (vocab; skipping causes the vocabulary-miss class of false verdicts — mechanisms ship under non-obvious names):

• riir-ai/crates/riir-engine/src/ (latent_functor/, cgsp_runtime/, hla/, ...), riir-ai/crates/riir-games/src/
• riir-chain/src/ (encoding/, consensus/, economics/, asset_lifecycle/, forensic/, catchup/)
• riir-neuron-db/src/ (shard.rs, index.rs, merkle.rs, freeze.rs, mape_k.rs, consolidation.rs, gateway.rs, vibe.rs, spectral_flatness.rs, shard_compactor.rs)
• riir-train/crates/riir-train-{gpu,engine}/src/ (distill_attention.rs, loss_grpo.rs, loss_dpo.rs, delta_filter.rs)
• riir-infer/src/ (the riir-infer-core root: quant/, deltanet/, transformer/, simd/, gguf_loader.rs, safetensors_loader.rs, tokenizer.rs, ...) + riir-infer/crates/riir-infer-{gpu,laya}/src/
• riir-reflex/src/ (engine.rs + engine/, embed.rs, label_heads.rs, readout.rs, harness/, lanes/, serve.rs, game_heads.rs)

Do NOT create any file until all five done.

Primary focus — Fusion-first

The highest-value Super-GOATs come from fusing 2–3 papers/primitives into a novel combination, not from direct-mapping a single paper. Always grep .research/ + .plans/ for the 2–3 closest cousins before verdict, and ask: "what does paper × note A × note B produce that none of them alone can?"

Fusion priority ladder (owner-set investment order, 2026-09-02)

The repos are NOT equal-weight fusion surfaces. When a paper fuses into several, evaluate and file in THIS order — the higher-priority surface wins plan/issue filing priority for the same primitive:

1. Game / MMORPG runtime (riir-ai + riir-game-sdk + product repos) — the #1 investment.
2. riir-refine healer (code/perf/sec fixing: corpus, retrieval, fix trajectories, score-bench, rustc_errors playbooks, domain router) — the #2 investment and the workspace's densest latent-state consumer per LOC.
3. Inference-perf league (beat llama.cpp / oMLX / vLLM — the riir-gpu / riir-ai serving path; substrate-side kernels + quant formats + encoders → riir-infer, serving + measurement → riir-reflex).
4. riir-chain (consensus / LatCal / settlement).
5. Training / fine-tuning / LoRA (riir-train + in-repo pipelines; recipes and adapters — full pretraining is out of scope).

The ladder orders EFFORT, not existence: lower-priority fusions still get recorded (note + issue), but a higher-priority surface carrying the same mechanism gets the plan first. The standing per-verdict check this ladder encodes: "did I ask what this does for the healer?" — canonical failure #5 (below) is what happens when that question is never asked.

Patterns that ship here:

• Latent-to-latent operations — dot-product projections, cosine retrieval, sigmoid-gated routing, manifold geometry, spectral methods on activations. Prefer operating on latents over decode→re-encode. Fuse with freeze/thaw to version direction vectors; with self-learn to update them from runtime curiosity.
• Freeze/thaw patterns — versioned snapshots, atomic hot-swap, lock-free reads, BLAKE3-checked reload, per-entity personality divergence. Fuse with adapter routing to dispatch by latent similarity; with self-learn to checkpoint emergent personalities.
• Runtime adapter routing — selecting between frozen adapters by state/objective/context (Dynamic Pair, Polytope, dMoE — inference-time, zero training). Fuse with freeze/thaw to make the pool versioned + committed; with bandits to learn routing online.
• Self-learn / adaptive CoT — runtime curiosity, entropy exploration, collapse detection/recovery, latent prediction SSL, trajectory folding. No backprop. Fuse with MMORPG-scale game AI for thousands of NPCs each with independent curiosity; with freeze/thaw to checkpoint.
• Modelless inference primitives — ConstraintPruners, bandits, DDTree, speculative decode, sparse attention, quant-aware inference.
• MMORPG-scale game AI — thousands of concurrent NPCs, 20Hz tick, fog-of-war, zone attention, emergent social/economic behavior. Latent ops must batch; raw sync must stay bit-identical.

Super-GOAT factory modules — grep FIRST

The highest-value latent Super-GOATs cluster in twelve module trees. list_directory these explicitly even if the paper looks pure-training — vocab mismatch is the #3 cause of false verdicts:

Adapter routing, KV compression, speculative decode = GOAT-tier framings. Latent-to-latent ops on belief/functor/shard/LatCal state = Super-GOAT-tier framings. Attempt Super-GOAT first. Defaulting to adapter routing when a latent reframe is stronger is the primary failure mode.

Consumer-surface miss (canonical failure #5 — arXiv:2608.29530 TPR, 2026-09-02): the paper's mechanism (role-filler binding, E = W(Σ fᵢ⊗rᵢ)+b) mapped onto the healer corpus (rule = role, code-shape = filler, oracle ground truth, measurable downstream top-1) MORE directly than onto any game surface — but the fusion hunt enumerated only game kernels: the factory table had no clippy rows, the MOAT table no clippy domain, and the repo-wide grep stopped at page 1 of matches, so the riir-rag/riir-refine wedge-consumption evidence was never read. The clippy fusion (riir-refine Issue 62: withheld-pair OOD bench + structured retrieval axis) surfaced only by user challenge — 5th rescue of the challenge-rescue class after NQF, LOPD, Le Critique, TTPO. Fixes applied: the priority ladder above, the clippy factory rows above, the step-4 consumer reframe, the MOAT clippy row, and the step-1 pagination rule.

Redirect to riir-train

Pre-check before ANY redirect: exhaust §3.5 modelless unblock paths first. A mechanism that looks training-only may be modelless-validable because its training-target MATH decomposes into shipped primitives (Flow Sampling is the canonical case: "trains a drift network via backprop" decomposed into dllm interpolant + Latent Field Steering reward-gradient + freeze/thaw replay buffer).

As of 2026-08-06: training is actively pursued, not lazily redirected. Applicable training papers (optimizer, loss, schedule, recipe, LoRA/OFT/IA3/QLoRA/DPO/GRPO/SFT/RL) get a Plan in riir-train/.plans/ with recipe + GPU-hours estimate + GOAT gate comparing trained-vs-modelless baseline. Only genuinely out-of-scope training (image-specific DiT we'll never train, medical imaging) gets the one-line redirect with explicit justification.

Runtime GRPO self-play stays in riir-ai (self-adaptive track — updates latent state, not weights). Model-based training (LoRA/SFT/GRPO on actual weights) lives in BOTH riir-train AND in-repo training pipelines (quest_grammar/grammar_training.rs in riir-ai, TernaryDraftModel .bits files in riir-ai/riir-refine). Quant-aware inference stays here; quant-aware training → riir-train. Never assume a repo is modelless-only — grep for existing training/model-based code first (pre-flight #5).

Workflow

Every path through this workflow terminates at §5 — the Claude verdict ping-pong — before anything commits. §1.5 / §1.55 / §1.6 grade the verdict; §5 is what makes it final.

0. Read & classify

Fetch via https://r.jina.ai/https://arxiv.org/pdf/{ID}. Ask: is the value in the training loop itself (optimizer/loss/schedule/RL), or in the math the training computes (closed-form drift, conditional score, Riemannian correction, steering formula)? Optimizer/loss/schedule → riir-train. Math → run §3.5 Path 0 first.

Label-anchoring hazard (canonical failure #2 — arXiv:2608.13335 NQF, 2026-08-18): the paper's own vocabulary ("Neural", "trained by gradient descent", "learning dynamics") is a routing hazard. Training-dynamics papers routinely carry closed-form modelless content — ignition-time formulas, closed-form trajectory families, initial-behavior limits, offline-computable spectra. NQF was routed wholesale to riir-train although its theorems carried a sigmoid-in-time adoption family, a t* = ln(1/ε)/ζ patience law, and a fresh-module leading-behavior predictor; surfaced only by user challenge (same rescue class as the LOPD canonical failure). Classification comes AFTER the §3.5 two-question decomposition + adversarial panel — never from the abstract's framing. The same hazard applies to NON-paper inputs (in-conversation proposals, model cards, issue texts): a 2026-10-07 encoder-lane proposal named "the Reflex decision family" as host and the note+POC were first routed to riir-reflex (public) although a trained-encoder serving lane is rethink's charter (private forever) — the family name was mistaken for the repo. The document's name for its host is routing INPUT, never the routing verdict; the defense is the family≠repo rule in the routing thumb + the MOAT rows + the §5 public/private tier check.

Test-time split hazard (canonical failure #4 — arXiv:2608.27448 TTPO, 2026-08-29): a "test-time training" paper carries TWO separable claims — the gradient objective (training track) AND the runtime decision layer the objective is built on (vote partition, asymmetric agree/penalize treatment, confidence scoring). TTPO's abstract framing routed the gradient objective to a riir-train plan filed as PRIMARY while the modelless decision layer — the half that fits the serving envelope — was downgraded to "recorded"; rescued by user challenge (4th rescue of this class after NQF, LOPD, Le Critique — user challenge is load-bearing, treat every challenge as a granularity audit). Fix: per-track verdicts (§1.5), discard-reason scrutiny (§3.5), serving-envelope fit (§3.5).

Three-track system — do NOT classify a repo as "modelless only" without checking pre-flight #5. The system runs three concurrent tracks: (a) modelless inference (primary hot path — no weights, BLAKE3-deterministic), (b) self-adaptive (runtime latent updates — self_evolve, EMA direction vectors, freeze/thaw cycles), (c) model-based (trained weights — ternary .bits files, LoRA/QLoRA adapters, Bonsai model comparison). A paper touching ANY track is actionable. The model-based track exists in repos OUTSIDE riir-train: quest_grammar/grammar_training.rs + quest_training.rs (LoRA rank=16-32, alpha=32-64, QLoRA 4-bit) in riir-ai; TernaryDraftModel with .bits weight files in riir-ai/riir-refine; self_evolve feature in riir-refine (shipped, G1-G7 ALL PASS). Before classifying a paper as "training-only, deferred" → grep for existing training code in the target repo (pre-flight #5).

Substrate ≠ value. Hardware/NMP/PIM/ASIC papers: the value is usually the technique (LUT INT→FP, shared ALU, sideband-tag) stripped of the hardware — grep simd_*, ternary, Plasma, Q4_K, LUT, from_bits for the software analog. Database/systems papers: riir-neuron-db IS a database (Pod + ShardIndex + Merkle + MAPE-K + Raven/δ-Mem + vibe KG) — the value is usually the access pattern. OS/kernel papers (io_uring, DPDK): substrate is Linux, value is usually the technique (lock-free queue, batching, zero-copy). Pure math/combinatorics: value may be a guaranteed-peak property on a per-entity scalar — see §1 step 4 game-context reframe.

Before PASS on hardware-vocab papers: (1) identify technique stripped of substrate, (2) grep for software-SIMD analog, (3) PASS only if both confirm no analog.

External code repo (not a paper)? Skip jina — §0.5 clones it into .raw/ for full-tree grep.

0.5 External-repo source access — clone into .raw/ (ephemeral, rm when done)

Papers distill fine over the wire (https://r.jina.ai/...). External CODE repos do not — distill verdicts, mining batches, and prior-art verification need full-tree grep, byte-accurate quotes, and multi-file reads that URL fetches cannot provide. When a research task needs an external repo's source:

# Clone (shallow by default; full history ONLY if the task mines git log)
git clone --depth 1 https://github.com/<org>/<repo>.git .raw/<repo>
# Pin provenance BEFORE reading anything into a verdict:
git -C .raw/<repo> rev-parse HEAD   # record this sha + the license in the note

Rules (all mandatory):

1. Location: .raw/ at the root of the repo whose .research//.plans/ will hold the output (e.g. katgpt-rs/.raw/ds4/). .raw is ephemeral scratch — gitignored in every workspace repo, never committed, never a sibling repo.
2. Pin before verdict: record @ <full-sha> + license (Apache-2.0/MIT/...) in the research note BEFORE deleting the clone — the sha is the provenance; the clone is throwaway. Every quote later cited must match the pinned sha (precedent: riir-refine Batches 96–98 distills cite antirez/ds4 @ 110afdd8… with quotes "re-verified at mine time").
3. Read-only. Do not modify files inside .raw. If a patch experiment is needed, copy the file out first; never let experiments dirty the clone mid-verdict.
4. No build-graph contamination: never add a Cargo/path dep into .raw (BOUNDARY.md + standalone-dep gates), and never include .raw in codebase/pre-flight grep scopes — it is NOT shipped substrate, so grepping it inflates hit counts and makes a mining candidate read as "already ships".
5. Cleanup is part of the task: when the verdict/note/plan is committed, rm -rf .raw/<repo> (or the whole .raw/). A finished research task with a live .raw/ entry is an unfinished task. If a session dies mid-task, treat any stale .raw/ entry as UNTRUSTED on resume — delete and re-clone at the pinned sha; never verdict against a clone whose commit you did not pin yourself.
6. Shallow unless history-mining: --depth 1 by default; full clone only when the task needs git log/diff archaeology (fix-pair mining, regression hunts) — and say so in the note. For very large repos where only a few files are read, --filter=blob:none fetches blobs on demand.

1. Distill fundamentally — fuse, don't direct-map

Find the transferable primitive (the geometric/spectral/information-theoretic insight that works without the paper's training setup). Then look for fusion opportunities: cross-pollinate with existing notes/plans/shipped primitives to synthesize something novel.

Fusion protocol:

1. Grep ALL workspace repos, BOTH layers (notes AND code), in parallel via subagents — the product set of 7 first, then the wider set (derive the set, never hand-type; see §Repos — 15 enumerated today). Do NOT stop after the first repo or layer, do NOT wait for user prompts to grep the next repo. Grep results are PAGINATED — a full first page is NOT a finished sweep: run offset until exhausted, or scope the grep per-repo so every repo's hits are visible. Closest cousin is frequently in the OTHER repo (cross-repo fusion) or in CODE not notes (mechanisms ship without research notes — evolve_belief is a per-NPC recurrent belief-state kernel with no .research/ framing). Grep:

   • Every .research/ + .plans/ folder in the workspace (derive both — typed counts of either rot within weeks; riir-train included: applicable training papers get Plans per §3.5 Path 0.5)
   • riir-ai/.docs/ (the moat/selling-point book — grep alongside .research/ so you don't claim novelty over a pillar that ships)
   • All shipped src//crates/ trees (notes describe intent; code describes what shipped)
   • The twelve Super-GOAT factory modules above

2. Vocabulary translation BEFORE grepping. Papers and codebase use different words. List the paper's 3–5 key terms; for EACH, brainstorm ≥2 codebase equivalents ("if we shipped this, what would we call it?"). Grep BOTH sets. read_file vocab.md (sibling file) for 8 standing vocabulary tables + worked examples. Coefficient-shape mechanisms (adaptive blend / mixture coefficient / interpolation ratio / ensemble weight): shipped blends hide as hand-tuned constants (W_EVO = 0.6, alpha: f32, trust: f32), never under the word "blend" — use vocab.md §6's grep set and run it across ALL repos, never scoped to the expected home (canonical failure #3).

3. Latent-space reframing BEFORE verdict. Re-cast the core mechanism as a latent-to-latent op on the codebase's kernels: (a) per-NPC belief, (b) latent_functor/ ops, (c) cgsp_runtime/ curiosity, (d) LatCal fixed-point commitment, (e) NeuronShard style_weights/dendritic/MerkleFrozenEnvelope/Raven/AnyRAG, (f) DEC Stokes operators (d, δ, hodge_decompose, DecFlowField). If you only reach adapter routing/KV/spec-decode framing → likely GOAT, missed the Super-GOAT angle.

4. Game-context AND consumer-context reframing BEFORE verdict (especially when step 3 returns no hits). Game question: how does this mechanism manifest as a per-NPC behavior signal / crowd pattern / selling point in MMORPG context? A guarantee → what per-entity scalar does it bound, can that drive behavior (salience cadence, curiosity trigger, consolidation window)? A combinatorial structure → does it appear in NPC routines, market cycles, quest scheduling? A number-theoretic property → fairness/diversity/coverage on a game signal? A geometric property → NPC phase scheduling, spatial spread, fog-of-war coverage? Consumer question (priority #2, same evidence bar): does the mechanism manifest on a healer surface — (a) the retrieval index / corpus structure, (b) fix-trajectory memory / selection, (c) the score-bench / eval axis, (d) drafter-pruner selection, (e) rustc_errors playbooks? One sentence each; a bare "no" without reading the surface is the canonical-failure-#5 shape. If either reframe is missing, you are NOT ready to PASS.

5. Zero hits ≠ novelty. Most likely you're using the wrong vocab — try a third semantic angle (grep output behavior "swap when X" instead of mechanism name "tightness monitor") before claiming "no prior art".

6. List the 2–3 closest cousins across all repos. Ask: what novel combination of paper × A × B produces a capability none has alone? Write that into the note's §Distillation as a Fusion subsection even if unplanned.

7. Verdict by tiers (§1.5). Create research .md at the right repo. Naming: {NNN}_{Short_Title}.md (next free number, monotonic, never reused). Format: read_file templates.md (sibling) — canonical example: katgpt-rs/.research/238_LoRA_Muon_Spectral_Low_Rank_Manifold.md.

1.5. Novelty gate — is this Super-GOAT?

Score all four:

1. No prior art? Grep notes + plans + shipped code across all repos, using BOTH paper vocab AND codebase-vocab alternatives. Read every grep hit's TL;DR before claiming novelty — a filename match is a lead, not confirmation. Symmetric rule for the opposite direction: a cousin NAME match is a lead toward coverage, never coverage itself — "already ships" claims require the §3.6 signal-diff check. Mechanisms ship under non-obvious names (DiPOD's "interleave self-distillation when ELBO drifts" ships as "coherence-driven re-estimation scheduler when coherence < tau_reest"). When the candidate selling point touches per-NPC + memory + personality + swap, the riir-ai/.research/ corpus is saturated — grep it broadly and READ every hit before claiming novelty.
2. New behavior class? Not better numbers — a capability no incumbent has. Requires step 4 game-context reframe to detect. If you reached Q2 without step 4, go back.
3. Product selling point? Can you finish: "Our NPCs/systems do X that no competitor can"? If not → Gain.
4. Force multiplier? Connects to ≥2 existing pillars/systems. Solo novelty = GOAT, not Super-GOAT.

All 4 YES → Super-GOAT. Mandatory outputs (in this same session):

• Open primitive → katgpt-rs (generic math, no game semantics).
• Architectural GUIDE → private selling-point doc. Repo by selling-point domain: riir-ai/.research/ for game-runtime/belief/functor/self-learn; riir-chain/.research/ for chain/LatCal/commitment/sync-bridge; riir-neuron-db/.research/ for shard/freeze/consolidation/AnyRAG/vibe/Merkle. Cross-domain selling points → primary guide in the repo owning the boundary being crossed. Guide includes: TL;DR with commercial value, distilled modelless primitive, connection map, latent↔raw boundary, what's private vs open, validation protocol, P0–P3 priority.
• Plan(s) → appropriate .plans/ folders.

No "candidate" escape hatch. Writing "all 4 YES" / "passes the gate" / "Super-GOAT candidate" anywhere in a note triggers the mandatory outputs in THIS session. If not confident on all 4 → write "fusion idea, novelty TBD" + create .issues/ entry. "Candidate" is not a deferred-commitment escape — it either triggers the guide now, or downgrades to an issue.

One verdict per track, not one per paper (TTPO lesson, 2026-08-29). When a paper yields BOTH a training recipe AND modelless extractions (the Path 0 inventory rows), score this gate SEPARATELY per track. A training-track plan and a modelless-track plan are two claims with independent tiers — a Q1 kill on one does NOT cascade to the other. "Recorded in the note" is NOT a tier (same violation class as the banned "candidate" escape hatch): every Path-0 inventory row ends in exactly one of (a) filed plan (GOAT+), (b) .issues/ entry (fusion idea / novelty TBD), or (c) an audited discard whose reason cites the mechanism-level §3.6 diff — see the discard-scrutiny rule in §3.5.

Pin the claim BEFORE searching it (§4 precondition — TTPO lesson, 2026-08-29). Prior-art search 3 below is only meaningful against a pinned claim. Before running ANY §4 search, write the claim in one sentence: "<mechanism> for <surface/consumer>, consuming <signal>, distinguished from <closest cousin> by <delta>." A novelty check against an unpinned claim is void — class-level prior art (JitRL/OptPO killed "training-free test-time policy optimization" the CLASS, not the asymmetric-partition + calibration-law MECHANISM) will silently kill anything, and the verdict regresses to vibes. If you cannot write the sentence, you have not distilled enough to claim novelty either way.

1.55. PASS vs Gain — no middle tier

PASS = no new research/plan files. Gain = files. Scan the paper for actionable improvements before verdict.

• Ships + actionable improvements → Gain (create .issues/ per AGENTS.md "Create issue at .issues for poc, proof, optimization or refactor task, do not create plan", and/or plan behind feature flag).
• Ships + no actionable → Pass (verdict + one-line reason + closest shipped cousin, in conversation only; no files).
• Doesn't ship + modelless → Gain or higher.
• Doesn't ship + training-only → run §3.5 Path 0.5. Applicable → Plan in riir-train/.plans/. Out of scope → one-line redirect with explicit justification.

PASS-Redirects line (mandatory): PASS verdicts still update the 1–3 closest shipped cousin .research/ notes with a one-line reference. Format:

> **PASS-Redirects (synthesis):** <Author> [arXiv:XXXX.XXXXX "<Full Title>"] — <one-line reason>.

Must include arxiv ID AND full title (so grep arxiv:ID AND grep "Title" hit). Prevents paper-number invisibility — without this, a future session greps the arxiv ID, finds nothing, re-distills from scratch.

Actionable = Gain. Actionable: paper data contradicts a current config default; exposes a failure mode with no existing mitigation; unblocks a deferred task. NOT actionable: "validates our design" / "theoretical lens" / "could inform a future config". Unsure → not actionable → Pass.

Reverse-grep before PASS (mandatory). Before any PASS, grep the codebase for documented gaps the paper could fill: .docs/ for Limitation|deferred|TODO|FIXME|gap|pending; .benchmarks/ for Caveat|deferred|artifact; .rs comments for TODO|FIXME|deferred|limitation near the paper's vocab. If ANY hit maps → Gain, not Pass. Compact heuristic: "Is there any documented limitation this paper could fix?" — if you can't answer "no, I checked" with evidence, don't PASS.

Training papers third defense: both defenses above can return clean and still produce a false PASS if "model-based track" is narrowed to one pipeline or one repo. Before PASS-ing any training paper: (1) read_file riir-train/.docs/02_pipelines/training_data_pipeline.md and ask: does a training pipeline for this domain already exist? (RL, distillation, linear attention, trajectory collection). (2) grep ALL repos for existing training/model-based code (pre-flight #5) — training pipelines ship OUTSIDE riir-train: quest_grammar/grammar_training.rs + quest_training.rs (LoRA training in riir-ai), TernaryDraftModel (ternary weights in riir-ai/riir-refine), self_evolve (self-adaptive in riir-refine). If ANY existing training/model-based code maps to the paper's domain → Gain, not Pass. Canonical failure (arXiv:2511.18538): Code LLM survey falsely PASSed because agent checked only riir-train (game AI pipeline), missing quest_grammar's code-domain LoRA training + riir-refine's ternary drafter + Issue 010 (generalization gap that RLVR would fix).

1.6. MOAT gate per domain + promote/demote

Tier verdict measures how strong. MOAT gate measures whether it strengthens THIS repo's moat. Mismatch → reroute.

9 sloppy-test pillars live in riir-ai/.docs/03_pillars/README.md — read_file 03_pillars/README.md + 04_supergoat_candidates/README.md before any "does this become a pillar?" verdict. Sloppy test: if it doesn't exist, the system goes structurally sloppy — not slower, broken.

katgpt-rs per-stack ledger: every primitive gets a feature flag + benchmark + GOAT gate; the verdict note records which stack slot (attention/KV/sampling/speculative/pruning) + promote-to-default or stay-opt-in. Re-gate on feature touch. Demote the loser when a newer primitive wins the same slot.