Deaths integration contract

The Five Deaths are implemented as standalone Rust modules — one file per death — composed into model.rs and wasm_bindings.rs by a single foreground integration step. Subagents own files; foreground owns linking.

Each death's module must match the surface declared here so:

• subagents writing the modules can work in parallel without reading each other,
• the foreground integration is mechanical (mod x; pipeline.x = X::new(); …),
• a regression that re-empties one module doesn't leak into the others.

Death #1 — src/matvec_memo.rs

pub const OP_Q: u8 = 0;
pub const OP_K: u8 = 1;
pub const OP_V: u8 = 2;
pub const OP_O: u8 = 3;
pub const OP_FFN_GATE: u8 = 4;
pub const OP_FFN_UP: u8 = 5;
pub const OP_FFN_DOWN: u8 = 6;
pub const OP_LM_HEAD: u8 = 7;
pub const OP_LM_HEAD_RANGE: u8 = 8;
pub const OP_LM_HEAD_PARTIAL: u8 = 9;
pub const OP_OUTPUT_PROJ: u8 = 10;

pub struct MatVecMemo;

impl MatVecMemo {
    pub fn new() -> Self;
    pub fn set_enabled(&mut self, on: bool);
    pub fn set_tau_squared(&mut self, tau_sq: f32);
    pub fn set_max_entries(&mut self, n: usize);
    pub fn clear(&mut self);
    pub fn stats(&self) -> (u64, u64, u64);
    pub fn detailed_stats(&self) -> Vec<(u32, u8, u32, u32)>;
    pub fn probe(
        &mut self,
        layer: usize,
        op: u8,
        rows: usize,
        cols: usize,
        qtype: crate::model::QType,
        input: &[f32],
    ) -> Option<&[f32]>;
    pub fn insert(
        &mut self,
        layer: usize,
        op: u8,
        rows: usize,
        cols: usize,
        qtype: crate::model::QType,
        input: &[f32],
        output: Vec<f32>,
    );
}

pub fn cached_mat_vec(
    memo: &mut MatVecMemo,
    out: &mut [f32],
    x: &[f32],
    w: &[u8],
    qtype: crate::model::QType,
    rows: usize,
    cols: usize,
    n_batch: usize,
    out_stride: usize,
    layer: usize,
    op: u8,
    raw_dispatch: fn(&mut [f32], &[f32], &[u8], crate::model::QType, usize, usize, usize, usize),
);

pub fn cached_mat_vec_f32(
    memo: &mut MatVecMemo,
    out: &mut [f32],
    x: &[f32],
    w: &[f32],
    rows: usize,
    cols: usize,
    n_batch: usize,
    out_stride: usize,
    layer: usize,
    op: u8,
    raw_dispatch: fn(&mut [f32], &[f32], &[f32], usize, usize, usize, usize),
);

pub fn cached_mat_vec_f32_with_context(
    memo: &mut MatVecMemo,
    out: &mut [f32],
    x: &[f32],
    w: &[f32],
    rows: usize,
    cols: usize,
    n_batch: usize,
    out_stride: usize,
    layer: usize,
    op: u8,
    context_hash: u64,
    raw_dispatch: fn(&mut [f32], &[f32], &[f32], usize, usize, usize, usize),
);

Foreground wiring: add memo: MatVecMemo to NativeLlamaPipeline, route the Gemma/Qwen chunked and single-token layer matmuls through cached_mat_vec(&mut self.memo, ..., &mat_vec_dispatch_batch), expose memo_enable/memo_set_tau_squared/memo_set_max_entries/memo_clear/memo_stats/memo_detailed_stats in wasm_bindings.rs.

Death #1 hitlist

These are the known matmul surfaces not yet first-class under the memo / resident / durable-cache boundary. Keep this queue ordered by expected Monster impact and only mark an item closed after a focused regression test proves a warm identical input skips or hydrates.

Closed in this pass:

Death #2 — src/amplituhedron.rs

pub struct AmplituhedronCache;

impl AmplituhedronCache {
    pub fn new() -> Self;
    pub fn set_enabled(&mut self, on: bool);
    pub fn set_max_volumes(&mut self, n: usize);
    pub fn clear(&mut self);
    pub fn stats(&self) -> (u64, u64, u64);
    pub fn capture(
        &mut self,
        prefix_hash: u64,
        prefix_len: u32,
        layer_lo: u16,
        layer_hi: u16,
        tail_residual: Vec<f32>,
        kv_slab: Vec<f32>,
    );
    pub fn replay(
        &mut self,
        prefix_hash: u64,
        prefix_len: u32,
        layer_lo: u16,
        layer_hi: u16,
    ) -> Option<(Vec<f32>, Vec<f32>)>;
}

Foreground wiring: add amplituhedron: AmplituhedronCache field to NativeLlamaPipeline. Wasm-bindgen accessors amplituhedron_enable / set_max_volumes / clear / stats / capture / replay. The capture/replay paths know the live KV layout (in model.rs); the cache itself is layout-agnostic — it just stores and returns Vec<f32>.

Death #3 — TS-only, no Rust module

See ./AEON_FLOW_TRANSPORT_PLAN.md. Surface change is in the worker handlers (apps/worker-node1/src/index.ts) and bench coordinator (scripts/bench-trisplit.ts). No wasm_bindings.rs changes.

Death #4 — src/octonion.rs (TBD)

Plan: ./open-source/gnosis/distributed-inference/OCTONION_ROUTING_PLAN.md. Surface to be defined when implementation starts; reserve the file path so the standalone-module discipline holds.

StructuralErrorgle-author rule for model.rs and wasm_bindings.rs

These two files are integration points. Only the foreground session edits them, and only after every standalone module declared above has compiled in isolation. Subagents that need integration-time changes return text patches; the foreground applies them serially.

If a future session finds either file regressed (struct missing, accessor missing), check git diff against the committed baseline and re-apply from the standalone modules. Don't assume in-flight subagents will preserve them.