Phase 11.8/12: MIR Core-13 roadmap, Nyash ABI design, async/await enhancements with TaskGroupBox foundation

Major additions:
- Phase 11.8 MIR cleanup specification (Core-15→14→13 roadmap)
- Nyash ABI unified design document (3×u64 structure)
- TaskGroupBox foundation with cancelAll/joinAll methods
- Enhanced async/await with checkpoint auto-insertion
- Structured concurrency preparation (parent-child task relationships)

Documentation:
- docs/development/roadmap/phases/phase-11.8_mir_cleanup/: Complete Core-13 path
- docs/development/roadmap/phases/phase-12/NYASH-ABI-DESIGN.md: Unified ABI spec
- Updated Phase 12 README with AOT/JIT explanation for script performance
- Added async_task_system/ design docs

Implementation progress:
- FutureBox spawn tracking with weak/strong reference management
- VM checkpoint integration before/after await
- LLVM backend async support preparation
- Verifier rules for await-checkpoint enforcement
- Result<T,E> normalization for timeout/cancellation

Technical insights:
- MIR as 'atomic instructions', Box as 'molecules' philosophy
- 'Everything is Box' enables full-stack with minimal instructions
- Unified BoxCall for array/plugin/async operations future consolidation

Next steps:
- Complete TaskGroupBox implementation
- Migrate from global to scoped task management
- Implement LIFO cleanup on scope exit
- Continue Core-13 instruction consolidation

🚀 'From 15 atoms to infinite programs: The Nyash Box Theory'

src/boxes/future/mod.rs

@@ -4,69 +4,74 @@
 
 use crate::box_trait::{NyashBox, StringBox, BoolBox, BoxCore, BoxBase};
 use std::any::Any;
-use std::sync::RwLock;
+use std::sync::{Mutex, Condvar, Arc, Weak};
 
 #[derive(Debug)]
 pub struct NyashFutureBox {
-    pub result: RwLock<Option<Box<dyn NyashBox>>>,
-    pub is_ready: RwLock<bool>,
+    inner: Arc<Inner>,
     base: BoxBase,
 }
 
+#[derive(Debug)]
+struct FutureState {
+    result: Option<Box<dyn NyashBox>>,
+    ready: bool,
+}
+
+#[derive(Debug)]
+struct Inner {
+    state: Mutex<FutureState>,
+    cv: Condvar,
+}
+
+/// A weak handle to a Future's inner state.
+/// Used for non-owning registries (TaskGroup/implicit group) to avoid leaks.
+#[derive(Clone, Debug)]
+pub struct FutureWeak {
+    pub(crate) inner: Weak<Inner>,
+}
+
 impl Clone for NyashFutureBox {
     fn clone(&self) -> Self {
-        let result_guard = self.result.read().unwrap();
-        let result_val = match result_guard.as_ref() {
-            Some(box_value) => Some(box_value.clone_box()),
-            None => None,
-        };
-        let is_ready_val = *self.is_ready.read().unwrap();
-        
-        Self {
-            result: RwLock::new(result_val),
-            is_ready: RwLock::new(is_ready_val),
-            base: BoxBase::new(), // Create a new base with unique ID for the clone
-        }
+        Self { inner: self.inner.clone(), base: BoxBase::new() }
     }
 }
 
 impl NyashFutureBox {
     pub fn new() -> Self {
         Self {
-            result: RwLock::new(None),
-            is_ready: RwLock::new(false),
+            inner: Arc::new(Inner {
+                state: Mutex::new(FutureState { result: None, ready: false }),
+                cv: Condvar::new(),
+            }),
             base: BoxBase::new(),
         }
     }
     
     /// Set the result of the future
     pub fn set_result(&self, value: Box<dyn NyashBox>) {
-        let mut result = self.result.write().unwrap();
-        *result = Some(value);
-        let mut ready = self.is_ready.write().unwrap();
-        *ready = true;
+        let mut st = self.inner.state.lock().unwrap();
+        st.result = Some(value);
+        st.ready = true;
+        self.inner.cv.notify_all();
     }
     
     /// Get the result (blocks until ready)
     pub fn get(&self) -> Box<dyn NyashBox> {
-        // Simple busy wait (could be improved with condvar)
-        loop {
-            let ready = self.is_ready.read().unwrap();
-            if *ready {
-                break;
-            }
-            drop(ready);
-            std::thread::yield_now();
+        let mut st = self.inner.state.lock().unwrap();
+        while !st.ready {
+            st = self.inner.cv.wait(st).unwrap();
         }
-        
-        let result = self.result.read().unwrap();
-        result.as_ref().unwrap().clone_box()
+        st.result.as_ref().unwrap().clone_box()
     }
     
     /// Check if the future is ready
     pub fn ready(&self) -> bool {
-        *self.is_ready.read().unwrap()
+        self.inner.state.lock().unwrap().ready
     }
+
+    /// Create a non-owning weak handle to this Future's state
+    pub fn downgrade(&self) -> FutureWeak { FutureWeak { inner: Arc::downgrade(&self.inner) } }
 }
 
 impl NyashBox for NyashFutureBox {
@@ -80,10 +85,10 @@ impl NyashBox for NyashFutureBox {
     }
 
     fn to_string_box(&self) -> StringBox {
-        let ready = *self.is_ready.read().unwrap();
+        let ready = self.inner.state.lock().unwrap().ready;
         if ready {
-            let result = self.result.read().unwrap();
-            if let Some(value) = result.as_ref() {
+            let st = self.inner.state.lock().unwrap();
+            if let Some(value) = st.result.as_ref() {
                 StringBox::new(format!("Future(ready: {})", value.to_string_box().value))
             } else {
                 StringBox::new("Future(ready: void)".to_string())
@@ -118,10 +123,10 @@ impl BoxCore for NyashFutureBox {
     }
 
     fn fmt_box(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let ready = *self.is_ready.read().unwrap();
+        let ready = self.inner.state.lock().unwrap().ready;
         if ready {
-            let result = self.result.read().unwrap();
-            if let Some(value) = result.as_ref() {
+            let st = self.inner.state.lock().unwrap();
+            if let Some(value) = st.result.as_ref() {
                 write!(f, "Future(ready: {})", value.to_string_box().value)
             } else {
                 write!(f, "Future(ready: void)")
@@ -155,3 +160,10 @@ impl FutureBox {
         Ok(self.get())
     }
 }
+
+impl FutureWeak {
+    /// Try to upgrade and check readiness
+    pub(crate) fn is_ready(&self) -> Option<bool> {
+        self.inner.upgrade().map(|arc| arc.state.lock().unwrap().ready)
+    }
+}

src/boxes/mod.rs

@@ -84,6 +84,7 @@ pub mod debug_config_box;
 pub mod gc_config_box;
 pub mod aot_config_box;
 pub mod aot_compiler_box;
+pub mod task_group_box;
 
 // Web専用Box群（ブラウザ環境でのみ利用可能）
 #[cfg(target_arch = "wasm32")]
@@ -122,6 +123,7 @@ pub use jit_strict_box::JitStrictBox;
 pub use jit_hostcall_registry_box::JitHostcallRegistryBox;
 pub use aot_config_box::AotConfigBox;
 pub use aot_compiler_box::AotCompilerBox;
+pub use task_group_box::TaskGroupBox;
 
 // EguiBoxの再エクスポート（非WASM環境のみ）
 #[cfg(all(feature = "gui", not(target_arch = "wasm32")))]
@@ -158,7 +160,7 @@ pub use null_box::{NullBox, null};
 pub use array::ArrayBox;
 pub use buffer::BufferBox;
 pub use file::FileBox;
-pub use future::{NyashFutureBox, FutureBox};
+pub use future::{NyashFutureBox, FutureBox, FutureWeak};
 pub use json::JSONBox;
 pub use result::{NyashResultBox, ResultBox};
 pub use http::HttpClientBox;

src/boxes/task_group_box.rs

@@ -0,0 +1,77 @@
+use crate::box_trait::{NyashBox, BoxCore, BoxBase, StringBox, BoolBox, VoidBox};
+use std::any::Any;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub(crate) struct TaskGroupInner {
+    pub(super) strong: Mutex<Vec<crate::boxes::future::FutureBox>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct TaskGroupBox {
+    base: BoxBase,
+    // Skeleton: cancellation token owned by this group (future wiring)
+    cancelled: bool,
+    pub(crate) inner: Arc<TaskGroupInner>,
+}
+
+impl TaskGroupBox {
+    pub fn new() -> Self {
+        Self { base: BoxBase::new(), cancelled: false, inner: Arc::new(TaskGroupInner { strong: Mutex::new(Vec::new()) }) }
+    }
+    pub fn cancel_all(&mut self) { self.cancelled = true; }
+    /// Cancel all child tasks (scaffold) and return void
+    pub fn cancelAll(&mut self) -> Box<dyn NyashBox> {
+        self.cancel_all();
+        Box::new(VoidBox::new())
+    }
+    /// Join all child tasks with optional timeout (ms); returns void
+    pub fn joinAll(&self, timeout_ms: Option<i64>) -> Box<dyn NyashBox> {
+        let ms = timeout_ms.unwrap_or(2000).max(0) as u64;
+        self.join_all_inner(ms);
+        Box::new(VoidBox::new())
+    }
+    pub fn is_cancelled(&self) -> bool { self.cancelled }
+
+    /// Register a Future into this group's ownership
+    pub fn add_future(&self, fut: &crate::boxes::future::FutureBox) {
+        if let Ok(mut v) = self.inner.strong.lock() {
+            v.push(fut.clone());
+        }
+    }
+
+    fn join_all_inner(&self, timeout_ms: u64) {
+        use std::time::{Duration, Instant};
+        let deadline = Instant::now() + Duration::from_millis(timeout_ms);
+        loop {
+            let mut all_ready = true;
+            if let Ok(mut list) = self.inner.strong.lock() {
+                list.retain(|f| !f.ready());
+                if !list.is_empty() { all_ready = false; }
+            }
+            if all_ready { break; }
+            if Instant::now() >= deadline { break; }
+            crate::runtime::global_hooks::safepoint_and_poll();
+            std::thread::yield_now();
+        }
+    }
+}
+
+impl BoxCore for TaskGroupBox {
+    fn box_id(&self) -> u64 { self.base.id }
+    fn parent_type_id(&self) -> Option<std::any::TypeId> { None }
+    fn fmt_box(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "TaskGroup(cancelled={})", self.cancelled)
+    }
+    fn as_any(&self) -> &dyn Any { self }
+    fn as_any_mut(&mut self) -> &mut dyn Any { self }
+}
+
+impl NyashBox for TaskGroupBox {
+    fn to_string_box(&self) -> StringBox { StringBox::new(format!("TaskGroup(cancelled={})", self.cancelled)) }
+    fn equals(&self, other: &dyn NyashBox) -> BoolBox {
+        if let Some(g) = other.as_any().downcast_ref::<TaskGroupBox>() { BoolBox::new(self.base.id == g.base.id) } else { BoolBox::new(false) }
+    }
+    fn clone_box(&self) -> Box<dyn NyashBox> { Box::new(self.clone()) }
+    fn share_box(&self) -> Box<dyn NyashBox> { self.clone_box() }
+}