oh-my-codex 0.20.2 → 0.20.5

package/Cargo.lock

@@ -20,9 +20,9 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "libc"
-version = "0.2.186"
+version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
 [[package]]
 name = "memchr"
@@ -32,7 +32,7 @@ checksum = "6b947ae49db0d222b1dbc6b113ce7248a3fc3a6ca21b696717bfc000ba4484d8"
 
 [[package]]
 name = "omx-api"
-version = "0.20.2"
+version = "0.20.5"
 dependencies = [
  "serde",
  "serde_json",
@@ -40,14 +40,14 @@ dependencies = [
 
 [[package]]
 name = "omx-explore-harness"
-version = "0.20.2"
+version = "0.20.5"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "omx-mux"
-version = "0.20.2"
+version = "0.20.5"
 dependencies = [
  "serde",
  "serde_json",
@@ -55,16 +55,19 @@ dependencies = [
 
 [[package]]
 name = "omx-runtime"
-version = "0.20.2"
+version = "0.20.5"
 dependencies = [
+ "fs2",
+ "libc",
  "omx-mux",
  "omx-runtime-core",
  "serde_json",
+ "windows-sys",
 ]
 
 [[package]]
 name = "omx-runtime-core"
-version = "0.20.2"
+version = "0.20.5"
 dependencies = [
  "fs2",
  "serde",
@@ -73,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "omx-sparkshell"
-version = "0.20.2"
+version = "0.20.5"
 dependencies = [
  "omx-mux",
 ]
@@ -98,9 +101,9 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.228"
+version = "1.0.229"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
 dependencies = [
  "serde_core",
  "serde_derive",
@@ -108,18 +111,18 @@ dependencies = [
 
 [[package]]
 name = "serde_core"
-version = "1.0.228"
+version = "1.0.229"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.228"
+version = "1.0.229"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -128,9 +131,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.150"
+version = "1.0.151"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
 dependencies = [
  "itoa",
  "memchr",
@@ -141,9 +144,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.117"
+version = "3.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+checksum = "a207d6d6a2b7fc470b80443726053f18a2481b7e1eee970597051596567987a3"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -178,6 +181,21 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "zmij"
 version = "1.0.21"

package/Cargo.toml

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

package/README.md

@@ -9,13 +9,13 @@
 [![npm version](https://img.shields.io/npm/v/oh-my-codex)](https://www.npmjs.com/package/oh-my-codex)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
-[![Discord](https://img.shields.io/discord/1452487457085063218?color=5865F2&logo=discord&logoColor=white&label=Discord)](https://discord.gg/sj4exxQ9v)
+[![Discord](https://img.shields.io/discord/1452487457085063218?color=5865F2&logo=discord&logoColor=white&label=Discord)](https://discord.gg/jq6jnSGABY)
 
 **Website:** https://yeachan-heo.github.io/oh-my-codex-website/
 
 **Docs:** [Getting Started](./docs/getting-started.html) · [Agents](./docs/agents.html) · [Skills](./docs/skills.html) · [Integrations](./docs/integrations.html) · [Demo](./DEMO.md) · [OpenClaw guide](./docs/openclaw-integration.md)
 
-**Community:** [Discord](https://discord.gg/sj4exxQ9v) — shared OMX/community server for oh-my-codex and related tooling.
+**Community:** [Discord](https://discord.gg/jq6jnSGABY) — shared OMX/community server for oh-my-codex and related tooling.
 
 ## Official project and package
 
@@ -165,6 +165,32 @@ created and recovered. `--worktree` also moves the launch into a separate git
 checkout, which is the safer default when using `--madmax`. Replace
 `feat/task` with a branch-like name for the task.
 
+### Concurrent standard conversations
+
+A standard launch owns one writable session pointer under its selected `OMX_ROOT`. A second ordinary `omx` launch from the same checkout therefore fails closed instead of sharing or silently changing that root. Give each additional conversation an explicit, distinct root:
+
+```bash
+omx
+OMX_ROOT="$HOME/.omx/instances/second-conversation" omx
+OMX_ROOT="$HOME/.omx/instances/third-conversation" omx
+```
+
+PowerShell:
+
+```powershell
+$env:OMX_ROOT = "$HOME/.omx/instances/second-conversation"
+omx
+```
+
+Command Prompt:
+
+```bat
+set "OMX_ROOT=%USERPROFILE%\.omx\instances\second-conversation"
+omx
+```
+
+User-specified roots are literal: launching twice with the same explicit `OMX_ROOT` remains a fatal owner conflict. Separate checkouts have separate default roots, while `--worktree` and `--madmax` keep their existing isolation behavior.
+
 ### Madmax and worktree launch safety
 
 `--madmax` is OMX shorthand for Codex

package/crates/omx-runtime/Cargo.toml

@@ -7,7 +7,11 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
+libc = "0.2"
 omx-mux = { path = "../omx-mux" }
 omx-runtime-core = { path = "../omx-runtime-core" }
+fs2 = "0.4"
 serde_json = "1"
 
+[target.'cfg(target_os = "windows")'.dependencies]
+windows-sys = { version = "0.61", features = ["Win32_System_Threading", "Win32_Foundation"] }

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

@@ -1,3 +1,4 @@
+use fs2::FileExt;
 use omx_mux::{canonical_contract_summary, MuxAdapter, MuxOperation, MuxTarget, TmuxAdapter};
 use omx_runtime_core::{runtime_contract_summary, RuntimeCommand, RuntimeEngine};
 use std::env;
@@ -71,9 +72,31 @@ fn run() -> Result<(), 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");
+            let _mutation_lock = if let Some(dir) = state_dir {
+                std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;
+                let lock =
+                    std::fs::File::create(std::path::Path::new(dir).join("runtime-mutation.lock"))
+                        .map_err(|e| e.to_string())?;
+                lock.lock_exclusive().map_err(|e| e.to_string())?;
+                Some(lock)
+            } else {
+                None
+            };
             let mut engine = match state_dir {
-                Some(dir) => RuntimeEngine::load(dir)
-                    .unwrap_or_else(|_| RuntimeEngine::new().with_state_dir(dir)),
+                Some(dir) => match RuntimeEngine::load(dir) {
+                    Ok(engine) => engine,
+                    Err(error) => {
+                        let has_persisted_state = ["events.json", "snapshot.json", "mailbox.json"]
+                            .iter()
+                            .any(|name| std::path::Path::new(dir).join(name).exists());
+                        if has_persisted_state {
+                            return Err(format!(
+                                "failed to load authoritative runtime state: {error}"
+                            ));
+                        }
+                        RuntimeEngine::new().with_state_dir(dir)
+                    }
+                },
                 None => RuntimeEngine::new(),
             };
 
@@ -100,6 +123,8 @@ fn run() -> Result<(), String> {
             );
             Ok(())
         }
+        Some("fs-rename-no-replace") => run_fs_rename_no_replace(&args[1..]),
+        Some("process-identity") => run_process_identity(&args[1..]),
         Some("init") => {
             let dir = second.ok_or("init requires a state directory path")?;
             let engine = RuntimeEngine::new().with_state_dir(dir);
@@ -111,12 +136,400 @@ fn run() -> Result<(), String> {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
+enum FsRenameOutcome {
+    Moved,
+    NotMoved,
+    Unsupported(&'static str),
+}
+
+fn run_fs_rename_no_replace(args: &[String]) -> Result<(), String> {
+    if args.len() != 2 {
+        return Err("fs-rename-no-replace requires exactly <from> and <to> paths".to_string());
+    }
+
+    let from = validate_absolute_path(&args[0], "from")?;
+    let to = validate_absolute_path(&args[1], "to")?;
+    let outcome = fs_rename_no_replace(&from, &to)?;
+    let json = match outcome {
+        FsRenameOutcome::Moved => serde_json::json!({ "outcome": "moved" }),
+        FsRenameOutcome::NotMoved => {
+            serde_json::json!({ "outcome": "not-moved", "code": "EEXIST" })
+        }
+        FsRenameOutcome::Unsupported(code) => {
+            serde_json::json!({ "outcome": "unsupported", "code": code })
+        }
+    };
+    println!(
+        "{}",
+        serde_json::to_string(&json).map_err(|error| error.to_string())?
+    );
+    Ok(())
+}
+
+fn validate_absolute_path(raw: &str, name: &str) -> Result<std::ffi::CString, String> {
+    if raw.is_empty() {
+        return Err(format!("{name} path must be a non-empty absolute path"));
+    }
+    if !std::path::Path::new(raw).is_absolute() {
+        return Err(format!("{name} path must be absolute"));
+    }
+    std::ffi::CString::new(raw.as_bytes())
+        .map_err(|_| format!("{name} path contains an embedded NUL byte"))
+}
+
+#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+fn fs_rename_no_replace(
+    from: &std::ffi::CString,
+    to: &std::ffi::CString,
+) -> Result<FsRenameOutcome, String> {
+    let result = unsafe {
+        libc::renameat2(
+            libc::AT_FDCWD,
+            from.as_ptr(),
+            libc::AT_FDCWD,
+            to.as_ptr(),
+            libc::RENAME_NOREPLACE,
+        )
+    };
+    if result == 0 {
+        return Ok(FsRenameOutcome::Moved);
+    }
+
+    let error = std::io::Error::last_os_error();
+    match error.raw_os_error() {
+        Some(libc::EEXIST) => Ok(FsRenameOutcome::NotMoved),
+        Some(libc::ENOSYS) => Ok(FsRenameOutcome::Unsupported("ENOSYS")),
+        Some(libc::EINVAL) => Ok(FsRenameOutcome::Unsupported("EINVAL")),
+        Some(libc::ENOTSUP) => Ok(FsRenameOutcome::Unsupported("ENOTSUP")),
+        Some(code) => Err(format!("renameat2 failed with errno {code}: {error}")),
+        None => Err(format!("renameat2 failed: {error}")),
+    }
+}
+
+#[cfg(all(target_os = "linux", target_env = "musl"))]
+fn fs_rename_no_replace(
+    from: &std::ffi::CString,
+    to: &std::ffi::CString,
+) -> Result<FsRenameOutcome, String> {
+    // libc 0.2.189 added a musl binding for renameat2, but the release
+    // runner's older musl exported symbol surface does not include it,
+    // causing an undefined-symbol link failure. Invoke the syscall
+    // directly via libc::syscall so the atomic no-replace rename works
+    // regardless of the musl version. The outcome and errno mapping are
+    // equivalent to the libc::renameat2 wrapper above (both classify the
+    // same errno values to the same FsRenameOutcome variants).
+    let result = unsafe {
+        libc::syscall(
+            libc::SYS_renameat2,
+            libc::AT_FDCWD,
+            from.as_ptr(),
+            libc::AT_FDCWD,
+            to.as_ptr(),
+            libc::RENAME_NOREPLACE,
+        )
+    };
+    if result == 0 {
+        return Ok(FsRenameOutcome::Moved);
+    }
+
+    let error = std::io::Error::last_os_error();
+    match error.raw_os_error() {
+        Some(libc::EEXIST) => Ok(FsRenameOutcome::NotMoved),
+        Some(libc::ENOSYS) => Ok(FsRenameOutcome::Unsupported("ENOSYS")),
+        Some(libc::EINVAL) => Ok(FsRenameOutcome::Unsupported("EINVAL")),
+        Some(libc::ENOTSUP) => Ok(FsRenameOutcome::Unsupported("ENOTSUP")),
+        Some(code) => Err(format!("renameat2 failed with errno {code}: {error}")),
+        None => Err(format!("renameat2 failed: {error}")),
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn fs_rename_no_replace(
+    from: &std::ffi::CString,
+    to: &std::ffi::CString,
+) -> Result<FsRenameOutcome, String> {
+    let result = unsafe { libc::renamex_np(from.as_ptr(), to.as_ptr(), libc::RENAME_EXCL) };
+    if result == 0 {
+        return Ok(FsRenameOutcome::Moved);
+    }
+
+    let error = std::io::Error::last_os_error();
+    match error.raw_os_error() {
+        Some(libc::EEXIST) => Ok(FsRenameOutcome::NotMoved),
+        Some(libc::ENOSYS) => Ok(FsRenameOutcome::Unsupported("ENOSYS")),
+        Some(libc::EINVAL) | Some(libc::ENOTSUP) => Ok(FsRenameOutcome::Unsupported("ENOTSUP")),
+        Some(code) => Err(format!("renamex_np failed with errno {code}: {error}")),
+        None => Err(format!("renamex_np failed: {error}")),
+    }
+}
+
+#[cfg(not(any(target_os = "linux", target_os = "macos")))]
+fn fs_rename_no_replace(
+    _from: &std::ffi::CString,
+    _to: &std::ffi::CString,
+) -> Result<FsRenameOutcome, String> {
+    Ok(FsRenameOutcome::Unsupported("platform"))
+}
+
+// ---------------------------------------------------------------------------
+// process-identity subcommand
+// ---------------------------------------------------------------------------
+
+#[allow(dead_code)]
+enum ProcessIdentityError {
+    Denied,
+    Gone,
+    Unsupported,
+    Error(String),
+}
+
+struct ProcessIdentityResult {
+    platform: &'static str,
+    birth: String,
+    cmdline: Option<String>,
+}
+
+fn run_process_identity(args: &[String]) -> Result<(), String> {
+    if args.len() != 1 {
+        return Err("process-identity requires exactly <pid>".to_string());
+    }
+    let pid: u32 = args[0].parse().map_err(|_| {
+        format!(
+            "process-identity pid must be a positive integer, got: {}",
+            args[0]
+        )
+    })?;
+    if pid == 0 {
+        return Err("process-identity pid must be > 0".to_string());
+    }
+    let result = process_identity(pid);
+    let json = match result {
+        Ok(identity) => {
+            let mut obj = serde_json::json!({
+                "platform": identity.platform,
+                "birth": identity.birth,
+            });
+            if let Some(cmdline) = &identity.cmdline {
+                obj["cmdline"] = serde_json::Value::String(cmdline.clone());
+            }
+            obj
+        }
+        Err(ProcessIdentityError::Denied) => {
+            serde_json::json!({ "outcome": "denied" })
+        }
+        Err(ProcessIdentityError::Gone) => {
+            serde_json::json!({ "outcome": "gone" })
+        }
+        Err(ProcessIdentityError::Unsupported) => {
+            serde_json::json!({ "outcome": "unsupported" })
+        }
+        Err(ProcessIdentityError::Error(reason)) => {
+            serde_json::json!({ "outcome": "error", "reason": reason })
+        }
+    };
+    println!(
+        "{}",
+        serde_json::to_string(&json).map_err(|error| error.to_string())?
+    );
+    Ok(())
+}
+
+#[cfg(target_os = "linux")]
+fn process_identity(pid: u32) -> Result<ProcessIdentityResult, ProcessIdentityError> {
+    let stat_path = format!("/proc/{pid}/stat");
+    let stat_content = match std::fs::read_to_string(&stat_path) {
+        Ok(content) => content,
+        Err(e) => {
+            return match e.raw_os_error() {
+                Some(libc::ENOENT) | Some(libc::ESRCH) => Err(ProcessIdentityError::Gone),
+                Some(libc::EACCES) | Some(libc::EPERM) => Err(ProcessIdentityError::Denied),
+                _ => Err(ProcessIdentityError::Error(format!(
+                    "read stat failed: {e}"
+                ))),
+            };
+        }
+    };
+
+    // Parse field 22: skip past the comm field (in parens) then count fields
+    let command_end = stat_content.rfind(')');
+    let start_ticks = match command_end {
+        Some(idx) => {
+            let fields: Vec<&str> = stat_content[idx + 1..].split_whitespace().collect();
+            // After ')', field 1 is state, field 2 is ppid, ..., field 20 is starttime
+            // (field 3 in the full stat is ppid; the 20th field after ')' is starttime)
+            if fields.len() <= 19 {
+                return Err(ProcessIdentityError::Error(
+                    "stat content too short for starttime field".to_string(),
+                ));
+            }
+            match fields[19].parse::<u64>() {
+                Ok(v) => v,
+                Err(_) => {
+                    return Err(ProcessIdentityError::Error(format!(
+                        "starttime field is not a valid integer: {}",
+                        fields[19]
+                    )))
+                }
+            }
+        }
+        None => {
+            return Err(ProcessIdentityError::Error(
+                "stat content has no closing paren".to_string(),
+            ))
+        }
+    };
+
+    // Read cmdline if accessible
+    let cmdline = read_linux_cmdline(pid);
+
+    Ok(ProcessIdentityResult {
+        platform: "linux",
+        birth: start_ticks.to_string(),
+        cmdline,
+    })
+}
+
+#[cfg(target_os = "linux")]
+fn read_linux_cmdline(pid: u32) -> Option<String> {
+    use std::io::Read;
+    let cmdline_path = format!("/proc/{pid}/cmdline");
+    let mut content = String::new();
+    let result =
+        std::fs::File::open(&cmdline_path).and_then(|mut f| f.read_to_string(&mut content));
+    match result {
+        Ok(_) => {
+            let text = content.replace('\u{0}', " ").trim().to_string();
+            if text.is_empty() {
+                None
+            } else {
+                Some(text)
+            }
+        }
+        Err(_) => None,
+    }
+}
+
+// Darwin: proc_pidinfo with PROC_PIDTBSDINFO for pbi_start_tvsec/pbi_start_tvusec
+#[cfg(target_os = "macos")]
+fn process_identity(pid: u32) -> Result<ProcessIdentityResult, ProcessIdentityError> {
+    // Use libc's maintained Darwin ABI definition instead of a partial local
+    // prefix. PROC_PIDTBSDINFO requires a full proc_bsdinfo-sized buffer.
+    let mut process_info: libc::proc_bsdinfo = unsafe { std::mem::zeroed() };
+    let buffer_size = std::mem::size_of::<libc::proc_bsdinfo>() as libc::c_int;
+    let bytes_read = unsafe {
+        libc::proc_pidinfo(
+            pid as libc::c_int,
+            libc::PROC_PIDTBSDINFO,
+            0,
+            &mut process_info as *mut _ as *mut libc::c_void,
+            buffer_size,
+        )
+    };
+
+    if bytes_read <= 0 {
+        let errno_val = std::io::Error::last_os_error().raw_os_error().unwrap_or(0);
+        return match errno_val {
+            libc::EPERM | libc::EACCES => Err(ProcessIdentityError::Denied),
+            libc::ESRCH | libc::ENOENT => Err(ProcessIdentityError::Gone),
+            _ => Err(ProcessIdentityError::Error(format!(
+                "proc_pidinfo(PROC_PIDTBSDINFO) failed: errno={}",
+                errno_val
+            ))),
+        };
+    }
+    if bytes_read != buffer_size {
+        return Err(ProcessIdentityError::Error(format!(
+            "proc_pidinfo(PROC_PIDTBSDINFO) returned {bytes_read} bytes; expected {buffer_size}"
+        )));
+    }
+
+    // Birth is exact decimal string: seconds.microseconds since Unix epoch.
+    // Two processes started in the same second will differ in microseconds
+    // unless they genuinely started at the same microsecond instant.
+    let birth = format!(
+        "{}.{}",
+        process_info.pbi_start_tvsec, process_info.pbi_start_tvusec
+    );
+
+    Ok(ProcessIdentityResult {
+        platform: "darwin",
+        birth,
+        cmdline: None,
+    })
+}
+
+// Windows: OpenProcess + GetProcessTimes for creation FILETIME
+#[cfg(target_os = "windows")]
+fn process_identity(pid: u32) -> Result<ProcessIdentityResult, ProcessIdentityError> {
+    use windows_sys::Win32::Foundation::{CloseHandle, FILETIME};
+    use windows_sys::Win32::System::Threading::{
+        GetProcessTimes, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION,
+    };
+
+    let handle = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) };
+    if handle.is_null() {
+        let err = unsafe { windows_sys::Win32::Foundation::GetLastError() };
+        return match err {
+            5 => Err(ProcessIdentityError::Denied), // ERROR_ACCESS_DENIED
+            87 => Err(ProcessIdentityError::Gone),  // ERROR_INVALID_PARAMETER
+            _ => Err(ProcessIdentityError::Error(format!(
+                "OpenProcess failed: error code {}",
+                err
+            ))),
+        };
+    }
+
+    // RAII guard: CloseHandle on all paths
+    struct HandleGuard(*mut std::ffi::c_void);
+    impl Drop for HandleGuard {
+        fn drop(&mut self) {
+            if !self.0.is_null() {
+                unsafe { CloseHandle(self.0) };
+            }
+        }
+    }
+    let _guard = HandleGuard(handle);
+
+    let mut creation: FILETIME = unsafe { std::mem::zeroed() };
+    let mut exit: FILETIME = unsafe { std::mem::zeroed() };
+    let mut kernel: FILETIME = unsafe { std::mem::zeroed() };
+    let mut user: FILETIME = unsafe { std::mem::zeroed() };
+
+    let ok = unsafe { GetProcessTimes(handle, &mut creation, &mut exit, &mut kernel, &mut user) };
+
+    if ok == 0 {
+        let err = unsafe { windows_sys::Win32::Foundation::GetLastError() };
+        return Err(ProcessIdentityError::Error(format!(
+            "GetProcessTimes failed: error code {}",
+            err
+        )));
+    }
+
+    // Combine FILETIME (100ns intervals since 1601-01-01) into u64
+    let birth_u64 = ((creation.dwHighDateTime as u64) << 32) | (creation.dwLowDateTime as u64);
+
+    Ok(ProcessIdentityResult {
+        platform: "win32",
+        birth: birth_u64.to_string(),
+        cmdline: None,
+    })
+}
+
+// Unsupported platform fallback
+#[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+fn process_identity(_pid: u32) -> Result<ProcessIdentityResult, ProcessIdentityError> {
+    Err(ProcessIdentityError::Unsupported)
+}
+
 fn print_usage() {
     println!(concat!(
         "usage: omx-runtime <command> [options]\n",
         "\n",
         "commands:\n",
         "  schema [--json]                     print the runtime contract summary\n",
+        "  fs-rename-no-replace <from> <to>       atomically move without replacing destination\n",
+        "  process-identity <pid>              print process birth identity as JSON\n",
         "  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",