CORRECTION to D1.1: ndarray::hpc::jitson_cranelift already ships JitEngine

User asked "I presume you are aware of cranelift/jitson" — honest
answer: Cranelift generally yes (Bytecode Alliance, wasmtime),
ndarray-side jitson engine specifically NO. Probed it just now.

ndarray already ships the full JIT pipeline:

  src/hpc/jitson/            — JITSON template format (JSON-based):
    parser / validator / template / precompile / scan_config /
    packed / noise
  src/hpc/jitson_cranelift/  — Cranelift engine:
    engine.rs (JitEngine + JitEngineBuilder)
    ir.rs / scan_jit.rs / noise_jit.rs / detect.rs

Deps behind `jit-native` feature:
  cranelift-codegen 0.116, cranelift-jit, cranelift-module,
  cranelift-frontend, target-lexicon

Upstream two-phase lifecycle is stronger than my D1.1 scaffold:
  BUILD: &mut JitEngine, compile(ScanParams) -> Result<u64>
  RUN:   Arc<JitEngine> freezes by Rust ownership
         &mut self unreachable through Arc
         get() ~5 ns (plain HashMap::get, no synchronization)
         vs my scaffold's ~25 ns RwLock read

The freeze is enforced by the TYPE SYSTEM, not a runtime lock.

The D1.1 scaffold is not redundant — CodecParams (codec-sweep key)
differs from ScanParams (thinking-style-scan key). Generic-over-H
design anticipates D1.1b: the scaffold wraps ndarray's JitEngine
at the H slot when the real engine lands. But my RwLock lifecycle
is worse than the Arc-freeze upstream uses.

Revised D1.1b plan (STATUS_BOARD updated):

  CodecKernelEngine mirroring ndarray's BUILD/RUN pattern:

    pub struct CodecKernelEngine {
        inner: ndarray::hpc::jitson_cranelift::JitEngine,
        codec_sig_to_inner_id: HashMap<u64, u64>,
    }
    .build() -> Builder
    .compile(&mut self, &CodecParams) -> Result<u64>
    .freeze(self) -> Arc<Self>       // moves to RUN phase
    .get(&self, &CodecParams) -> Option<KernelHandle>

  Target ~250 LOC; JitEngine itself is DONE upstream. What's left
  is the CodecParams adapter + codec-specific JITSON template
  (CodecScanParams struct OR direct JSON emission from CodecParams).

D1.1 scaffold stays as StubKernel-backed test fixture. The
generic-over-H design is the wedge that lets both coexist.

EPIPHANIES.md PREPEND: "CORRECTION to D1.1 scaffold".
STATUS_BOARD.md: D1.1b description updated to cite the real upstream
surface + revised ~250 LOC target + path to jitson_cranelift/engine.rs.

Honesty landed explicitly so next session doesn't repeat the
"guess at upstream surface" failure mode.

https://claude.ai/code/session_01SbYsmmbPf9YQuYbHZN52Zh

Author: claude

.claude/board/EPIPHANIES.md

@@ -65,6 +65,84 @@ stay as historical references.
 
 ## Entries (reverse chronological)
 
+## 2026-04-20 — CORRECTION to D1.1 scaffold: ndarray::hpc::jitson_cranelift already ships JitEngine
+
+**Status:** FINDING / CORRECTION
+
+The D1.1 `CodecKernelCache` scaffold (RwLock + double-check) is
+strictly worse than what ndarray's `jitson_cranelift::JitEngine`
+already provides. Real upstream:
+
+```
+/home/user/ndarray/src/hpc/
+  ├── jitson/           — JITSON template format (parser/validator/
+  │                        template/precompile/scan_config/packed/noise)
+  └── jitson_cranelift/ — real Cranelift engine
+      ├── engine.rs     — JitEngine + JitEngineBuilder
+      ├── ir.rs         — IR emission
+      ├── scan_jit.rs   — scan kernel codegen
+      ├── noise_jit.rs  — noise kernel codegen
+      └── detect.rs     — CPU capability detection
+```
+
+Dependencies behind `jit-native` feature:
+`cranelift-{codegen, jit, module, frontend} 0.116` + `target-lexicon`.
+
+**Upstream two-phase lifecycle is stronger than my scaffold:**
+
+- **BUILD phase:** `&mut JitEngine`, `compile(ScanParams) -> Result<u64>`,
+  mutable cache via `&mut self`.
+- **RUN phase:** `Arc<JitEngine>` freezes the cache by Rust's ownership
+  (`&mut self` unreachable through `Arc`). `get()` drops from
+  ~25 ns (my RwLock read) to ~5 ns (plain `HashMap::get`, no
+  synchronization needed).
+
+The freeze is enforced by the type system, not by a runtime lock.
+That's the right design for this domain (build-once, run-many).
+
+**What the D1.1 scaffold is still good for:** `CodecParams` is the
+codec-sweep key; `ScanParams` is ndarray's thinking-style-scan key.
+Different domains; a `CodecParams`-keyed adapter layer is still
+needed. My generic-over-handle design anticipates this — the
+scaffold wraps ndarray's `JitEngine` at the `H` slot when D1.1b
+lands.
+
+**Revised D1.1b plan:**
+
+Mirror ndarray's two-phase pattern in `cognitive-shader-driver`:
+
+```rust
+// BUILD phase — mutable, single-threaded
+pub struct CodecKernelEngine {
+    inner: ndarray::hpc::jitson_cranelift::JitEngine,
+    codec_sig_to_inner_id: HashMap<u64, u64>,  // CodecParams signature → JitEngine id
+}
+
+// RUN phase — frozen via Arc
+impl CodecKernelEngine {
+    pub fn build() -> CodecKernelEngineBuilder { ... }
+    pub fn compile(&mut self, params: &CodecParams) -> Result<u64, JitError>;
+    pub fn freeze(self) -> Arc<Self>;  // moves to RUN phase
+    pub fn get(&self, params: &CodecParams) -> Option<KernelHandle>;
+}
+```
+
+Then D1.2/D1.3 call `inner.compile` with codec-specific
+`ScanParams`-analogs (new `CodecScanParams` struct or a JITSON
+template constructed from `CodecParams`).
+
+**Honesty note:** user asked "I presume you are aware of
+cranelift/jitson" — answer is: Cranelift yes (Bytecode Alliance,
+wasmtime), ndarray jitson NO (didn't inspect the upstream surface
+before writing D1.1). This correction surfaces that gap explicitly
+so the next session doesn't repeat it.
+
+**Cross-ref:** D1.1 `crates/cognitive-shader-driver/src/codec_kernel_cache.rs`
+(keep as `StubKernel`-backed test fixture); `ndarray::hpc::jitson_cranelift::JitEngine`;
+D1.1b revised plan above.
+
+---
+
 ## 2026-04-20 — D1.1 scaffold-before-codegen: cache semantics testable without Cranelift
 
 **Status:** FINDING

.claude/board/STATUS_BOARD.md

@@ -62,7 +62,7 @@ afterwards is a JIT kernel, not a rebuild. Plan path:
 | D-id | Title | Status | PR / Evidence |
 |---|---|---|---|
 | D1.1 | `CodecKernelCache` — structural cache layer (generic over handle) | **In PR** | branch — `CodecKernelCache<H>` + `StubKernel` + `get_or_compile` / `try_get_or_compile` with RwLock concurrent-safe double-check + compile/hit/ratio counters + 9 tests. Scaffold ships NOW; D1.1b Cranelift IR emission follows. |
-| D1.1b | Cranelift IR emission (plugs the real `KernelHandle` into the cache from D1.1) | **Queued** | target ~180 LOC once ndarray's jitson engine exposes the compile entry |
+| D1.1b | Adapter: `CodecKernelEngine` wrapping `ndarray::hpc::jitson_cranelift::JitEngine` with two-phase BUILD/RUN lifecycle (Arc-freeze). CodecParams → CodecScanParams adapter + codec-specific IR emission in jitson_cranelift/scan_jit analog | **Queued** | target ~250 LOC; `JitEngine` already ships (`/home/user/ndarray/src/hpc/jitson_cranelift/engine.rs`); the work is the CodecParams adapter + codec-specific JITSON template |
 | D1.2 | Rotation primitives: Identity / Hadamard / OPQ as JIT kernels | **Queued** | target ~190 LOC |
 | D1.3 | Residual PQ via JIT composition | **Queued** | target ~150 LOC |