oh-my-codex 0.10.5 → 0.11.0

package/Cargo.lock

@@ -2,10 +2,170 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "fs2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "libc"
+version = "0.2.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
 [[package]]
 name = "omx-explore-harness"
-version = "0.10.5"
+version = "0.11.0"
+
+[[package]]
+name = "omx-mux"
+version = "0.11.0"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "omx-runtime"
+version = "0.11.0"
+dependencies = [
+ "omx-mux",
+ "omx-runtime-core",
+ "serde_json",
+]
+
+[[package]]
+name = "omx-runtime-core"
+version = "0.11.0"
+dependencies = [
+ "fs2",
+ "serde",
+ "serde_json",
+]
 
 [[package]]
 name = "omx-sparkshell"
-version = "0.10.5"
+version = "0.11.0"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"

package/Cargo.toml

@@ -1,9 +1,15 @@
 [workspace]
-members = ["crates/omx-explore", "native/omx-sparkshell"]
+members = [
+  "crates/omx-explore",
+  "crates/omx-mux",
+  "crates/omx-runtime-core",
+  "crates/omx-runtime",
+  "crates/omx-sparkshell",
+]
 resolver = "2"
 
 [workspace.package]
-version = "0.10.5"
+version = "0.11.0"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/Yeachan-Heo/oh-my-codex"

package/README.md

@@ -112,6 +112,7 @@ omx team 3:executor "ship the scoped task with verification"
 OMX treats default model selection as a small explicit contract:
 
 - `OMX_DEFAULT_FRONTIER_MODEL` — canonical frontier/default leader model
+- `OMX_DEFAULT_STANDARD_MODEL` — canonical standard subagent model
 - `OMX_DEFAULT_SPARK_MODEL` — canonical spark / low-complexity worker model
 
 If upstream defaults change, update the single canonical source instead of scattering model literals across prompts/docs/runtime.
@@ -122,6 +123,7 @@ For local-model setups, you can persist overrides in `~/.codex/.omx-config.json`
 {
   "env": {
     "OMX_DEFAULT_FRONTIER_MODEL": "your-frontier-model",
+    "OMX_DEFAULT_STANDARD_MODEL": "your-standard-model",
     "OMX_DEFAULT_SPARK_MODEL": "your-spark-model"
   }
 }
@@ -133,7 +135,7 @@ Resolution order:
 2. `.omx-config.json` `env` overrides
 3. OMX built-in canonical defaults
 
-The same config-driven env overrides are forwarded when OMX launches native helpers such as `omx sparkshell`, so local-model routing stays consistent.
+The same config-driven env overrides are forwarded when OMX launches native helpers such as `omx sparkshell`, so local-model routing stays consistent. By default OMX ships a three-lane split: frontier roles on `gpt-5.4`, standard subagents on `gpt-5.4-mini`, and spark/fast roles on `gpt-5.3-codex-spark`.
 
 Recommended trusted-environment launch profile:
 

package/crates/omx-mux/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "omx-mux"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"

package/crates/omx-mux/src/lib.rs

@@ -0,0 +1,91 @@
+mod tmux;
+mod types;
+
+pub use tmux::TmuxAdapter;
+pub use types::*;
+
+pub fn canonical_contract_summary() -> String {
+    format!(
+        "mux-operations={operations}\nmux-target-kinds={target_kinds}\nsubmit-policy={submit_policy}\nreadiness={readiness}\nconfirmation={confirmation}\nadapter=tmux",
+        operations = MUX_OPERATION_NAMES.join(", "),
+        target_kinds = MUX_TARGET_KINDS.join(", "),
+        submit_policy = SubmitPolicy::enter(2, 100),
+        readiness = PaneReadinessReason::Ok,
+        confirmation = DeliveryConfirmation::Confirmed,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn canonical_contract_names_remain_generic() {
+        assert_eq!(
+            MUX_OPERATION_NAMES,
+            &[
+                "resolve-target",
+                "send-input",
+                "capture-tail",
+                "inspect-liveness",
+                "attach",
+                "detach",
+            ]
+        );
+        assert_eq!(MUX_TARGET_KINDS, &["delivery-handle", "detached"]);
+    }
+
+    #[test]
+    fn input_envelope_normalizes_literal_text_for_typed_send() {
+        let envelope = InputEnvelope::new("hello\nbridge", SubmitPolicy::enter(2, 100));
+        assert_eq!(envelope.normalized_text(), "hello bridge");
+        assert_eq!(envelope.submit.presses(), 2);
+        assert_eq!(
+            format!("{}", envelope.submit),
+            "enter(presses=2, delay_ms=100)"
+        );
+    }
+
+    #[test]
+    fn confirmation_policy_defaults_match_notify_hook_expectations() {
+        let policy = ConfirmationPolicy::default();
+        assert_eq!(policy.narrow_capture_lines, 8);
+        assert_eq!(policy.wide_capture_lines, 80);
+        assert_eq!(policy.verify_delay_ms, 250);
+        assert_eq!(policy.verify_rounds, 3);
+        assert!(policy.allow_active_task_confirmation);
+        assert!(policy.require_ready_for_worker_targets);
+        assert_eq!(policy.non_empty_tail_lines, 24);
+        assert!(policy.retry_submit_without_retyping);
+    }
+
+    #[test]
+    fn serde_roundtrip_mux_operation() {
+        let op = MuxOperation::SendInput {
+            target: MuxTarget::DeliveryHandle("sess:0.1".into()),
+            envelope: InputEnvelope::new("test", SubmitPolicy::enter(1, 50)),
+        };
+        let json = serde_json::to_string(&op).expect("serialize");
+        let deserialized: MuxOperation = serde_json::from_str(&json).expect("deserialize");
+        assert_eq!(format!("{deserialized:?}"), format!("{op:?}"));
+    }
+
+    #[test]
+    fn serde_roundtrip_mux_outcome() {
+        let outcome = MuxOutcome::TailCaptured {
+            visible_lines: 80,
+            body: "hello".into(),
+        };
+        let json = serde_json::to_string(&outcome).expect("serialize");
+        let deserialized: MuxOutcome = serde_json::from_str(&json).expect("deserialize");
+        assert_eq!(deserialized, outcome);
+    }
+
+    #[test]
+    fn serde_roundtrip_mux_error() {
+        let err = MuxError::InvalidTarget("bad".into());
+        let json = serde_json::to_string(&err).expect("serialize");
+        let deserialized: MuxError = serde_json::from_str(&json).expect("deserialize");
+        assert_eq!(deserialized, err);
+    }
+}

package/crates/omx-mux/src/tmux.rs

@@ -0,0 +1,282 @@
+use std::process::Command;
+use std::thread;
+use std::time::Duration;
+
+use crate::types::{MuxAdapter, MuxError, MuxOperation, MuxOutcome, MuxTarget, SubmitPolicy};
+
+/// Run a tmux command with the given arguments. Returns stdout on success.
+fn run_tmux(args: &[&str]) -> Result<String, MuxError> {
+    let output = Command::new("tmux")
+        .args(args)
+        .output()
+        .map_err(|e| MuxError::AdapterFailed(format!("failed to run tmux: {e}")))?;
+
+    if output.status.success() {
+        String::from_utf8(output.stdout)
+            .map_err(|e| MuxError::AdapterFailed(format!("invalid utf-8 from tmux: {e}")))
+    } else {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        Err(MuxError::AdapterFailed(format!(
+            "tmux {} failed: {}",
+            args.first().unwrap_or(&""),
+            stderr.trim()
+        )))
+    }
+}
+
+/// Extract a tmux target string from a `MuxTarget`.
+fn resolve_target_handle(target: &MuxTarget) -> Result<String, MuxError> {
+    match target {
+        MuxTarget::DeliveryHandle(handle) => {
+            if handle.is_empty() {
+                Err(MuxError::InvalidTarget("empty delivery handle".into()))
+            } else {
+                Ok(handle.clone())
+            }
+        }
+        MuxTarget::Detached => Err(MuxError::InvalidTarget(
+            "cannot operate on a detached target".into(),
+        )),
+    }
+}
+
+/// Extract the session name portion from a tmux target string (e.g. "mysess:0.1" -> "mysess").
+fn session_from_handle(handle: &str) -> &str {
+    handle.split(':').next().unwrap_or(handle)
+}
+
+/// Build the argument list for `tmux send-keys` with literal text.
+pub(crate) fn build_send_keys_args<'a>(target: &'a str, text: &'a str) -> Vec<&'a str> {
+    vec!["send-keys", "-t", target, "-l", text]
+}
+
+/// Build the argument list for `tmux send-keys` enter press.
+pub(crate) fn build_enter_key_args(target: &str) -> Vec<String> {
+    vec!["send-keys".into(), "-t".into(), target.into(), "C-m".into()]
+}
+
+/// Build the argument list for `tmux capture-pane`.
+pub(crate) fn build_capture_pane_args(target: &str, visible_lines: usize) -> Vec<String> {
+    vec![
+        "capture-pane".into(),
+        "-t".into(),
+        target.into(),
+        "-p".into(),
+        "-S".into(),
+        format!("-{visible_lines}"),
+    ]
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct TmuxAdapter;
+
+impl TmuxAdapter {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn status(&self) -> &'static str {
+        "tmux adapter ready"
+    }
+
+    fn do_resolve_target(&self, target: &MuxTarget) -> Result<MuxOutcome, MuxError> {
+        let handle = resolve_target_handle(target)?;
+
+        // Verify the target exists by listing all panes
+        let pane_list = run_tmux(&[
+            "list-panes",
+            "-a",
+            "-F",
+            "#{session_name}:#{window_index}.#{pane_index}",
+        ])?;
+
+        let found = pane_list.lines().any(|line| line.trim() == handle);
+        if found {
+            Ok(MuxOutcome::TargetResolved {
+                resolved_handle: handle,
+            })
+        } else {
+            Err(MuxError::InvalidTarget(format!("pane not found: {handle}")))
+        }
+    }
+
+    fn do_send_input(
+        &self,
+        target: &MuxTarget,
+        envelope: &crate::types::InputEnvelope,
+    ) -> Result<MuxOutcome, MuxError> {
+        let handle = resolve_target_handle(target)?;
+        let text = envelope.normalized_text();
+
+        // Send the literal text
+        let args = build_send_keys_args(&handle, &text);
+        run_tmux(&args)?;
+
+        // Send enter presses per submit policy
+        if let SubmitPolicy::Enter { presses, delay_ms } = &envelope.submit {
+            for i in 0..*presses {
+                if i > 0 && *delay_ms > 0 {
+                    thread::sleep(Duration::from_millis(*delay_ms));
+                }
+                let enter_args = build_enter_key_args(&handle);
+                let str_args: Vec<&str> = enter_args.iter().map(|s| s.as_str()).collect();
+                run_tmux(&str_args)?;
+            }
+        }
+
+        Ok(MuxOutcome::InputAccepted {
+            bytes_written: text.len(),
+        })
+    }
+
+    fn do_capture_tail(
+        &self,
+        target: &MuxTarget,
+        visible_lines: usize,
+    ) -> Result<MuxOutcome, MuxError> {
+        let handle = resolve_target_handle(target)?;
+        let args = build_capture_pane_args(&handle, visible_lines);
+        let str_args: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
+        let body = run_tmux(&str_args)?;
+
+        Ok(MuxOutcome::TailCaptured {
+            visible_lines,
+            body,
+        })
+    }
+
+    fn do_inspect_liveness(&self, target: &MuxTarget) -> Result<MuxOutcome, MuxError> {
+        let handle = resolve_target_handle(target)?;
+        let session = session_from_handle(&handle);
+
+        let output = Command::new("tmux")
+            .args(["has-session", "-t", session])
+            .output()
+            .map_err(|e| MuxError::AdapterFailed(format!("failed to run tmux: {e}")))?;
+
+        Ok(MuxOutcome::LivenessChecked {
+            alive: output.status.success(),
+        })
+    }
+
+    fn do_attach(&self, target: &MuxTarget) -> Result<MuxOutcome, MuxError> {
+        let handle = resolve_target_handle(target)?;
+        run_tmux(&["attach-session", "-t", &handle])?;
+        Ok(MuxOutcome::Attached { handle })
+    }
+
+    fn do_detach(&self, target: &MuxTarget) -> Result<MuxOutcome, MuxError> {
+        let handle = resolve_target_handle(target)?;
+        run_tmux(&["detach-client", "-t", &handle])?;
+        Ok(MuxOutcome::Detached { handle })
+    }
+}
+
+impl MuxAdapter for TmuxAdapter {
+    fn adapter_name(&self) -> &'static str {
+        "tmux"
+    }
+
+    fn execute(&self, operation: &MuxOperation) -> Result<MuxOutcome, MuxError> {
+        match operation {
+            MuxOperation::ResolveTarget { target } => self.do_resolve_target(target),
+            MuxOperation::SendInput { target, envelope } => self.do_send_input(target, envelope),
+            MuxOperation::CaptureTail {
+                target,
+                visible_lines,
+            } => self.do_capture_tail(target, *visible_lines),
+            MuxOperation::InspectLiveness { target } => self.do_inspect_liveness(target),
+            MuxOperation::Attach { target } => self.do_attach(target),
+            MuxOperation::Detach { target } => self.do_detach(target),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::{InputEnvelope, SubmitPolicy};
+
+    #[test]
+    fn resolve_target_handle_rejects_empty() {
+        let err = resolve_target_handle(&MuxTarget::DeliveryHandle(String::new()))
+            .expect_err("should reject empty");
+        assert!(matches!(err, MuxError::InvalidTarget(_)));
+    }
+
+    #[test]
+    fn resolve_target_handle_rejects_detached() {
+        let err = resolve_target_handle(&MuxTarget::Detached).expect_err("should reject detached");
+        assert!(matches!(err, MuxError::InvalidTarget(_)));
+    }
+
+    #[test]
+    fn resolve_target_handle_accepts_valid() {
+        let handle = resolve_target_handle(&MuxTarget::DeliveryHandle("sess:0.1".into()))
+            .expect("should accept valid handle");
+        assert_eq!(handle, "sess:0.1");
+    }
+
+    #[test]
+    fn session_from_handle_extracts_session() {
+        assert_eq!(session_from_handle("mysess:0.1"), "mysess");
+        assert_eq!(session_from_handle("plain"), "plain");
+        assert_eq!(session_from_handle("a:b:c"), "a");
+    }
+
+    #[test]
+    fn build_send_keys_args_constructs_correct_args() {
+        let args = build_send_keys_args("sess:0.1", "hello world");
+        assert_eq!(
+            args,
+            vec!["send-keys", "-t", "sess:0.1", "-l", "hello world"]
+        );
+    }
+
+    #[test]
+    fn build_enter_key_args_constructs_correct_args() {
+        let args = build_enter_key_args("sess:0.1");
+        assert_eq!(args, vec!["send-keys", "-t", "sess:0.1", "C-m"]);
+    }
+
+    #[test]
+    fn build_capture_pane_args_constructs_correct_args() {
+        let args = build_capture_pane_args("sess:0.1", 80);
+        assert_eq!(
+            args,
+            vec!["capture-pane", "-t", "sess:0.1", "-p", "-S", "-80"]
+        );
+    }
+
+    #[test]
+    fn send_keys_uses_normalized_text() {
+        let envelope = InputEnvelope::new("line1\nline2", SubmitPolicy::None);
+        let text = envelope.normalized_text();
+        assert_eq!(text, "line1 line2");
+        let args = build_send_keys_args("t:0.0", &text);
+        assert_eq!(args[4], "line1 line2");
+    }
+
+    #[test]
+    fn adapter_name_is_tmux() {
+        let adapter = TmuxAdapter::new();
+        assert_eq!(adapter.adapter_name(), "tmux");
+    }
+
+    #[test]
+    fn status_reports_ready() {
+        let adapter = TmuxAdapter::new();
+        assert_eq!(adapter.status(), "tmux adapter ready");
+    }
+
+    #[test]
+    fn execute_rejects_detached_target() {
+        let adapter = TmuxAdapter::new();
+        let result = adapter.execute(&MuxOperation::ResolveTarget {
+            target: MuxTarget::Detached,
+        });
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(matches!(err, MuxError::InvalidTarget(_)));
+    }
+}