🔍 Research: GPT-5-Codex capabilities and GitHub PR integration

## Summary
Investigated OpenAI's new GPT-5-Codex model and Codex GitHub PR review integration capabilities.

## GPT-5-Codex Analysis

### Benchmark Performance (Good)
- SWE-bench Verified: 74.5% (vs GPT-5's 72.8%)
- Refactoring tasks: 51.3% (vs GPT-5's 33.9%)
- Code review: Higher developer ratings

### Real-World Issues (Concerning)
- Users report degraded coding performance
- Scripts that previously worked now fail
- Less consistent than GPT-4.5
- Longer response times (minutes vs instant)
- "Creatively and emotionally flat"
- Basic errors (e.g., counting letters incorrectly)

### Key Finding
Classic case of "optimizing for benchmarks vs real usability" - scores well on tests but performs poorly in practice.

## Codex GitHub PR Integration

### Setup Process
1. Enable MFA and connect GitHub account
2. Authorize Codex GitHub app for repos
3. Enable "Code review" in repository settings

### Usage Methods
- **Manual**: Comment '@codex review' in PR
- **Automatic**: Triggers when PR moves from draft to ready

### Current Limitations
- One-way communication (doesn't respond to review comments)
- Prefers creating new PRs over updating existing ones
- Better for single-pass reviews than iterative feedback

## 'codex resume' Feature
New session management capability:
- Resume previous codex exec sessions
- Useful for continuing long tasks across days
- Maintains context from interrupted work

🐱 The investigation reveals that while GPT-5-Codex shows benchmark improvements, practical developer experience has declined - a reminder that metrics don't always reflect real-world utility\!

crates/nyrt/src/lib.rs

@@ -545,6 +545,23 @@ pub extern "C" fn nyash_console_birth_h_export() -> i64 {
     0
 }
 
+
+
+// ArrayBox birth shim for AOT/JIT handle-based creation
+#[export_name = "nyash.array.birth_h"]
+pub extern "C" fn nyash_array_birth_h_export() -> i64 {
+    let arc: std::sync::Arc<dyn nyash_rust::box_trait::NyashBox> =
+        std::sync::Arc::new(nyash_rust::boxes::array::ArrayBox::new());
+    nyash_rust::jit::rt::handles::to_handle(arc) as i64
+}
+
+// MapBox birth shim for AOT/JIT handle-based creation
+#[export_name = "nyash.map.birth_h"]
+pub extern "C" fn nyash_map_birth_h_export() -> i64 {
+    let arc: std::sync::Arc<dyn nyash_rust::box_trait::NyashBox> =
+        std::sync::Arc::new(nyash_rust::boxes::map_box::MapBox::new());
+    nyash_rust::jit::rt::handles::to_handle(arc) as i64
+}
 // ---- Process entry (driver) ----
 #[cfg(not(test))]
 #[no_mangle]

crates/nyrt/src/plugin/map.rs

@@ -63,17 +63,15 @@ pub extern "C" fn nyash_map_get_h(handle: i64, key: i64) -> i64 {
 
 // get_hh: (map_handle, key_handle) -> value_handle
 #[export_name = "nyash.map.get_hh"]
-pub extern "C" fn nyash_map_get_hh(handle: i64, key_h: i64) -> i64 {
-    use nyash_rust::{box_trait::NyashBox, jit::rt::handles};
-    if handle <= 0 || key_h <= 0 {
-        return 0;
-    }
-    if let (Some(obj), Some(key)) = (handles::get(handle as u64), handles::get(key_h as u64)) {
-        if let Some(map) = obj
-            .as_any()
-            .downcast_ref::<nyash_rust::boxes::map_box::MapBox>()
-        {
-            let v = map.get(key.clone_box());
+pub extern "C" fn nyash_map_get_hh(handle: i64, key_any: i64) -> i64 {
+    use nyash_rust::{box_trait::{NyashBox, IntegerBox}, jit::rt::handles};
+    if handle <= 0 { return 0; }
+    if let Some(obj) = handles::get(handle as u64) {
+        if let Some(map) = obj.as_any().downcast_ref::<nyash_rust::boxes::map_box::MapBox>() {
+            let key_box: Box<dyn NyashBox> = if key_any > 0 {
+                if let Some(k) = handles::get(key_any as u64) { k.clone_box() } else { Box::new(IntegerBox::new(key_any)) }
+            } else { Box::new(IntegerBox::new(key_any)) };
+            let v = map.get(key_box);
             let arc: std::sync::Arc<dyn NyashBox> = std::sync::Arc::from(v);
             let h = handles::to_handle(arc);
             return h as i64;
@@ -82,6 +80,7 @@ pub extern "C" fn nyash_map_get_hh(handle: i64, key_h: i64) -> i64 {
     0
 }
 
+
 // set_h: (map_handle, key_i64, val) -> i64 (ignored/0)
 #[export_name = "nyash.map.set_h"]
 pub extern "C" fn nyash_map_set_h(handle: i64, key: i64, val: i64) -> i64 {
@@ -126,6 +125,44 @@ pub extern "C" fn nyash_map_set_h(handle: i64, key: i64, val: i64) -> i64 {
     0
 }
 
+
+// set_hh: (map_handle, key_any: handle or i64, val_any: handle or i64) -> i64
+#[export_name = "nyash.map.set_hh"]
+pub extern "C" fn nyash_map_set_hh(handle: i64, key_any: i64, val_any: i64) -> i64 {
+    use nyash_rust::{box_trait::{NyashBox, IntegerBox}, jit::rt::handles};
+    if handle <= 0 { return 0; }
+    if let Some(obj) = handles::get(handle as u64) {
+        if let Some(map) = obj.as_any().downcast_ref::<nyash_rust::boxes::map_box::MapBox>() {
+            let kbox: Box<dyn NyashBox> = if key_any > 0 {
+                if let Some(k) = handles::get(key_any as u64) { k.clone_box() } else { Box::new(IntegerBox::new(key_any)) }
+            } else { Box::new(IntegerBox::new(key_any)) };
+            let vbox: Box<dyn NyashBox> = if val_any > 0 {
+                if let Some(v) = handles::get(val_any as u64) { v.clone_box() } else { Box::new(IntegerBox::new(val_any)) }
+            } else { Box::new(IntegerBox::new(val_any)) };
+            let _ = map.set(kbox, vbox);
+            return 0;
+        }
+    }
+    0
+}
+
+// has_hh: (map_handle, key_any: handle or i64) -> i64 (0/1)
+#[export_name = "nyash.map.has_hh"]
+pub extern "C" fn nyash_map_has_hh(handle: i64, key_any: i64) -> i64 {
+    use nyash_rust::{box_trait::{NyashBox, IntegerBox, BoolBox}, jit::rt::handles};
+    if handle <= 0 { return 0; }
+    if let Some(obj) = handles::get(handle as u64) {
+        if let Some(map) = obj.as_any().downcast_ref::<nyash_rust::boxes::map_box::MapBox>() {
+            let kbox: Box<dyn NyashBox> = if key_any > 0 {
+                if let Some(k) = handles::get(key_any as u64) { k.clone_box() } else { Box::new(IntegerBox::new(key_any)) }
+            } else { Box::new(IntegerBox::new(key_any)) };
+            let v = map.has(kbox);
+            if let Some(b) = v.as_any().downcast_ref::<BoolBox>() { return if b.value { 1 } else { 0 }; }
+        }
+    }
+    0
+}
+
 // has_h: (map_handle, key_i64) -> i64 (0/1)
 #[export_name = "nyash.map.has_h"]
 pub extern "C" fn nyash_map_has_h(handle: i64, key: i64) -> i64 {
@@ -139,10 +176,8 @@ pub extern "C" fn nyash_map_has_h(handle: i64, key: i64) -> i64 {
             .downcast_ref::<nyash_rust::boxes::map_box::MapBox>()
         {
             let kbox = Box::new(IntegerBox::new(key));
-            let v = map.get(kbox);
-            // Consider present if not VoidBox
-            let present = !v.as_any().is::<nyash_rust::box_trait::VoidBox>();
-            return if present { 1 } else { 0 };
+            let v = map.has(kbox);
+            if let Some(b) = v.as_any().downcast_ref::<nyash_rust::box_trait::BoolBox>() { return if b.value { 1 } else { 0 }; }
         }
     }
     0