oh-my-codex 0.21.16 → 0.21.18

package/Cargo.lock

@@ -32,7 +32,7 @@ checksum = "6b947ae49db0d222b1dbc6b113ce7248a3fc3a6ca21b696717bfc000ba4484d8"
 
 [[package]]
 name = "omx-api"
-version = "0.21.16"
+version = "0.21.18"
 dependencies = [
  "serde",
  "serde_json",
@@ -40,14 +40,14 @@ dependencies = [
 
 [[package]]
 name = "omx-explore-harness"
-version = "0.21.16"
+version = "0.21.18"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "omx-mux"
-version = "0.21.16"
+version = "0.21.18"
 dependencies = [
  "serde",
  "serde_json",
@@ -55,7 +55,7 @@ dependencies = [
 
 [[package]]
 name = "omx-runtime"
-version = "0.21.16"
+version = "0.21.18"
 dependencies = [
  "fs2",
  "libc",
@@ -67,7 +67,7 @@ dependencies = [
 
 [[package]]
 name = "omx-runtime-core"
-version = "0.21.16"
+version = "0.21.18"
 dependencies = [
  "fs2",
  "serde",
@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "omx-sparkshell"
-version = "0.21.16"
+version = "0.21.18"
 dependencies = [
  "omx-mux",
 ]

package/Cargo.toml

@@ -11,7 +11,7 @@ resolver = "2"
 
 [workspace.package]
 
-version = "0.21.16"
+version = "0.21.18"
 
 edition = "2021"
 rust-version = "1.73"

package/crates/omx-runtime/src/main.rs

@@ -27,6 +27,7 @@ fn run() -> Result<(), String> {
             if second == Some("--json") {
                 let summary = serde_json::json!({
                     "schema_version": omx_runtime_core::RUNTIME_SCHEMA_VERSION,
+                    "capabilities": omx_runtime_core::RUNTIME_CAPABILITIES,
                     "commands": omx_runtime_core::RUNTIME_COMMAND_NAMES,
                     "events": omx_runtime_core::RUNTIME_EVENT_NAMES,
                     "transport": "tmux",
@@ -70,7 +71,12 @@ fn run() -> Result<(), String> {
             }
             Ok(())
         }
-        Some("exec") => {
+        Some("exec") | Some("exec-scoped") => {
+            if first == Some("exec-scoped")
+                && !omx_runtime_core::RUNTIME_CAPABILITIES.contains(&"team-mailbox-scope-v1")
+            {
+                return Err("omx-runtime requires team-mailbox-scope-v1".to_string());
+            }
             let json_input = second.ok_or("exec requires a JSON command argument")?;
             let state_dir = args.iter().find_map(|a| a.strip_prefix("--state-dir="));
             let compact = args.iter().any(|a| a == "--compact");
@@ -119,9 +125,14 @@ fn run() -> Result<(), String> {
                     .map_err(|e| format!("compatibility view failed: {e}"))?;
             }
 
+            let mut response = serde_json::to_value(&event).map_err(|e| e.to_string())?;
+            if matches!(event, omx_runtime_core::RuntimeEvent::SnapshotCaptured) {
+                response["dispatch_records"] =
+                    serde_json::to_value(engine.dispatch_records()).map_err(|e| e.to_string())?;
+            }
             println!(
                 "{}",
-                serde_json::to_string_pretty(&event).map_err(|e| e.to_string())?
+                serde_json::to_string_pretty(&response).map_err(|e| e.to_string())?
             );
             Ok(())
         }
@@ -536,6 +547,7 @@ fn print_usage() {
         "  snapshot [--json] [--state-dir=DIR]  print a runtime snapshot\n",
         "  mux-contract                        print the mux boundary summary\n",
         "  exec <json> [--state-dir=DIR]       process a runtime command from JSON\n",
+        "  exec-scoped <json> [--state-dir=DIR]  require Team isolation in the executing process\n",
         "  lease-mutex <absolute-canonical-dir> <expected-dev> <expected-ino> <safe-leaf>  hold native lease mutex over stdin JSON protocol\n",
         "  init <state-dir>                    initialize a fresh state directory\n",
     ));

package/crates/omx-runtime/tests/execution.rs

@@ -178,6 +178,10 @@ fn schema_json_subcommand_prints_valid_json() {
     let stdout = String::from_utf8(output.stdout).expect("utf8 stdout");
     let parsed: serde_json::Value = serde_json::from_str(&stdout).expect("valid JSON");
     assert_eq!(parsed["schema_version"], 1);
+    assert!(parsed["capabilities"]
+        .as_array()
+        .unwrap()
+        .contains(&serde_json::json!("team-mailbox-scope-v1")));
     assert!(parsed["commands"].is_array());
     assert!(parsed["events"].is_array());
 }
@@ -240,6 +244,64 @@ fn exec_subcommand_processes_json_command() {
     let stdout = String::from_utf8(output.stdout).expect("utf8 stdout");
     let parsed: serde_json::Value = serde_json::from_str(&stdout).expect("valid JSON");
     assert_eq!(parsed["event"], "SnapshotCaptured");
+    assert_eq!(parsed["dispatch_records"], serde_json::json!([]));
+}
+
+#[test]
+fn capture_snapshot_returns_event_authoritative_dispatch_records() {
+    let dir = std::env::temp_dir().join(format!("omx-capture-records-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    let state_arg = format!("--state-dir={}", dir.display());
+    let run = |command: &str| {
+        let output = Command::new(env!("CARGO_BIN_EXE_omx-runtime"))
+            .args(["exec-scoped", command, &state_arg])
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "{}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        serde_json::from_slice::<serde_json::Value>(&output.stdout).unwrap()
+    };
+    run(
+        r#"{"command":"QueueDispatch","request_id":"queued","target":"worker-1","metadata":{"team_name":"alpha"}}"#,
+    );
+    let stale = std::fs::read(dir.join("dispatch.json")).unwrap();
+    run(r#"{"command":"MarkNotified","request_id":"queued","channel":"tmux"}"#);
+    std::fs::write(dir.join("dispatch.json"), stale).unwrap();
+    let response = run(r#"{"command":"CaptureSnapshot"}"#);
+    let expected: serde_json::Value =
+        serde_json::from_slice(&std::fs::read(dir.join("dispatch.json")).unwrap()).unwrap();
+    assert_eq!(response["dispatch_records"], expected["records"]);
+    assert_eq!(response["dispatch_records"][0]["status"], "notified");
+    std::fs::remove_dir_all(dir).unwrap();
+}
+
+#[test]
+fn exec_scoped_checks_and_persists_team_scope_in_the_mutating_process() {
+    let dir = std::env::temp_dir().join("omx-runtime-test-exec-scoped");
+    let _ = std::fs::remove_dir_all(&dir);
+    let state_arg = format!("--state-dir={}", dir.display());
+    let command = r#"{"command":"CreateMailboxMessage","team_name":"alpha","message_id":"scoped","from_worker":"leader-fixed","to_worker":"worker-1","body":"private"}"#;
+    let output = Command::new(env!("CARGO_BIN_EXE_omx-runtime"))
+        .args(["exec-scoped", command, &state_arg, "--compact"])
+        .output()
+        .expect("ran omx-runtime");
+    assert!(
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let event: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    assert_eq!(event["team_name"], "alpha");
+    let mailbox: serde_json::Value =
+        serde_json::from_slice(&std::fs::read(dir.join("mailbox.json")).unwrap()).unwrap();
+    assert_eq!(mailbox["records"][0]["team_name"], "alpha");
+    let events: serde_json::Value =
+        serde_json::from_slice(&std::fs::read(dir.join("events.json")).unwrap()).unwrap();
+    assert_eq!(events[0]["team_name"], "alpha");
+    std::fs::remove_dir_all(dir).unwrap();
 }
 
 #[test]
@@ -522,7 +584,7 @@ fn exec_compact_immediately_persists_only_nonterminal_dispatch_records() {
     )
     .expect("valid events JSON");
     let events = events.as_array().expect("events array");
-    assert!(events
+    assert!(!events
         .iter()
         .any(|event| event["event"] == "SnapshotCaptured"));
     assert!(events

package/crates/omx-runtime-core/src/dispatch.rs

@@ -180,6 +180,59 @@ impl DispatchLog {
         &self.records
     }
 
+    pub(crate) fn recover_pending_hook_attempts(&mut self, projection: &Self) {
+        let projected: std::collections::HashMap<_, _> = projection
+            .records()
+            .iter()
+            .map(|record| (record.request_id.as_str(), record))
+            .collect();
+        for record in &mut self.records {
+            let Some(previous) = projected.get(record.request_id.as_str()) else {
+                continue;
+            };
+            if record.status != DispatchStatus::Pending
+                || previous.status != DispatchStatus::Pending
+                || record.target != previous.target
+            {
+                continue;
+            }
+            let Some(metadata) = record
+                .metadata
+                .as_mut()
+                .and_then(|value| value.as_object_mut())
+            else {
+                continue;
+            };
+            let Some(previous_metadata) = previous
+                .metadata
+                .as_ref()
+                .and_then(|value| value.as_object())
+            else {
+                continue;
+            };
+            let team = metadata.get("team_name").and_then(|value| value.as_str());
+            if team.map_or(true, str::is_empty)
+                || team
+                    != previous_metadata
+                        .get("team_name")
+                        .and_then(|value| value.as_str())
+            {
+                continue;
+            }
+            // Hook retries have no runtime event; all other fields remain event-owned.
+            for key in ["attempt_count", "last_attempt_at"] {
+                if let Some(value) = previous_metadata.get(key) {
+                    if (key == "attempt_count" && value.as_u64().is_some())
+                        || (key == "last_attempt_at" && value.is_string())
+                    {
+                        metadata.insert(key.into(), value.clone());
+                    }
+                }
+            }
+            record.reason = previous.reason.clone();
+        }
+    }
+
     pub fn request_ids(&self) -> impl Iterator<Item = &str> {
         self.records.iter().map(|record| record.request_id.as_str())
     }