diff --git a/CURRENT_TASK.md b/CURRENT_TASK.md
index b46a0e7b..db761e9d 100644
--- a/CURRENT_TASK.md
+++ b/CURRENT_TASK.md
@@ -1,5 +1,19 @@
 # Current Task — Phase 21.8（Numeric Core Integration & Builder Support）
 
+Update (2025-11-14 — Phase 21.8 wrap-up: builder/importsまでで一旦クローズ)
+- Status:
+  - Phase 21.8 は「Stage‑B / Bridge / MirBuilder への IntArrayCore/MatI64 導線（imports）」まで完了とし、EXE/LLVM ベンチ統合は Phase 25 に移管する。
+- Done in 21.8:
+  - BridgeEnv に `imports: HashMap<String,String>` フィールドを追加し、using 由来の alias 情報を JSON→MIR 変換に渡せるようにした。
+  - `MapVars::resolve` を拡張し、`env.imports` を参照して `MatI64` / `IntArrayCore` などの静的 box 名を「有効な変数」として解決できるようにした。
+  - `parse_json_v0_to_module_with_imports` / `program_json_to_mir_json_with_imports` を導入し、Program(JSON v0)→MIR(JSON) 経路が imports マップを受け取れるようにした。
+  - `collect_using_and_strip` の戻り値を `(cleaned, prelude_paths, imports)` に拡張し、using から alias 一覧を収集できるようにした（既存呼び出しは `_imports` として無視し、挙動不変）。
+  - `HAKO_MIRBUILDER_IMPORTS` 経由で imports を Rust 側 MirBuilder へ渡す読み取り側の配線を追加（env.mirbuilder.emit ルート）。
+- Deferred to Phase 25:
+  - `matmul_core` microbench の EXE/LLVM 統合（MatI64/IntArrayCore を LLVM ラインで実行可能にする設計と実装）。
+  - Numeric core AOT ライン（Ring1 numeric runtime を .hako 実装＋汎用 `ExternCall`/numeric ABI 経由で LLVM に乗せる設計）。
+  - これらの後続タスクは `docs/development/roadmap/phases/phase-25/README.md` に移し、Ring0/Ring1 再編フェーズ（Phase 25）の一部として扱う。
+
 Update (2025-11-14 — 21.8 kickoff: MatI64/IntArrayCore builder integration)
 - Context:
   - 21.5: AotPrep/CollectionsHot v1 + microbench整備まで完了（linidx/maplin ≒ C=100%）。arraymap/matmul は次フェーズ送り。
diff --git a/crates/nyash_kernel/src/plugin/intarray.rs b/crates/nyash_kernel/src/plugin/intarray.rs
index 4c535d1d..c4f9a010 100644
--- a/crates/nyash_kernel/src/plugin/intarray.rs
+++ b/crates/nyash_kernel/src/plugin/intarray.rs
@@ -68,7 +68,7 @@ impl BoxCore for IntArrayCore {
     }
 
     fn fmt_box(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "IntArrayCore(len={})", self.data.len())
+        write!(f, "IntArrayCore(len={})", self.data.read().unwrap().len())
     }
 
     fn as_any(&self) -> &dyn Any {
@@ -82,12 +82,12 @@ impl BoxCore for IntArrayCore {
 
 impl NyashBox for IntArrayCore {
     fn to_string_box(&self) -> StringBox {
-        StringBox::new(&format!("IntArrayCore(len={})", self.data.len()))
+        StringBox::new(&format!("IntArrayCore(len={})", self.data.read().unwrap().len()))
     }
 
     fn equals(&self, other: &dyn NyashBox) -> BoolBox {
         if let Some(o) = other.as_any().downcast_ref::<IntArrayCore>() {
-            BoolBox::new(self.data == o.data)
+            BoolBox::new(*self.data.read().unwrap() == *o.data.read().unwrap())
         } else {
             BoolBox::new(false)
         }
@@ -115,19 +115,19 @@ fn get_core(handle: i64) -> Option<std::sync::Arc<dyn NyashBox>> {
     handles::get(handle as u64)
 }
 
-#[export_name = \"nyash.intarray.new_h\"]
-pub extern \"C\" fn nyash_intarray_new_h(len: i64) -> i64 {
+#[export_name = "nyash.intarray.new_h"]
+pub extern "C" fn nyash_intarray_new_h(len: i64) -> i64 {
     let core = IntArrayCore::new(len);
     let arc: std::sync::Arc<dyn NyashBox> = std::sync::Arc::new(core);
     let h = handles::to_handle_arc(arc) as i64;
-    if std::env::var(\"NYASH_CLI_VERBOSE\").ok().as_deref() == Some(\"1\") {
-        eprintln!(\"[INTARRAY] new_h(len={}) -> handle={}\", len, h);
+    if std::env::var("NYASH_CLI_VERBOSE").ok().as_deref() == Some("1") {
+        eprintln!("[INTARRAY] new_h(len={}) -> handle={}", len, h);
     }
     h
 }
 
-#[export_name = \"nyash.intarray.len_h\"]
-pub extern \"C\" fn nyash_intarray_len_h(handle: i64) -> i64 {
+#[export_name = "nyash.intarray.len_h"]
+pub extern "C" fn nyash_intarray_len_h(handle: i64) -> i64 {
     if let Some(obj) = get_core(handle) {
         if let Some(core) = obj.as_any().downcast_ref::<IntArrayCore>() {
             return core.len_i64();
@@ -136,8 +136,8 @@ pub extern \"C\" fn nyash_intarray_len_h(handle: i64) -> i64 {
     0
 }
 
-#[export_name = \"nyash.intarray.get_hi\"]
-pub extern \"C\" fn nyash_intarray_get_hi(handle: i64, idx: i64) -> i64 {
+#[export_name = "nyash.intarray.get_hi"]
+pub extern "C" fn nyash_intarray_get_hi(handle: i64, idx: i64) -> i64 {
     if let Some(obj) = get_core(handle) {
         if let Some(core) = obj.as_any().downcast_ref::<IntArrayCore>() {
             if let Some(v) = core.get_i64(idx) {
@@ -148,8 +148,8 @@ pub extern \"C\" fn nyash_intarray_get_hi(handle: i64, idx: i64) -> i64 {
     0
 }
 
-#[export_name = \"nyash.intarray.set_hii\"]
-pub extern \"C\" fn nyash_intarray_set_hii(handle: i64, idx: i64, val: i64) -> i64 {
+#[export_name = "nyash.intarray.set_hii"]
+pub extern "C" fn nyash_intarray_set_hii(handle: i64, idx: i64, val: i64) -> i64 {
     if let Some(obj) = get_core(handle) {
         if let Some(core) = obj.as_any().downcast_ref::<IntArrayCore>() {
             return if core.set_i64(idx, val) { 0 } else { 1 };
diff --git a/docs/development/roadmap/phases/phase-21.8/README.md b/docs/development/roadmap/phases/phase-21.8/README.md
index 40e30a36..84556a78 100644
--- a/docs/development/roadmap/phases/phase-21.8/README.md
+++ b/docs/development/roadmap/phases/phase-21.8/README.md
@@ -1,17 +1,17 @@
 # Phase 21.8 — Numeric Core Integration & Builder Support
 
-Status: proposal (to hand off to Claude Code)
+Status: partially completed（builder/imports導線まで・EXEベンチはPhase 25へ移管）
 
 ## Goal
 
 Integrate the new numeric core boxes (IntArrayCore + MatI64) into the Hakorune selfhost chain so that:
 
-- Stage‑B → MirBuilder → ny‑llvmc(crate) can emit MIR(JSON) and EXE for code that uses:
+- Stage‑B → MirBuilder → ny‑llvmc(crate) can emit MIR(JSON) for code that uses:
   - `using nyash.core.numeric.intarray as IntArrayCore`
   - `using nyash.core.numeric.matrix_i64 as MatI64`
-- The `matmul_core` microbench (MatI64 + IntArrayCore) runs end‑to‑end in EXE mode and can be compared fairly against a matching C implementation.
+- The `matmul_core` microbench（MatI64 + IntArrayCore）については、**構造的な導線（builder/imports）まで本フェーズで整備し、EXE/LLVM ベンチ統合は Phase 25 に移管する**。
 
-21.6 provides the core boxes; 21.8 focuses on wiring them into the builder/runtime chain without changing default behaviour for other code.
+21.6 provides the core boxes; 21.8 focuses on wiring them into the builder/runtime chain（Stage‑B/Bridge/MirBuilder）without changing default behaviour for other code. LLVM での数値コア実行経路は Phase 25（Ring0/Ring1 再編・numeric runtime AOT）で扱う。
 
 ## Scope (21.8, this host)
 
@@ -73,13 +73,33 @@ Out of scope:
 
 4) **Keep existing behaviour stable**
    - No changes to default user behaviour, env toggles, or existing benches beyond adding `matmul_core`.
-   - Ensure quick/profile smokes (where applicable) remain green with numeric core present.
+  - Ensure quick/profile smokes (where applicable) remain green with numeric core present.
 
-## Notes
+## 結果（2025-11-14 時点）
 
-- 21.6 already introduced:
-  - NyRT `IntArrayCore` (Vec<i64> + RwLock) and handle‑based externs (`nyash.intarray.*`).
-  - Hako wrappers `IntArrayCore` and `MatI64` in `lang/src/runtime/numeric/`.
-  - `nyash.toml` module aliases for `nyash.core.numeric.intarray` and `nyash.core.numeric.matrix_i64`.
-- 21.8 is about wiring these into the builder/emit chain so that Hakorune can compile and benchmark numeric core code end‑to‑end.
+本フェーズは「builder/imports 導線の整備」までを完了とし、EXE/LLVM ベンチ統合は Phase 25 に移管する。
 
+**達成済み（21.8）**
+
+- Stage‑B / Bridge / MirBuilder:
+  - `BridgeEnv` に `imports: HashMap<String,String>` フィールドを追加し、using 由来のエイリアス情報（alias → box_type）を保持できるようにした。
+  - `MapVars::resolve` を拡張し、`env.imports` を参照して `MatI64` / `IntArrayCore` などの using エイリアスを「静的 box 参照」として MIR 上で解決できるようにした。
+  - JSON v0 → MIR(JSON) 経路に `*_with_imports` 版を追加:
+    - `runner::json_v0_bridge::parse_json_v0_to_module_with_imports`
+    - `host_providers::mir_builder::program_json_to_mir_json_with_imports`
+  - `HAKO_MIRBUILDER_IMPORTS` 環境変数を経由して、Stage‑B 側で収集した imports を Rust 側の MirBuilder に渡す配線を追加（読み取り側）。
+- Using / imports 収集:
+  - `collect_using_and_strip` の戻り値を `(cleaned, prelude_paths, imports)` に拡張し、using から alias 情報を収集できるようにした。
+  - 既存呼び出し側は `_imports` として無視するため、従来挙動は維持。
+- MatI64/IntArrayCore:
+  - `using nyash.core.numeric.matrix_i64 as MatI64` / `using nyash.core.numeric.intarray as IntArrayCore` の構文が Stage‑B/Bridge で undefined variable エラーにならないところまで確認済み（builder 経路に乗る）。
+
+**未完・移管（Phase 25 に送るもの）**
+
+- `matmul_core` microbench の EXE/LLVM 統合:
+  - MIR 上では `MatI64` が BoxCall として現れるが、LLVM ラインには BoxCall 実行経路がなく、AotPrep も MatI64 向けの書き換えを持たない。
+  - 「MatI64/IntArrayCore を LLVM までどう運ぶか」（numeric ABI / AotPrep / Ring1 AOT 設計）は、Phase 25「脱Rustランタイム / Ring0-Ring1再編」で扱う。
+- Numeric core AOT ライン:
+  - IntArrayCore/MatI64 の実装を `.hako`（Ring1）側に寄せ、LLVM からは汎用 `ExternCall`/numeric ABI のみを見る構造は Phase 25 の設計スコープとする。
+
+詳細な将来計画・numeric runtime AOT 方針については `docs/development/roadmap/phases/phase-25/README.md` を参照。
diff --git a/docs/development/roadmap/phases/phase-25/README.md b/docs/development/roadmap/phases/phase-25/README.md
index 3ed1be70..897cb541 100644
--- a/docs/development/roadmap/phases/phase-25/README.md
+++ b/docs/development/roadmap/phases/phase-25/README.md
@@ -40,6 +40,14 @@ Status: proposal（設計フェーズ・実装は後続ホスト想定）
 - 箱のフィールド管理（ptr+len+stride）、境界チェック、ループ本体、行列演算アルゴリズムなどは **すべて .hako 側で記述**。
 - Ring1 コードは AOT して `stdlib` 相当の成果物（例: `stdlib.hbc`）として VM 起動時にロードする構造を目指す。
 
+### Rust ソースの保存ポリシー
+
+- 本フェーズは **Rust コードの削除ではなく、責務の縮退と凍結** を目的とする。
+- `src/` 以下の Ring0 Rust ソース（VM コア / LLVM・OS FFI / 起動コード）は、将来もブートストラップ用としてリポジトリに残す前提とする。
+- 脱Rustが進み、将来 Hakorune EXE 単独で自己ホスト可能になっても:
+  - Ring0 Rust は「アーカイブ兼非常用バックアップ」として保持する。
+  - 削除や完全な Rust 依存断絶は、別フェーズ（かつ明示的な設計・合意）なしには行わない。
+
 ## スコープ（Phase 25）
 
 Phase 25 は「設計とロードマップの確定」が主目的。実装・移行作業自体は後続フェーズ（22.x/26.x など）で分割実施する。
@@ -69,16 +77,136 @@ Phase 25 は「設計とロードマップの確定」が主目的。実装・
     など、小さな intrinsic 群に縮退。
 - タスク（設計レベル）:
   - 必要な intrinsic セットの定義（型・エラー処理ポリシー・Fail‑Fast方針）。
-  - `nyash.core.numeric.intarray` の API 仕様と内部構造（ptr+len/所有権/ライフサイクル）を docs に固定。
+  - `nyash.core.numeric.intarray` / `nyash.core.numeric.matrix_i64` の API 仕様と内部構造（ptr+len/rows/cols/stride/所有権/ライフサイクル）を docs に固定。
+    - Box レベルの仕様: `lang/src/runtime/numeric/README.md` に IntArrayCore / MatI64 のフィールド・メソッド契約を記述。
+    - Core / Handle レベルの仕様: 本ファイルおよび System Hakorune subset / numeric ABI ドキュメントで補完。
   - MatI64 が IntArrayCore をどう利用するか（row-major/stride/ビューなど）を整理。
 
+#### 2.1) Numeric ABI（IntArrayCore / MatI64）の詳細方針
+
+**ゴール:**
+
+- MatI64 / IntArrayCore のような数値箱を LLVM まで運ぶ際に、「箱の知識」は Ring1 に閉じ込め、Ring0（Rust+LLVM）は汎用的な `Call` / `ExternCall` しか知らなくて済む構造にする。
+
+**基本方針:**
+
+- BoxCall を LLVM まで持ち込まない:
+  - LLVM に渡す最終 MIR には、原則として:
+    - `Const / BinOp / Compare / Branch / Jump / Ret`
+    - `Call`（通常の関数呼び出し）
+    - `ExternCall`（NyRT / 低レベル intrinsic 呼び出し）
+    - `NewBox`（必要最小限）
+  - `BoxCall(MatI64, ...)` や `BoxCall(IntArrayCore, ...)` は AotPrep で潰す。
+- 箱の構造・都合は Ring1 で完結させる:
+  - MatI64 / IntArrayCore のフィールド構造やメソッドは Ring1 が知るだけでよい。
+  - Ring0/LLVM から見ると「固定 ABI の関数呼び出し」に見えるようにする。
+
+**Ring1 側の責務: numeric ABI 定義とラッパー**
+
+- IntArrayCore / MatI64 向けに固定された numeric ABI 関数セットを定義する（例・概念レベル）:
+  - `ny_numeric_intarray_new(len: i64) -> IntArrayHandle`
+  - `ny_numeric_intarray_get(a: IntArrayHandle, idx: i64) -> i64`
+  - `ny_numeric_intarray_set(a: IntArrayHandle, idx: i64, v: i64)`
+  - `ny_numeric_mat_i64_new(rows: i64, cols: i64) -> MatI64Handle`
+  - `ny_numeric_mat_i64_mul_naive(a: MatI64Handle, b: MatI64Handle, n: i64) -> MatI64Handle`
+- 具体的な関数一覧・事前条件・Fail‑Fast 方針は `docs/development/runtime/NUMERIC_ABI.md` に整理する。
+- 実装:
+  - Phase 25 の段階では、これらを **Ring1 の通常の Hako 関数** として実装し、MIR 上では `Call` 命令として現れる形を基本とする。
+  - 将来、別バイナリや C 実装に差し替える場合のみ、同じ関数群を ExternCall/FFI 経由で公開する案を検討する（Phase 26 以降）。
+  - これらの関数名・引数型を「numeric ABI」として docs に固定する。
+- MatI64 / IntArrayCore Box メソッドは「numeric ABI の薄ラッパ」として実装する:
+  - 例: `MatI64.mul_naive(self, rhs, n)` の本体は Ring1 numeric core 関数（例: `NyNumericMatI64.mul_naive(self, rhs, n)`）を 1 回呼ぶだけ。
+  - VM/インタープリタライン: BoxCall をそのまま実行すればラッパ経由で numeric core に到達する。
+  - AOT/LLVM ライン: BoxCall を numeric core 関数への `Call` に書き換えるだけで済む（BoxCall を LLVM まで持ち込まない）。
+
+**BoxCall → Call（numeric core）変換（AotPrep / builder の責務）**
+
+- 初期 MIR では `BoxCall(MatI64, "new", ...)` や `BoxCall(MatI64, "mul_naive", ...)` が現れる。
+- Ring1 の AotPrep パスで、これらを numeric core 関数への `Call` に変換する計画とし、Phase 25 ではそのための診断パス（`AotPrepNumericCoreBox`）を用意する:
+  - 例（概念レベル）:
+    - `BoxCall(MatI64, "new",  ...)` → `Call NyNumericMatI64.new_core(...)`
+    - `BoxCall(MatI64, "mul_naive", ...)` → `Call NyNumericMatI64.mul_naive(...)`
+- これらは一時しのぎのハードコードではなく、Ring1 numeric ランタイムの正規インターフェースとして docs に固定する（実際の書き換えは後続フェーズで実装）。
+- 拡張性:
+  - 可能なら「Box 型ID + メソッドID → numeric core 関数 ID」のテーブルで持つ（メタデータ化）。
+  - 少なくとも `MatI64` / `IntArrayCore` を識別する Box 型IDを見てから変換する方針にする（文字列 if の乱立を避ける）。
+
+**Ring0 側の責務: 汎用 Call/ExternCall のみ**
+
+- LLVM backend は汎用的な `Call` / `ExternCall` のコード生成のみ実装する。
+  - `Call` → Hako から生成された通常の関数呼び出しに変換（numeric core 関数もここに含まれる）。
+  - `ExternCall` → NyRT / OS / C など「Hakorune 外部」の FFI だけを扱う（`rt_mem_alloc_i64` 等）。
+- Ring0 は「MatI64 という箱がある」「IntArrayCore という型がある」といった情報を持たない。
+  - numeric core について知っているのは「`Call @ny_numeric_*` という形の関数が存在する」という事実だけであり、Box 型や内部フィールド構造は Ring1 に閉じ込める。
+
+**Handle / Core の設計ポリシー（概念レベル）**
+
+- `IntArrayHandle` / `MatI64Handle` は実質 Core 構造を指すものとして扱う:
+  - 例: `struct IntArrayCore { i64* ptr; i64 len; };`
+    - `struct MatI64Core { i64* ptr; i64 rows; i64 cols; i64 stride; };`
+- Box 側（MatI64 Box）はこれら Core をラップするだけにする。
+- GC を導入する場合、numeric Core は pinned / non‑moving 領域または明示的 malloc/free 管理とし、Box→Core の所有権・ライフサイクルを Ring1 側で管理する。
+
+**ABI 関数セット（初期案の固定方針）**
+
+- IntArrayCore（1 次元 i64 配列）:
+  - `ny_numeric_intarray_new(len: i64) -> (IntArrayHandle)`  
+    - 役割: 長さ `len` のゼロ初期化配列を確保する。
+    - 失敗時: OOM など致命的エラーは Fail‑Fast（プロセス終了または未定義だが「静かに 0 を返す」等は禁止）。
+  - `ny_numeric_intarray_free(a: IntArrayHandle)`  
+    - 役割: Core を解放する（多重 free は未定義とし、Ring1 側の所有権設計で防ぐ）。
+  - `ny_numeric_intarray_len(a: IntArrayHandle) -> i64`  
+    - 役割: 現在の長さを返す（境界チェック不要）。
+  - `ny_numeric_intarray_get(a: IntArrayHandle, idx: i64) -> i64`  
+    - 役割: `0 <= idx < len` を前提とした読み取り。範囲外は Fail‑Fast。
+  - `ny_numeric_intarray_set(a: IntArrayHandle, idx: i64, v: i64)`  
+    - 役割: `0 <= idx < len` を前提とした書き込み。範囲外は Fail‑Fast。
+
+- MatI64（2 次元 i64 行列; row‑major）:
+  - `ny_numeric_mat_i64_new(rows: i64, cols: i64) -> (MatI64Handle)`  
+    - 役割: 行列本体を `rows * cols` 要素で確保し、ゼロ初期化する。
+  - `ny_numeric_mat_i64_free(m: MatI64Handle)`  
+    - 役割: Core を解放する（所有権は Box 側が管理）。
+  - `ny_numeric_mat_i64_dims(m: MatI64Handle) -> (rows: i64, cols: i64)`  
+    - 役割: 行数・列数を返す（構造検査用）。
+  - `ny_numeric_mat_i64_get(m: MatI64Handle, row: i64, col: i64) -> i64`  
+    - 役割: `0 <= row < rows`, `0 <= col < cols` を前提とした読み取り。範囲外は Fail‑Fast。
+  - `ny_numeric_mat_i64_set(m: MatI64Handle, row: i64, col: i64, v: i64)`  
+    - 役割: 上記と同じ前提の書き込み。範囲外は Fail‑Fast。
+  - `ny_numeric_mat_i64_mul_naive(a: MatI64Handle, b: MatI64Handle, n: i64) -> MatI64Handle`  
+    - 役割: `n x n` 行列同士のナイーブな行列積。`n` と `dims` の不整合は Fail‑Fast（ベンチ用の前提エラーは早期に止める）。
+
+**ABI 型と呼び出し規約（概念レベル）**
+
+- `IntArrayHandle` / `MatI64Handle` は LLVM / C 側では「Core 構造体を値渡しする ABI」として扱う案を第一候補とする:
+  - C 側イメージ（proposal）:
+    - `typedef struct { int64_t *ptr; int64_t len; } ny_intarray_handle;`
+    - `typedef struct { int64_t *ptr; int64_t rows; int64_t cols; int64_t stride; } ny_mat_i64_handle;`
+  - MIR から見ると「2 〜 4 個の `i64` をまとめた値」として ExternCall の引数/戻り値に現れる。
+  - 将来、GC 等でハンドルをテーブル管理に変えたくなった場合も、「ハンドルは ABI 上は i64×N で表現する」という規約だけを維持すればよい。
+- ExternCall 側の型:
+  - `ExternCall` から見える型はすべて `i64` のみとし、「どのスロットが ptr/len/rows/cols か」は numeric ABI 側の約束で固定する。
+  - これにより LLVM backend は「i64 のタプルをそのまま C 関数に渡す」だけで済み、箱/行列の構造を知らなくてよい。
+
+**エラー処理と Fail‑Fast ポリシー**
+
+- OOM / 致命的エラー:
+  - numeric ABI レベルでは「戻り値でのエラー表現」は行わず、Fail‑Fast を原則とする（プロセス終了 or 例外経路など、実装詳細は後続フェーズで決める）。
+  - 「負の長さ」「rows*cols のオーバーフロー」など明らかなバグ入力も Fail‑Fast。
+- 境界違反:
+  - `*_get` / `*_set` / `*_mul_naive` など、index/dims に依存する API は **事前条件を満たさない呼び出しをすべてバグ扱い** とし、Fail‑Fast する。
+  - 「エラーコードを返して上層で if する」スタイルは禁止（AGENTS.md の対処療法禁止と揃える）。
+- Box 側との責務分離:
+  - Box メソッドは「precondition を満たすように引数を構成して numeric ABI を呼ぶ」責務のみを持ち、境界チェックの抜けや重複を避ける。
+  - numeric ABI 側は「precondition 違反を検出したら即 Fail‑Fast」することで、バグを早期発見する。
+
 ### 3) System Hakorune サブセットの定義
 
 - Ring1 で「C 代替」として安全に使える記法/機能を定義:
   - 推奨: 明示ループ（while/for）、Fail‑Fast、Box フィールドの明示管理。
   - 慎重に: 例外/非同期/動的ロードなど、ランタイム依存が重い機能。
-- ドキュメント案:
-  - `docs/development/runtime/system-hakorune-subset.md`（候補）
+- ドキュメント:
+  - `docs/development/runtime/system-hakorune-subset.md`（本ガイド）
   - 想定ユース:
     - numeric core / matrix core
     - runtime policy / stats
@@ -90,11 +218,91 @@ Phase 25 は「設計とロードマップの確定」が主目的。実装・
   - 「Hakorune で書かれた runtime/numeric コード」を AOT して、VM 起動時に一括ロードする仕組みを設計。
 - 方針案:
   - `tools/hakc_stdlib.sh`（仮）で:
-    - `lang/src/runtime/**/*.hako` のうち Ring1 対象をコンパイルして `build/stdlib.hbc` を生成。
+    - `lang/src/runtime/**/*.hako` のうち Ring1 対象（特に `lang/src/runtime/numeric/` 以下）をコンパイルして `build/stdlib.hbc` を生成。
   - `hakorune` / `nyash` バイナリ起動時に:
     - `stdlib.hbc` を自動ロード（PATH または env で切り替え）。
   - Phase 25 では「どのモジュールを stdlib に含めるか」「ビルド/ロードの責任境界」を文章で決めるところまで。
 
+### 5) stdlib モードと衝突回避ポリシー（embedded / source）
+
+- 目的:
+  - IntArrayCore / MatI64 など、同じモジュール名を持つ数値箱が「埋め込み stdlib」と「開発中 .hako ソース」で二重定義されて衝突しないようにする。
+- 方針:
+  - `nyash.core.numeric.*` 系モジュールは **stdlib 専用の名前空間**として扱い、1 度の実行中に有効な実装は常に 1 つだけとする。
+  - 実装の SSOT は `.hako` とし、埋め込みは「その時点の .hako を AOT した成果物」としてのみ存在させる（別実装は持たない）。
+- モード案（env ベースの切替; 名前は Phase 26 以降で最終決定）:
+  - `NYASH_STDLIB_MODE=embedded`（デフォルト候補）:
+    - 起動時に `stdlib.hbc` をロードし、`nyash.core.numeric.*` は埋め込み stdlib から提供。
+    - 同じモジュール名をファイルで定義しても、原則として無視 or 警告（開発時のみ許可）とし、実行時には埋め込み版だけが有効になる。
+  - `NYASH_STDLIB_MODE=source`（開発専用候補）:
+    - `stdlib.hbc` をロードせず、Stage‑B/VM が `lang/src/runtime/numeric/*.hako`（など）を直接コンパイルして runtime/numeric を提供。
+    - このモードでは埋め込み stdlib は無効化され、`.hako` ソースでのみ挙動が決まる。
+- 利点:
+  - 本番/ベンチでは embedded モードで安定した numeric stdlib を使用できる。
+  - 開発時は source モードで IntArrayCore/MatI64 の `.hako` を編集しながら試せる。
+  - 「同じ名前の箱が2つ同時に有効になる」状態を構造的に防げる。
+
+## 実装チェックリスト（Phase 25 以降で順番にやる）
+
+Phase 25 自体は設計フェーズだが、後続フェーズ（22.x / 26.x など）で実装を進める際のチェックリストをここにまとめておく。
+
+### A. 設計・ドキュメント
+
+- [ ] Rust Freeze（ランタイム/箱/数値系）の詳細ポリシーを docs に固定する。
+  - [ ] 「新しい箱・数値カーネルは .hako で書く」方針を明文化。
+  - [ ] Ring0 で許可される変更種別（intrinsic 追加 / バグ修正のみ）を列挙。
+- [ ] System Hakorune サブセットのガイド（`docs/development/runtime/system-hakorune-subset.md`）を整備する。
+  - [ ] 使用を推奨する構文/機能（ループ、Fail‑Fast 等）。
+  - [ ] 慎重に扱う機能（例外/非同期/動的ロード 等）。
+- [ ] IntArrayCore / MatI64 の API 仕様と内部構造を docs で固定する。
+  - [ ] フィールド（ptr/len/rows/cols/stride 等）の意味と所有権ポリシー。
+  - [ ] public メソッドとその契約（境界チェック有無、Fail‑Fastポリシー）。
+- [ ] Numeric ABI（`ny_numeric_*`）の関数セットを文書化する。
+  - [ ] 関数名・引数型・戻り値型・エラーハンドリング規約。
+  - [ ] （必要になった場合のみ）C/Rust から呼ぶ際のシンボル名規約を決める。
+
+### B. Ring0（Rust）側の最小実装
+
+- [ ] 既存ランタイムに不足している最小 intrinsic を確認し、必要なら追加する。
+  - [ ] `rt_mem_alloc_i64(len) -> (ptr,len)`
+  - [ ] `rt_mem_free_i64(ptr,len)`
+  - [ ] `rt_unsafe_load_i64(ptr, idx)`
+  - [ ] `rt_unsafe_store_i64(ptr, idx, val)`
+- [ ] LLVM backend が既存の `ExternCall` メカニズムで Ring0 intrinsic（`rt_mem_*` 等）を扱えることを確認する。
+  - [ ] numeric 用に特別な分岐を追加せず、必要なら共通の規約ベースでシンボル名を組み立てる。
+
+### C. Ring1（.hako）側 numeric runtime
+
+- [ ] `nyash.core.numeric.intarray` を Ring1 実装に移行する。
+  - [ ] IntArrayCore を `.hako` で実装（ptr+len 管理 / get/set/fill 等）。
+  - [ ] 内部で Ring0 intrinsic（alloc/free/load/store）を使用する。
+  - [ ] 既存の Rust プラグイン実装との整合性を確認し、最終的に Rust 実装を縮退 or 退役できるようにする。
+- [ ] `nyash.core.numeric.matrix_i64`（MatI64）を numeric ABI ベースのラッパ Box に整える。
+  - [ ] フィールドに Core ハンドル（MatI64Handle）を持つ構造に整理。
+  - [ ] `new/at/set/mul_naive` などのメソッド本体を Ring1 numeric core 関数（通常の Hako 関数）呼び出しに寄せる。
+- [ ] Numeric ABI 関数群（`ny_numeric_intarray_*` / `ny_numeric_mat_i64_*`）を `.hako` で実装し、AOT 可能な状態にする。
+
+### D. AotPrep / builder 経路
+
+- [ ] `BoxCall(MatI64, ...)` / `BoxCall(IntArrayCore, ...)` を Ring1 numeric core 関数への通常 `Call` に変換する AotPrep パスを設計する（Phase 25 では診断パスまで、実際の変換は後続フェーズ）。
+  - [ ] Box 型ID / メソッド名から numeric core 関数 ID にマップする表（メタ）を用意（対処療法的な文字列 if の乱立を避ける）。
+- [ ] 変換後の MIR から `BoxCall` が LLVM ラインには残らないことを確認。
+- [ ] imports / using 経路（Phase 21.8 で導入済み）を再確認し、MatI64/IntArrayCore の静的参照が安定して解決されることを確認。
+
+### E. stdlib ビルド／ロード
+
+- [ ] `lang/src/runtime/numeric/*.hako` を含む Ring1 モジュールを AOT して `stdlib.hbc`（仮）にまとめるビルドスクリプト（設計どおりなら `tools/hakc_stdlib.sh` 相当）を用意する。
+- [ ] `hakorune` / `nyash` 起動時に `stdlib.hbc` をロードする導線を設計し、Ring0 に最小限のフックを追加する。
+- [ ] VM/LLVM 両ラインで numeric runtime が利用できるかを確認する（どちらも BoxCall→Call(numeric core) の同一 MIR を実行する）。
+
+### F. 検証・移行
+
+- [ ] 代表的な数値ベンチ（`matmul_core` など）を:
+  - [ ] VM ライン（BoxCall 経路）で確認。
+  - [ ] LLVM ライン（numeric ABI 経路）で確認。
+- [ ] 21.x の既存ベンチが regression していないことを確認する（数値系以外は挙動不変）。
+- [ ] Rust 側の IntArrayCore plugin 実装を「縮退 or optional 化」するタイミングと手順を docs に追記する。
+
 ## アウト・オブ・スコープ（Phase 25）
 
 - 実際のコード移行（Rust 実装の削除や .hako への完全移植）は、このフェーズでは行わない。
@@ -106,4 +314,3 @@ Phase 25 は「設計とロードマップの確定」が主目的。実装・
 - Rust / Hakorune の責務分離が文書として明確になり、「新しい箱・数値カーネルは .hako で書く」がプロジェクトの合意として固定されている。
 - IntArrayCore / MatI64 の「Rust→Hakorune 移行」手順が、段階ごとのタスクリストとして整理されている。
 - System Hakorune サブセットと stdlib ビルド/ロード戦略のたたき台があり、後続フェーズ（例: Phase 22.x / 26.x）でそのまま実装に着手できる状態になっている。
-
diff --git a/docs/development/runtime/ENV_VARS.md b/docs/development/runtime/ENV_VARS.md
index 42917ca2..1d13fd5f 100644
--- a/docs/development/runtime/ENV_VARS.md
+++ b/docs/development/runtime/ENV_VARS.md
@@ -75,6 +75,11 @@ NYASH_DISABLE_PLUGINS = "1"
 - NYASH_AOT_OBJECT_OUT: AOT パイプラインで使用する `.o` 出力ディレクトリ/パス
 - NYASH_LLVM_USE_HARNESS: "1" で llvmlite ハーネス経路を有効化（MIR(JSON)→Python→.ll→llc→.o）
 
+## AotPrep / Numeric Core（Phase 25 実験用）
+- NYASH_AOT_COLLECTIONS_HOT: Array/Map boxcall を externcall に書き換えるホットパス（CollectionsHot パスを有効化）
+- NYASH_AOT_NUMERIC_CORE: 数値系 BoxCall（MatI64 / IntArrayCore 等）の診断パスを有効化（`AotPrepNumericCoreBox`）。現状はログ出力のみで MIR は変更しない（将来の BoxCall→Call 降ろし用の足場）。
+- NYASH_AOT_NUMERIC_CORE_TRACE: 上記 numeric core パスの詳細トレース（"1" で `mul_naive/at/set` など候補 BoxCall を stderr にログ出力）
+
 ### LLVM Feature 詳細
 - **llvm** (デフォルト): llvmlite Python ハーネス使用、LLVM_SYS_180_PREFIX不要
 - **llvm-inkwell-legacy**: Rust inkwell bindings使用、LLVM_SYS_180_PREFIX必要
diff --git a/docs/development/runtime/NUMERIC_ABI.md b/docs/development/runtime/NUMERIC_ABI.md
new file mode 100644
index 00000000..79105a37
--- /dev/null
+++ b/docs/development/runtime/NUMERIC_ABI.md
@@ -0,0 +1,147 @@
+# Numeric ABI (IntArrayCore / MatI64) — Design Stage
+
+Status: design-stage; Phase 25 scope; no behaviour change yet.
+
+## Purpose
+
+- Define a minimal, stable **numeric ABI** for IntArrayCore / MatI64 that:
+  - 実装としては Ring1 Hakorune の通常関数（`Call`）として表現でき、
+  - 必要に応じて Ring0 Rust / C 側からも同じシグネチャで呼び出せる（将来の FFI/ExternCall 連携の基礎になる）。
+- Keep **all box-specific knowledge in Ring1**:
+  - Box/Handle/Core の構造（ptr/len/rows/cols/stride 等）。
+  - 行列積などの数値アルゴリズム本体。
+  - 境界チェックと Fail‑Fast ポリシー。
+- Allow Ring0/LLVM to treat numeric calls as:
+  - 通常の関数呼び出し（`Call @ny_numeric_*`）として扱えるようにし、
+  - 必要な場合のみ、既存の `ExternCall`/FFI 構造の上に同じ関数群を載せ替えられるようにする（Phase 25 では必須ではない）。
+
+Related docs:
+- Phase 25 roadmap: `docs/development/roadmap/phases/phase-25/README.md`
+- Ring1 numeric runtime layout: `lang/src/runtime/numeric/README.md`
+- System Hakorune subset (runtime/numeric 用記法): `docs/development/runtime/system-hakorune-subset.md`
+
+## Conventions
+
+- **Types / encoding**
+  - Numeric ABI 関数のシグネチャは **i64 と Handle（実体は i64×N）** のみを使う。
+  - `IntArrayHandle` / `MatI64Handle` は「i64×N の値」として表現される:
+    - C 側イメージ（概念）:
+      - `typedef struct { int64_t *ptr; int64_t len; } ny_intarray_handle;`
+      - `typedef struct { int64_t *ptr; int64_t rows; int64_t cols; int64_t stride; } ny_mat_i64_handle;`
+    - MIR では「複数の i64 をまとめた値」として `Call` の引数/戻り値に現れる。
+- **命名**
+  - Ring1/Hakorune 側では、`ny_numeric_intarray_*` / `ny_numeric_mat_i64_*` 系の関数名（またはそれに相当するモジュール＋メソッド名）で実装する。
+  - C/Rust 側から直接呼びたい場合は、同じ名前でシンボルをエクスポートする（必要になったタイミングで ExternCall に載せ替え可能）。
+- **Fail‑Fast**
+  - numeric ABI では、事前条件違反（負の長さ、境界外 index、dims 不整合）は **すべてバグ扱い** とし、Fail‑Fast で扱う。
+  - 「エラーコードを返して上層で if」するスタイルは禁止（AGENTS.md の対処療法禁止に準拠）。
+
+## ABI Surface — IntArrayCore (i64 1D)
+
+Conceptual handle:
+- `IntArrayHandle`: 実体は「`ptr: i64` + `len: i64`」等で構成される Core 構造体を指す値。
+- Box レベル仕様は `lang/src/runtime/numeric/README.md` の IntArrayCore セクションを参照。
+
+Functions (proposal; Phase 25 scope):
+
+- `ny_numeric_intarray_new(len: i64) -> IntArrayHandle`
+  - Allocate zero-initialized buffer of length `len`.
+  - Preconditions:
+    - `len >= 0`
+    - `len` が i64 範囲内であり、`len * sizeof(i64)` の計算がオーバーフローしない。
+  - Failure:
+    - OOM / 明らかな誤りは Fail‑Fast（戻り値でのエラー表現は行わない）。
+
+- `ny_numeric_intarray_free(a: IntArrayHandle)`
+  - Free underlying Core.
+  - Double-free / invalid handle は未定義動作とし、所有権設計（Ring1 側）で防ぐ。
+
+- `ny_numeric_intarray_len(a: IntArrayHandle) -> i64`
+  - Return current logical length.
+  - Used mainly for assertions / diagnostics;通常は Box 側で長さを保持しない方向に寄せる。
+
+- `ny_numeric_intarray_get(a: IntArrayHandle, idx: i64) -> i64`
+  - Load `a[idx]`.
+  - Preconditions:
+    - `0 <= idx < len(a)`.
+  - Failure:
+    - Precondition violated → Fail‑Fast（例外 or プロセス終了; 実際の実装は後続フェーズで決定）。
+
+- `ny_numeric_intarray_set(a: IntArrayHandle, idx: i64, v: i64)`
+  - Store `v` into `a[idx]`.
+  - Preconditions:
+    - `0 <= idx < len(a)`.
+  - Failure:
+    - Precondition violated → Fail‑Fast。
+
+Mapping to MIR（Phase 25 の基本方針）:
+- BoxCall（例）: `BoxCall(IntArrayCore, "get_unchecked", [arr, idx])`
+  - AotPrep: 数値コア関数への通常 `Call` に書き換え（例: `Call NyNumericIntArray.get(arr_handle, idx)`）。
+  - LLVM/VM: どちらも同じ `Call` を実行するだけで numeric ABI に到達する。
+
+## ABI Surface — MatI64 (i64 2D matrix)
+
+Conceptual handle:
+- `MatI64Handle`: 「`ptr`, `rows`, `cols`, `stride`」を持つ Core 構造を指す値。
+- Box レベル仕様は `lang/src/runtime/numeric/README.md` の MatI64 セクションを参照。
+
+Functions (proposal; Phase 25 scope):
+
+- `ny_numeric_mat_i64_new(rows: i64, cols: i64) -> MatI64Handle`
+  - Allocate zero-initialized `rows x cols` matrix, row‑major。
+  - Preconditions:
+    - `rows >= 0`, `cols >= 0`.
+    - `rows * cols` が i64 範囲内であり、`rows * cols * sizeof(i64)` がオーバーフローしない。
+
+- `ny_numeric_mat_i64_free(m: MatI64Handle)`
+  - Free underlying matrix Core（所有権は Box 側で管理）。
+
+- `ny_numeric_mat_i64_dims(m: MatI64Handle) -> (rows: i64, cols: i64)`
+  - Return matrix dimensions（行数・列数）。
+
+- `ny_numeric_mat_i64_get(m: MatI64Handle, row: i64, col: i64) -> i64`
+  - Load element at `(row, col)`.
+  - Preconditions:
+    - `0 <= row < rows(m)`, `0 <= col < cols(m)`.
+
+- `ny_numeric_mat_i64_set(m: MatI64Handle, row: i64, col: i64, v: i64)`
+  - Store `v` into `(row, col)`.
+  - Preconditions:
+    - 同上。
+
+- `ny_numeric_mat_i64_mul_naive(a: MatI64Handle, b: MatI64Handle, n: i64) -> MatI64Handle`
+  - Naive O(n³) matrix multiplication for `n x n` matrices.
+  - Preconditions:
+    - `rows(a) == cols(a) == rows(b) == cols(b) == n`.
+    - `n >= 0`。
+  - Failure:
+    - 上記条件を満たさない場合は Fail‑Fast。ベンチマークバグを隠さない。
+
+Mapping to MIR（Phase 25 の基本方針）:
+- BoxCall（例）: `BoxCall(MatI64, "mul_naive", [a, b])`
+  - AotPrep: `Call NyNumericMatI64.mul_naive(a_handle, b_handle, n)` のような numeric core 関数呼び出しに書き換え。
+  - LLVM/VM: どちらも同じ `Call` を実行するだけで numeric ABI に到達する。
+
+## BoxCall / Call / ExternCall の役割分担
+
+- Initial MIR:
+  - `BoxCall(MatI64, "new",  [rows, cols])`
+  - `BoxCall(MatI64, "mul_naive", [a, b])`
+- AotPrep (Ring1):
+  - これらを numeric core 関数への `Call` に変換する（BoxCall を LLVM まで持ち込まない）。
+  - Box 名やメソッド名ベースの一時的 if ではなく、「Box 型ID + メソッドID → numeric core 関数 ID」テーブル化を目指す。
+- Ring0 / LLVM:
+  - `Call @ny_numeric_*` を普通の関数呼び出しとして扱う。
+  - 低レベルのメモリアクセスや OS 連携が必要な場合のみ、既存の `ExternCall`（例: `rt_mem_alloc_i64`）を使う。numeric ABI 自体は必須では ExternCall に依存しない。
+
+## Relation to other docs
+
+- Phase 25 roadmap:
+  - Numeric ABI の設計方針（Ring0/Ring1 分離、Call/ExternCall のみ、Fail‑Fast）を高レベルで説明。
+  - このファイルは、そのうち IntArrayCore / MatI64 に関わる ABI 面のみを詳細化する。
+- `lang/src/runtime/numeric/README.md`:
+  - IntArrayCore / MatI64 の **Box レベル API**（フィールド・メソッド契約）を定義。
+  - Numeric ABI はその下で動く「Core/Handle レベル」の境界として扱う。
+- `docs/development/runtime/system-hakorune-subset.md`:
+  - Numeric ABI の実装を記述する際に使う Hakorune 言語機能の subset を規定。
+  - ループ/Fail‑Fast/Box/Handle パターンなど、実装スタイルを制約する。
diff --git a/docs/development/runtime/system-hakorune-subset.md b/docs/development/runtime/system-hakorune-subset.md
new file mode 100644
index 00000000..2600e5bd
--- /dev/null
+++ b/docs/development/runtime/system-hakorune-subset.md
@@ -0,0 +1,87 @@
+# System Hakorune Subset — Runtime / Numeric Core Design
+
+Status: design-stage; subset definition only. No behavior change yet.
+
+## Purpose
+
+- Provide a small, predictable subset of Hakorune for implementing **runtime / numeric core logic** in Ring1（IntArrayCore, MatI64, stats, policy, etc.）。
+- Make this subset explicit so that:
+  - Box / numeric kernels can be moved from Rust to `.hako` **without increasing semantic complexity**.
+  - AotPrep / VM / LLVM can rely on a restricted feature set when reasoning about these modules.
+- Align with Phase 25 goals:
+  - Ring0（Rust）は intrinsic と最小 VM/FFI のみ。
+  - Ring1（Hakorune）は「元・C 相当の実装」をこの subset で記述する。
+
+Related docs:
+- Phase 25 roadmap: `docs/development/roadmap/phases/phase-25/README.md`
+- Ring1 numeric runtime layout: `lang/src/runtime/numeric/README.md`
+- Numeric ABI surface (IntArrayCore / MatI64): `docs/development/runtime/NUMERIC_ABI.md`
+
+## Scope & Typical Use
+
+- 対象モジュールの例:
+  - `nyash.core.numeric.intarray`（IntArrayCore 本体）
+  - `nyash.core.numeric.matrix_i64`（MatI64 本体）
+  - 将来の数値箱（例: F64ArrayCore, MatF64 など）
+  - ランタイムポリシー / stats / 軽量な AotPrep 補助ロジック
+- 非対象（ここでは扱わないもの）:
+  - 高レベルアプリケーションロジック（UI、CLI コマンド等）。
+  - 重い I/O / ネットワーク / プラグイン動的ロード。
+  - 実験的な言語機能（例外、async 等）を前提とするコード。
+
+## Allowed Features（推奨）
+
+- 制御構造:
+  - `if / else`、`while`、インデックス付きの従来型 `for` ループ。
+  - ネストは OK だが、循環依存や過度な再帰は避ける。
+- データ構造:
+  - Box フィールドを明示した構造体的なパターン（`handle.ptr`, `handle.len` 等）。
+  - 固定長 or 単純な一次元/二次元配列アクセス（IntArrayCore / MatI64）。
+- 関数:
+  - 引数/戻り値が `i64` と Box/Handle 型に限定された関数。
+  - 純粋 or 副作用が局所（配列/行列への書き込み）のみの関数。
+- エラーハンドリング:
+  - **Fail‑Fast** を前提とした設計（事前条件違反は即失敗）。
+  - 戻り値でのエラーコード運搬は禁止（AGENTS.md の対処療法禁止と合わせる）。
+
+## Restricted / Forbidden Features
+
+- 例外 / 非同期:
+  - `throw/try` や async 相当の機能は numeric core の実装では使わない方針（後続フェーズで必要になった場合に個別に設計）。
+- 動的ディスパッチ:
+  - 文字列ベースの `by-name` ディスパッチ（`if method == "mul"` 等）は避け、事前に決まった numeric ABI 関数を直接呼び出す。
+- 動的ロード / プラグイン依存:
+  - numeric core から直接プラグインをロードしない。必要なら上位層（アプリ側）がプラグイン経由で呼ぶ。
+- 型拡張:
+  - 汎用的な「任意型の配列/行列」をここで扱わない。Phase 25 では **i64 専用（IntArrayCore / MatI64）** にスコープを絞る。
+
+## Design Patterns & Guidelines
+
+- 明示的ループ:
+  - 数値カーネルは map/filter 的な高階関数ではなく、`for` / `while` による明示ループで書く。
+  - これにより AotPrep / LLVM でのループ変換・アンローリング等の解析がしやすくなる。
+- Box / Handle の役割分離:
+  - Box（例: `MatI64`）は **API と所有権** を管理する層。
+  - Handle/Core（例: `IntArrayCore`, `MatI64Core`）は **実データとループ本体** を持つ層。
+  - Box メソッドは「引数検査 → numeric ABI 呼び出し」の薄いラッパに留める。
+- Fail‑Fast:
+  - インデックスや次元の検査は、「バグを隠さない」方向で実装する。
+  - `idx < 0` や `idx >= len` など明らかなバグは例外 or プロセス終了で即座に検出し、フォールバックや silent failure は行わない。
+
+## Relation to Ring0 / Numeric ABI
+
+- Ring0（Rust）:
+  - IntArrayCore / MatI64 向けには「ptr/len/rows/cols/stride を受け取る intrinsic」だけを提供する。
+  - ループ本体や境界チェックは実装しない（System Hakorune subset 側に責務を寄せる）。
+- Ring1（Hakorune）:
+  - この subset 上で numeric ABI 関数群（`ny_numeric_intarray_*`, `ny_numeric_mat_i64_*`）を実装する。
+  - AotPrep は BoxCall → numeric ABI への `ExternCall` 変換を行い、LLVM 側は汎用 Call/ExternCall として扱うだけでよい。
+
+## Roadmap（Phase 25 以降）
+
+- Phase 25:
+  - Subset の定義を docs として固定（このファイル）。
+  - IntArrayCore / MatI64 の API 仕様と合わせて、どの機能を subset に含めるかを明示する。
+- 後続フェーズ（22.x / 26.x など）:
+  - 実際の `.hako` 実装を subset 遵守で書き起こす。
+  - AotPrep / VM / LLVM の観点から「subset で書かれた numeric core を前提にした最適化/診断」を設計する。
diff --git a/lang/src/llvm_ir/boxes/aot_prep.hako b/lang/src/llvm_ir/boxes/aot_prep.hako
index 2c25583b..f096a9d3 100644
--- a/lang/src/llvm_ir/boxes/aot_prep.hako
+++ b/lang/src/llvm_ir/boxes/aot_prep.hako
@@ -21,6 +21,7 @@ using selfhost.llvm.ir.aot_prep.passes.const_dedup as AotPrepConstDedupBox
 using selfhost.llvm.ir.aot_prep.passes.binop_cse as AotPrepBinopCSEBox
 using selfhost.llvm.ir.aot_prep.passes.collections_hot as AotPrepCollectionsHotBox
 using selfhost.llvm.ir.aot_prep.passes.fold_const_ret as AotPrepFoldConstRetBox
+using selfhost.llvm.ir.aot_prep.passes.numeric_core as AotPrepNumericCoreBox
 
 // Pass modules (logical分割; 将来はファイル分割へ移行)
 static box AotPrepPass_Strlen { run(json) { return AotPrepStrlenBox.run(json) } }
@@ -28,6 +29,7 @@ static box AotPrepPass_LoopHoist { run(json) { return AotPrepLoopHoistBox.run(js
 static box AotPrepPass_ConstDedup { run(json) { return AotPrepConstDedupBox.run(json) } }
 static box AotPrepPass_CollectionsHot { run(json) { return AotPrepCollectionsHotBox.run(json) } }
 static box AotPrepPass_BinopCSE { run(json) { return AotPrepBinopCSEBox.run(json) } }
+static box AotPrepPass_NumericCore { run(json) { return AotPrepNumericCoreBox.run(json) } }
 
 static box AotPrepBox {
   // AotPrepBox.prep
@@ -71,6 +73,12 @@ static box AotPrepBox {
       if r != null && r != "" { out = r }
     }
 
+    // Phase‑4 (opt-in): numeric core diagnostics / future lowering
+    if env.get("NYASH_AOT_NUMERIC_CORE") == "1" {
+      local nn = AotPrepPass_NumericCore.run(out)
+      if nn != null && nn != "" { out = nn }
+    }
+
     // Phase‑3.5 (opt-in): 正規化（Rust normalize.rs からの移行先／既定OFF）
     if env.get("HAKO_MIR_NORMALIZE_PRINT") == "1" {
       local np = NormalizePrintBox.run(out)
diff --git a/lang/src/llvm_ir/boxes/aot_prep/passes/numeric_core.hako b/lang/src/llvm_ir/boxes/aot_prep/passes/numeric_core.hako
new file mode 100644
index 00000000..f5b8c5a5
--- /dev/null
+++ b/lang/src/llvm_ir/boxes/aot_prep/passes/numeric_core.hako
@@ -0,0 +1,54 @@
+// AotPrepNumericCoreBox — numeric BoxCall diagnostics / future lowering hook (design-stage)
+// Scope (Phase 25):
+// - Detect MatI64 / IntArrayCore related boxcalls in MIR(JSON v0).
+// - Emit lightweight trace when NYASH_AOT_NUMERIC_CORE=1.
+// - Do NOT modify JSON yet (semantics不変)。将来の BoxCall→Call(numeric core) 書き換えの足場とする。
+
+using selfhost.shared.json.utils.json_frag as JsonFragBox
+using selfhost.shared.common.string_helpers as StringHelpers
+
+static box AotPrepNumericCoreBox {
+  // design-stage entry point
+  run(json) {
+    if json == null { return json }
+    local enabled = env.get("NYASH_AOT_NUMERIC_CORE")
+    if enabled == null || ("" + enabled) != "1" { return json }
+
+    local trace = env.get("NYASH_AOT_NUMERIC_CORE_TRACE")
+    local text = "" + json
+    local pos = 0
+    loop(true) {
+      // Find next boxcall
+      local op_pos = text.indexOf("\"op\":\"boxcall\"", pos)
+      if op_pos < 0 { break }
+
+      // Find enclosing object bounds (best-effort)
+      local obj_start = text.substring(0, op_pos).lastIndexOf("{")
+      if obj_start < 0 { pos = op_pos + 1 continue }
+      local obj_end = JsonFragBox._seek_object_end(text, obj_start)
+      if obj_end <= obj_start { pos = op_pos + 1 continue }
+
+      local inst = text.substring(obj_start, obj_end + 1)
+      // Read method name if present
+      local m = AotPrepNumericCoreBox._read_field(inst, "method")
+      if m == "mul_naive" || m == "at" || m == "set" {
+        // We cannot yet reliably resolve box type here; this is purely diagnostic.
+        if trace != null && ("" + trace) == "1" {
+          print("[aot/numeric_core] boxcall(method=" + m + ") candidate: " + inst)
+        }
+      }
+
+      pos = obj_end + 1
+    }
+    // No transformation yet; return input as-is.
+    return json
+  }
+
+  _read_field(text, key) {
+    local needle = "\"" + key + "\":\""
+    local idx = text.indexOf(needle)
+    if idx < 0 { return "" }
+    return JsonFragBox.read_string_after(text, idx + needle.length())
+  }
+}
+
diff --git a/lang/src/runtime/numeric/README.md b/lang/src/runtime/numeric/README.md
new file mode 100644
index 00000000..8ee880d5
--- /dev/null
+++ b/lang/src/runtime/numeric/README.md
@@ -0,0 +1,133 @@
+# lang/src/runtime/numeric — Ring1 Numeric Runtime
+
+Scope: Phase 21.6+ / 21.8 / 25 で導入する **数値コア箱（numeric core boxes）** を配置するディレクトリ。
+
+## 目的
+
+- ArrayBox/MapBox などの汎用箱とは別に、数値・行列・ビルダ系の「C 相当コア」を Ring1（Hakorune）側で実装する。
+- 将来的には、このディレクトリ配下の `.hako` を AOT して `stdlib` 相当の成果物にまとめ、VM 起動時にロードする（Phase 25 以降）。
+
+## 代表モジュール
+
+- `intarray_core_box.hako`
+  - 数値一次元配列コア（IntArrayCore）の Box ラッパ。
+  - Phase 21.6: Rust プラグイン `IntArrayCore` に委譲。
+  - Phase 25: `.hako` 実装に移行し、Ring0 は `alloc/free/load/store` などの intrinsic のみ提供する方針。
+- `mat_i64_box.hako`
+  - 行列箱 `MatI64`（i64 行列）の Box 実装。
+  - Phase 21.6/21.8: IntArrayCore に委譲する naive 実装。
+  - Phase 25: numeric ABI（`ny_numeric_mat_i64_*`）の薄ラッパとして整理し、VM / LLVM ともに「BoxCall → numeric core 関数への Call」という同じ MIR を実行する形を目指す（numeric 専用の ExternCall 境界は増やさない）。
+  - 現状: 数値核 `mul_naive` の本体は `NyNumericMatI64.mul_naive` に分離し、`MatI64.mul_naive` はその薄ラッパとして実装。
+
+## Phase 25 との関係
+
+- Phase 25 では:
+  - IntArrayCore / MatI64 の本体ロジックを `.hako` 側に移し、Rust 側は最小の numeric intrinsic と LLVM/OS FFI だけを持つ Ring0 とする。
+  - AotPrep / builder で `BoxCall(MatI64, ...)` / `BoxCall(IntArrayCore, ...)` を **numeric core 関数への通常 `Call`** に変換する設計を導入する（BoxCall を LLVM まで持ち込まない）。
+- このディレクトリはそのための **Ring1 numeric runtime の定位置**として扱う。
+  - 本番やベンチでは、AOT 済み stdlib（例: `stdlib.hbc`）から `nyash.core.numeric.*` モジュールをロードする embedded モードを使用。
+  - 開発時には、`NYASH_STDLIB_MODE=source`（候補）などで埋め込み stdlib を無効化し、このディレクトリ配下の `.hako` を直接コンパイルして挙動を確認する運用を想定。
+
+## IntArrayCore Box API（設計メモ）
+
+実装ファイル: `lang/src/runtime/numeric/intarray_core_box.hako`
+
+### フィールド設計
+
+- `handle: i64`
+  - NyRT/Rust 側で管理される IntArrayCore インスタンスへのハンドル。
+  - 現行実装では `nyash.intarray.*` C シンボル経由で操作される（Phase 25 以降で numeric ABI に移行予定）。
+- `len: i64`
+  - 配列長（要素数）。`new(len)` 時の引数と一致する前提。
+  - 変更不可（再割り当てや resize は想定しない）。
+
+### メソッド仕様（Box レベル）
+
+- `static new(len: i64) -> IntArrayCore`
+  - 役割: 長さ `len` の 0 初期化配列を作成する。
+  - 事前条件:
+    - `len >= 0` を前提とする（負値はバグ扱い; Fail‑Fast 寄りのポリシーで扱う）。
+  - 実装メモ:
+    - 現行: `externcall "nyash.intarray.new_h"(len)` を呼び、返ってきたハンドルを `handle` に格納。
+    - 将来: numeric ABI（`ny_numeric_intarray_new` 等）経由で Core を構築し、Handle/Core の表現を段階的に置き換える。
+
+- `length() -> i64`
+  - 役割: 現在の要素数を返す。
+  - 期待挙動:
+    - 通常は `len` と同値。
+    - Core 側の情報と不整合が生じないよう、Phase 25 以降は「単一の SSOT（Core 側）」に寄せる設計を検討する。
+
+- `get_unchecked(idx: i64) -> i64`
+  - 役割: インデックス `idx` から値を取得する。
+  - 事前条件:
+    - `0 <= idx < length()` を呼び出し側が保証する（unchecked の名の通り）。
+  - エラー処理:
+    - Phase 21.x 実装では、範囲外アクセス時に 0 を返すなどの挙動が残っているため、Phase 25 では「Fail‑Fast（バグを隠さない）」方向に整理する。
+  - 用途:
+    - MatI64 や numeric カーネル内部でのループ本体から使用する前提（System Hakorune subset 内）。
+
+- `set_unchecked(idx: i64, v: i64) -> null`
+  - 役割: インデックス `idx` に値 `v` を書き込む。
+  - 事前条件:
+    - `0 <= idx < length()` を呼び出し側が保証する。
+  - エラー処理:
+    - Phase 21.x 実装では戻り値でエラーコードを返す形跡があるが、Phase 25 では Fail‑Fast で統一し、Box レベルでは成功/失敗を返さない設計を目指す。
+
+## MatI64 Box API（設計メモ）
+
+実装ファイル: `lang/src/runtime/numeric/mat_i64_box.hako`
+
+### フィールド設計
+
+- `rows: i64`
+  - 行数（row count）。`rows >= 0` を前提。
+- `cols: i64`
+  - 列数（column count）。`cols >= 0` を前提。
+- `stride: i64`
+  - 1 行あたりのステップ幅。現行実装では `cols` と同一（row‑major の連続配置）。
+  - 将来、ビューやサブ行列を導入する場合に `stride != cols` を許容する余地を残す。
+- `core: IntArrayCore`
+  - 実データを保持する一次元配列コア（長さは `rows * cols` を前提）。
+
+### メソッド仕様（Box レベル）
+
+- `static new(rows: i64, cols: i64) -> MatI64`
+  - 役割: `rows x cols` のゼロ初期化行列を作成する。
+  - 事前条件:
+    - `rows >= 0`, `cols >= 0`。
+    - `rows * cols` が i64 の範囲内に収まること（オーバーフロー時は Fail‑Fast 寄りに扱う）。
+  - 実装メモ:
+    - `IntArrayCore.new(rows * cols)` を呼び出し、`stride = cols` として初期化。
+
+- `rowsCount() -> i64`
+  - 役割: 行数を返す（読み取り専用）。
+
+- `colsCount() -> i64`
+  - 役割: 列数を返す。
+
+- `at(r: i64, c: i64) -> i64`
+  - 役割: 要素 `(r, c)` を読み取る。
+  - 事前条件:
+    - `0 <= r < rows`, `0 <= c < cols` を呼び出し側が保証。
+  - 実装メモ:
+    - `idx = r * stride + c` を計算し、`core.get_unchecked(idx)` を呼ぶ。
+  - 将来:
+    - デバッグ/strict モードでは範囲チェックを追加するオプションを検討（prod ではループ性能優先）。
+
+- `set(r: i64, c: i64, v: i64) -> null`
+  - 役割: 要素 `(r, c)` に `v` を書き込む。
+  - 事前条件:
+    - `0 <= r < rows`, `0 <= c < cols`。
+  - 実装メモ:
+    - `idx = r * stride + c` を計算し、`core.set_unchecked(idx, v)` を呼ぶ。
+
+- `mul_naive(b: MatI64) -> MatI64`
+  - 役割: `me * b` のナイーブな O(n³) 行列積を計算する。
+  - 事前条件:
+    - 現行スケルトンでは「正方行列かつ形状一致」を暗黙前提としている（Phase 25 で明示条件に格上げする）。
+    - 最低限 `me.cols == b.rows` を事前条件とし、満たさない場合は Fail‑Fast とする方向。
+  - 実装メモ:
+    - 三重ループ (`i`,`k`,`j`) で `out[i,j] += me[i,k] * b[k,j]` を計算。
+    - `out` 行列は `MatI64.new(me.rows, b.cols)` で確保。
+  - Phase 25 以降:
+    - Box メソッドとしての `mul_naive` は numeric ABI の薄ラッパに縮退し、ループ本体は System Hakorune subset 上の別関数（`ny_numeric_mat_i64_mul_naive`）に切り出す。
diff --git a/lang/src/runtime/numeric/mat_i64_box.hako b/lang/src/runtime/numeric/mat_i64_box.hako
index 053c43a0..1cb6060c 100644
--- a/lang/src/runtime/numeric/mat_i64_box.hako
+++ b/lang/src/runtime/numeric/mat_i64_box.hako
@@ -37,17 +37,25 @@ static box MatI64 {
   }
 
   // Naive O(n^3) matmul: this * b
+  // Box メソッドは numeric core への薄ラッパとして扱う。
   mul_naive(b) {
-    local n = me.rows
-    local mcols = me.cols
+    return NyNumericMatI64.mul_naive(me, b)
+  }
+}
+
+// NyNumericMatI64 — numeric core for MatI64 operations (System Hakorune subset)
+static box NyNumericMatI64 {
+  static mul_naive(a, b) {
+    local n = a.rows
+    local mcols = a.cols
     local bcols = b.cols
-    // assume shapes are compatible and square for now (Phase 21.6 draft)
+    // assume shapes are compatible and square for now (Phase 21.6/25 draft)
     local out = MatI64.new(n, bcols)
     local i = 0
     loop(i < n) {
       local k = 0
       loop(k < mcols) {
-        local aik = me.at(i, k)
+        local aik = a.at(i, k)
         local j = 0
         loop(j < bcols) {
           local idx = i * out.stride + j
@@ -62,4 +70,3 @@ static box MatI64 {
     return out
   }
 }
-