oh-my-codex 0.18.0 → 0.18.2

package/Cargo.lock

@@ -32,7 +32,7 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "omx-api"
-version = "0.18.0"
+version = "0.18.2"
 dependencies = [
  "serde",
  "serde_json",
@@ -40,14 +40,14 @@ dependencies = [
 
 [[package]]
 name = "omx-explore-harness"
-version = "0.18.0"
+version = "0.18.2"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "omx-mux"
-version = "0.18.0"
+version = "0.18.2"
 dependencies = [
  "serde",
  "serde_json",
@@ -55,7 +55,7 @@ dependencies = [
 
 [[package]]
 name = "omx-runtime"
-version = "0.18.0"
+version = "0.18.2"
 dependencies = [
  "omx-mux",
  "omx-runtime-core",
@@ -64,7 +64,7 @@ dependencies = [
 
 [[package]]
 name = "omx-runtime-core"
-version = "0.18.0"
+version = "0.18.2"
 dependencies = [
  "fs2",
  "serde",
@@ -73,7 +73,7 @@ dependencies = [
 
 [[package]]
 name = "omx-sparkshell"
-version = "0.18.0"
+version = "0.18.2"
 dependencies = [
  "omx-mux",
 ]

package/Cargo.toml

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

package/README.md

@@ -17,6 +17,12 @@
 
 **Community:** [Discord](https://discord.gg/PUwSMR9XNk) — shared OMX/community server for oh-my-codex and related tooling.
 
+## Official project and package
+
+The official/original OMX project is this repository, [`Yeachan-Heo/oh-my-codex`](https://github.com/Yeachan-Heo/oh-my-codex), and the official npm package for this project is [`oh-my-codex`](https://www.npmjs.com/package/oh-my-codex). Install this project with `npm install -g oh-my-codex` (or alongside Codex CLI as shown below).
+
+Third-party projects or forks that use names such as “OMX v2” are not official continuations, replacements, or release lines for this repository unless this README or the docs explicitly say so. When in doubt, trust this repository and the `oh-my-codex` package as the official install target.
+
 OMX is a workflow layer for [OpenAI Codex CLI](https://github.com/openai/codex).
 
 <table>
@@ -28,7 +34,7 @@ OMX is a workflow layer for [OpenAI Codex CLI](https://github.com/openai/codex).
 It keeps Codex as the execution engine and makes it easier to:
 - start a stronger Codex session by default
 - run one consistent workflow from clarification to completion
-- invoke the canonical skills with `$deep-interview`, `$ralplan`, `$team`, and `$ralph`
+- invoke the canonical default workflow with `$deep-interview`, `$ralplan`, and `$ultragoal`
 - keep project guidance, plans, logs, and state in `.omx/`
 
 ## Core Maintainers
@@ -58,34 +64,50 @@ It keeps Codex as the execution engine and makes it easier to:
 
 If you want the default OMX experience, start here:
 
+Choose one install path. If Codex CLI is already installed (Homebrew, npm, or another supported method):
+
 ```bash
-npm install -g @openai/codex oh-my-codex
+codex --version
+npm install -g oh-my-codex
+omx setup
 omx --madmax --high
 ```
 
+If you do not have Codex CLI yet and want npm to manage it:
+
+```bash
+npm install -g @openai/codex
+npm install -g oh-my-codex
+omx setup
+```
+
+Do not run a combined `npm install -g @openai/codex oh-my-codex` over an existing Homebrew-owned `codex` binary such as `/opt/homebrew/bin/codex`; npm may fail with `EEXIST` when `@openai/codex` tries to create the same binary. OMX only needs a working, authenticated `codex` command on `PATH`; it does not require Codex to be installed through npm.
+
 On a real `oh-my-codex` version bump, the global npm install now prints an explicit reminder instead of launching `omx setup` automatically. When you're ready, run `omx setup` manually or use `omx update` to check npm and then run the same setup refresh path.
 
-**Codex plugin install note:** this repo also ships an official Codex plugin layout at `plugins/oh-my-codex` with marketplace metadata in `.agents/plugins/marketplace.json`. That plugin bundles the mirrored skill surface plus plugin-scoped companion metadata for optional MCP compatibility servers and apps, disabled by default. Native/runtime hooks still stay on the setup/runtime side rather than the installable plugin manifest. It is still **not** a replacement for `npm install -g oh-my-codex` plus `omx setup`: legacy setup mode installs native agents and prompts, while plugin setup mode relies on plugin discovery for bundled skills and archives/removes legacy OMX-managed prompts/native-agent TOMLs so stale role files cannot shadow plugin behavior.
+OMX also checks for npm updates at launch on a throttled cadence and prompts before scheduling the update after the current session exits. Set `OMX_AUTO_UPDATE=0` to disable the launch-time check, or set `OMX_AUTO_UPDATE=defer` to schedule the same deferred update without prompting.
+
+**Codex plugin install note:** this repo also ships an official Codex plugin layout at `plugins/oh-my-codex` with marketplace metadata in `.agents/plugins/marketplace.json`. That plugin bundles the mirrored skill surface plus plugin-scoped companion metadata for official Codex lifecycle hooks, optional MCP compatibility servers, and apps. It is still **not** a replacement for `npm install -g oh-my-codex` plus `omx setup`: plugin-scoped hooks launch the installed `omx` CLI, legacy setup mode installs native agents and prompts, and plugin setup mode relies on plugin discovery for bundled skills while archiving/removing legacy OMX-managed prompts/native-agent TOMLs so stale role files cannot shadow plugin behavior.
 
 Then work normally inside Codex:
 
 ```text
 $deep-interview "clarify the authentication change"
 $ralplan "approve the auth plan and review tradeoffs"
-$ralph "carry the approved plan to completion"
-$team 3:executor "execute the approved plan in parallel"
-$ultragoal "turn this launch into durable Codex goals"
+$prometheus-strict "stress-test the plan before durable execution"
+$ultragoal "turn the approved plan into durable Codex goals"
 ```
 
 That is the main path.
 Before you treat the runtime as ready, run the quick-start smoke test below: `omx doctor` verifies the install shape, while `omx exec` proves the active Codex runtime can actually authenticate and complete a model call from the current environment.
-Start OMX strongly, clarify first when needed, approve the plan, then choose `$team` for coordinated parallel execution or `$ralph` for the persistent completion loop.
+Start OMX strongly, clarify first when needed, approve the plan, optionally use `$prometheus-strict` for interview-driven plan hardening on high-risk work, then use `$ultragoal` as the default durable completion wrapper. Use `$team` inside that execution path only when a specific Ultragoal story needs coordinated parallel work; use `$ralph` when you intentionally want a single-owner completion loop instead of a durable multi-goal run.
 
 ## What OMX is for
 
 Use OMX if you already like Codex and want a better day-to-day runtime around it:
-- a standard workflow built around `$deep-interview`, `$ralplan`, `$team`, and `$ralph`
-- durable multi-goal handoffs with `$ultragoal` and `.omx/ultragoal` artifacts when a launch needs sequential Codex goals
+- a standard workflow built around `$deep-interview` -> `$ralplan` -> `$ultragoal`, with `$prometheus-strict` available when plans need stricter interview/critique/synthesis before execution and optional `.omx/plans/prometheus-strict/` artifacts
+- research boundaries: use `$best-practice-research` for ordinary pre-planning official/upstream evidence, `$autoresearch` for bounded validator-gated research artifacts, `$autoresearch-goal` for goal-mode research missions, and feed any research findings into `$ralplan` for architecture synthesis
+- durable multi-goal handoffs with `$ultragoal` and `.omx/ultragoal` artifacts as the default completion path after planning
 - specialist roles and supporting skills when the task needs them
 - project guidance through scoped `AGENTS.md`
 - durable state under `.omx/` for plans, logs, memory, and mode tracking
@@ -97,7 +119,7 @@ If you want plain Codex with no extra workflow layer, you probably do not need O
 ### Requirements
 
 - Node.js 20+
-- Codex CLI installed: `npm install -g @openai/codex`
+- Codex CLI installed, verified with `codex --version`, and authenticated (Homebrew or npm are both fine; do not reinstall `@openai/codex` with npm if Homebrew already owns `codex`)
 - Codex auth configured and visible in the same shell/profile that will run OMX
 - `tmux` on macOS/Linux if you want the recommended durable team runtime
 - `psmux` on native Windows only if you intentionally want the less-supported Windows team path
@@ -160,11 +182,10 @@ Then try the canonical workflow:
 ```text
 $deep-interview "clarify the authentication change"
 $ralplan "approve the safest implementation path"
-$ralph "carry the approved plan to completion"
-$team 3:executor "execute the approved plan in parallel"
+$ultragoal "turn the approved path into durable Codex goals"
 ```
 
-Use `$team` when the approved plan needs coordinated parallel work, or `$ralph` when one persistent owner should keep pushing to completion.
+Use `$team` when an active Ultragoal story needs coordinated parallel work, or `$ralph` when one persistent owner should keep pushing to completion without a multi-goal ledger.
 
 ## A simple mental model
 
@@ -180,20 +201,22 @@ Most users should think of OMX as **better task routing + better workflow + bett
 
 ## Start here if you are new
 
-1. Install or update OMX with `npm install -g @openai/codex oh-my-codex`
+1. If Codex CLI already exists, verify it with `codex --version` and install or update OMX with `npm install -g oh-my-codex`; otherwise install `@openai/codex` separately first if you want npm to manage Codex
 2. After install or real OMX version bumps, run `omx setup` yourself when you're ready, or use `omx update` when you also want npm to check for and install the latest build before refreshing setup
 3. Run `omx doctor`
 4. Run a real execution smoke test: `codex login status` and `omx exec --skip-git-repo-check -C . "Reply with exactly OMX-EXEC-OK"`
 5. Launch with `omx --madmax --high`
 6. Use `$deep-interview "..."` when the request or boundaries are still unclear
 7. Use `$ralplan "..."` to approve the plan and review tradeoffs
-8. Choose `$team` for coordinated parallel execution or `$ralph` for persistent completion loops
+8. Use `$ultragoal "..."` to turn the approved plan into durable goals and ledger checkpoints
 
 ## Recommended workflow
 
 1. `$deep-interview` — clarify scope when the request or boundaries are still vague.
 2. `$ralplan` — turn that clarified scope into an approved architecture and implementation plan.
-3. `$team` or `$ralph` — use `$team` for coordinated parallel execution, or `$ralph` when you want a persistent completion loop with one owner.
+3. `$ultragoal` — make the approved plan durable as sequential Codex goals with `.omx/ultragoal` ledger checkpoints.
+
+Inside an Ultragoal story, use `$team` only when that story benefits from coordinated parallel execution. Use `$ralph` as an intentional alternate completion loop when you do not need a durable multi-goal ledger.
 
 ## Common in-session surfaces
 
@@ -201,6 +224,7 @@ Most users should think of OMX as **better task routing + better workflow + bett
 | --- | --- |
 | `$deep-interview "..."` | clarifying intent, boundaries, and non-goals |
 | `$ralplan "..."` | approving the implementation plan and tradeoffs |
+| `$ultragoal "..."` | durable multi-goal completion after the approved plan |
 | `$ralph "..."` | persistent completion and verification loops |
 | `$team "..."` | coordinated parallel execution when the work is big enough |
 | `/skills` | browsing installed skills and supporting helpers |
@@ -223,19 +247,21 @@ omx team shutdown <team-name>
 ### Setup, doctor, and HUD
 
 These are operator/support surfaces:
-- Codex plugin marketplace install/discovery can cache the plugin under `${CODEX_HOME:-~/.codex}/plugins/cache/$MARKETPLACE_NAME/oh-my-codex/$VERSION/` (local installs may use `local` as the version identifier); that packaged plugin includes plugin-scoped companion metadata for optional MCP compatibility servers and apps (disabled by default), while native/runtime hooks remain setup-owned, so it is still not the full OMX runtime setup
-- `omx setup` installs prompts, skills, AGENTS scaffolding, `.codex/config.toml`, and OMX-managed native Codex hooks in `.codex/hooks.json`
+- Codex plugin marketplace install/discovery can cache the plugin under `${CODEX_HOME:-~/.codex}/plugins/cache/$MARKETPLACE_NAME/oh-my-codex/$VERSION/` (local installs may use `local` as the version identifier); that packaged plugin includes plugin-scoped companion metadata for official Codex lifecycle hooks, optional MCP compatibility servers, and apps (MCP/apps disabled by default), so it is still paired with the installed `omx` CLI for runtime execution
+- `omx setup` installs prompts, skills, AGENTS scaffolding, `.codex/config.toml`, and (for legacy installs or older Codex without `plugin_hooks`) OMX-managed native Codex hooks in `.codex/hooks.json`
   - setup refresh preserves non-OMX hook entries in `.codex/hooks.json` and only rewrites OMX-managed wrappers
   - `omx setup --merge-agents` preserves existing `AGENTS.md` guidance while inserting or refreshing generated OMX sections between `<!-- OMX:AGENTS:START -->` / `<!-- OMX:AGENTS:END -->`; without `--merge-agents` or `--force`, non-interactive setup keeps skipping existing `AGENTS.md` files
   - `omx uninstall` removes OMX-managed wrappers from `.codex/hooks.json` but keeps the file when user hooks remain
 - `omx update` checks npm immediately, installs the newest global OMX build, then reruns the same interactive setup refresh path
+- launch-time update checks are throttled and prompt by default; use `OMX_AUTO_UPDATE=0` to disable them or `OMX_AUTO_UPDATE=defer` to schedule deferred updates without a prompt
 - fresh OMX-managed `gpt-5.5` config seeding now recommends `model_context_window = 250000` and `model_auto_compact_token_limit = 200000`, but only when those keys are missing
 - `.omx-config.json` model/env routing is documented in [the model/env routing reference](./docs/reference/omx-config-schema-routing.md); only edit keys supported by your installed OMX version
 - `omx doctor` verifies the install when something seems wrong; it does not prove that the active Codex profile can make an authenticated model call
 - `omx hud --watch` is a monitoring/status surface, not the primary user workflow
 
 For non-team sessions, native Codex hooks are now the canonical lifecycle surface:
-- `.codex/hooks.json` = native Codex hook registrations
+- `plugins/oh-my-codex/hooks/hooks.json` = official plugin-scoped hook registrations for plugin installs
+- `.codex/hooks.json` = legacy/fallback native Codex hook registrations preserved for legacy installs and older Codex versions
 - `.omx/hooks/*.mjs` = OMX plugin hooks
 - `omx tmux-hook` / notify-hook / derived watcher = tmux + runtime fallback paths
 

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

@@ -6,7 +6,7 @@ use std::fs;
 use std::io::{self, BufRead, BufReader, Read, Write};
 use std::net::{IpAddr, Shutdown, TcpListener, TcpStream};
 use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
+use std::process::{Child, Command, Stdio};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
@@ -1934,17 +1934,49 @@ fn spawn_daemon(config: &ServerConfig) -> Result<DaemonState> {
         .stdout(Stdio::null())
         .stderr(Stdio::null())
         .spawn()?;
-    for _ in 0..100 {
-        if let Some(state) = read_daemon_state(&config.state_file)? {
-            return Ok(state);
+    wait_for_daemon_state(
+        &mut child,
+        &config.state_file,
+        100,
+        Duration::from_millis(20),
+    )
+}
+
+fn terminate_child(child: &mut Child) {
+    let _ = child.kill();
+    let _ = child.wait();
+}
+
+fn wait_for_daemon_state(
+    child: &mut Child,
+    state_file: &Path,
+    attempts: usize,
+    sleep: Duration,
+) -> Result<DaemonState> {
+    for _ in 0..attempts {
+        match read_daemon_state(state_file) {
+            Ok(Some(state)) => return Ok(state),
+            Ok(None) => {}
+            Err(error) => {
+                terminate_child(child);
+                return Err(error);
+            }
         }
-        if let Some(status) = child.try_wait()? {
-            return Err(OmxApiError::Message(format!(
-                "daemon exited before writing state: {status}"
-            )));
+        match child.try_wait() {
+            Ok(Some(status)) => {
+                return Err(OmxApiError::Message(format!(
+                    "daemon exited before writing state: {status}"
+                )));
+            }
+            Ok(None) => {}
+            Err(error) => {
+                terminate_child(child);
+                return Err(error.into());
+            }
         }
-        std::thread::sleep(Duration::from_millis(20));
+        std::thread::sleep(sleep);
     }
+    terminate_child(child);
     Err(OmxApiError::Message(
         "daemon did not write state within timeout".to_string(),
     ))
@@ -2930,6 +2962,31 @@ mod tests {
         assert!(read_daemon_state(&path).unwrap().is_none());
     }
 
+    #[test]
+    fn daemon_startup_timeout_kills_child_process_to_avoid_process_leak() {
+        let path = env::temp_dir().join(format!("omx-api-timeout-test-{}.json", now_unix()));
+        let mut child = Command::new("sh")
+            .arg("-c")
+            .arg("sleep 60")
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+            .expect("spawn sleep child");
+
+        let error = wait_for_daemon_state(&mut child, &path, 1, Duration::from_millis(1))
+            .expect_err("missing state should time out");
+
+        assert!(error
+            .to_string()
+            .contains("daemon did not write state within timeout"));
+        assert!(
+            child.try_wait().unwrap().is_some(),
+            "timeout path should reap the spawned daemon child"
+        );
+        let _ = fs::remove_file(path);
+    }
+
     #[test]
     fn cli_system_dry_run_is_json() {
         let mut out = Vec::new();

package/crates/omx-sparkshell/src/exec.rs

@@ -26,8 +26,82 @@ impl CommandOutput {
     }
 }
 
-pub fn execute_shell_command(script: &str) -> Result<CommandOutput, SparkshellError> {
-    execute_command(&["bash".to_string(), "-lc".to_string(), script.to_string()])
+pub fn resolve_shell_argv(script: &str) -> Vec<String> {
+    resolve_shell_argv_for_platform(script, current_platform(), command_exists_on_path)
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ShellPlatform {
+    Windows,
+    Posix,
+}
+
+fn current_platform() -> ShellPlatform {
+    if cfg!(windows) {
+        ShellPlatform::Windows
+    } else {
+        ShellPlatform::Posix
+    }
+}
+
+fn resolve_shell_argv_for_platform(
+    script: &str,
+    platform: ShellPlatform,
+    exists: impl Fn(&str) -> bool,
+) -> Vec<String> {
+    match platform {
+        ShellPlatform::Posix => vec!["bash".to_string(), "-lc".to_string(), script.to_string()],
+        ShellPlatform::Windows => {
+            if exists("pwsh") {
+                return vec![
+                    "pwsh".to_string(),
+                    "-NoLogo".to_string(),
+                    "-NoProfile".to_string(),
+                    "-Command".to_string(),
+                    script.to_string(),
+                ];
+            }
+            if exists("powershell.exe") {
+                return vec![
+                    "powershell.exe".to_string(),
+                    "-NoLogo".to_string(),
+                    "-NoProfile".to_string(),
+                    "-Command".to_string(),
+                    script.to_string(),
+                ];
+            }
+            vec![
+                std::env::var("ComSpec").unwrap_or_else(|_| "cmd.exe".to_string()),
+                "/d".to_string(),
+                "/s".to_string(),
+                "/c".to_string(),
+                script.to_string(),
+            ]
+        }
+    }
+}
+
+fn command_exists_on_path(command: &str) -> bool {
+    if command.contains(std::path::MAIN_SEPARATOR)
+        || command.contains('/')
+        || command.contains('\\')
+    {
+        return std::path::Path::new(command).is_file();
+    }
+    let Some(path) = std::env::var_os("PATH") else {
+        return false;
+    };
+    std::env::split_paths(&path).any(|dir| {
+        let candidate = dir.join(command);
+        candidate.is_file()
+            || if cfg!(windows) && std::path::Path::new(command).extension().is_none() {
+                ["exe", "cmd", "bat", "com"]
+                    .iter()
+                    .any(|ext| dir.join(format!("{command}.{ext}")).is_file())
+            } else {
+                false
+            }
+    })
 }
 
 pub fn execute_command(argv: &[String]) -> Result<CommandOutput, SparkshellError> {
@@ -106,7 +180,7 @@ fn build_windows_command(command_name: &str, args: &[String]) -> Command {
 
 #[cfg(test)]
 mod tests {
-    use super::execute_command;
+    use super::{execute_command, resolve_shell_argv_for_platform, ShellPlatform};
 
     #[test]
     fn rejects_missing_command() {
@@ -116,4 +190,52 @@ mod tests {
             "usage: omx-sparkshell <command> [args...]"
         );
     }
+
+    #[test]
+    fn posix_shell_mode_uses_bash_lc() {
+        assert_eq!(
+            resolve_shell_argv_for_platform("printf ok", ShellPlatform::Posix, |_| false),
+            ["bash", "-lc", "printf ok"]
+        );
+    }
+
+    #[test]
+    fn windows_shell_mode_prefers_pwsh() {
+        assert_eq!(
+            resolve_shell_argv_for_platform("Write-Output ok", ShellPlatform::Windows, |name| {
+                name == "pwsh"
+            }),
+            [
+                "pwsh",
+                "-NoLogo",
+                "-NoProfile",
+                "-Command",
+                "Write-Output ok"
+            ]
+        );
+    }
+
+    #[test]
+    fn windows_shell_mode_falls_back_to_windows_powershell() {
+        assert_eq!(
+            resolve_shell_argv_for_platform("Write-Output ok", ShellPlatform::Windows, |name| {
+                name == "powershell.exe"
+            }),
+            [
+                "powershell.exe",
+                "-NoLogo",
+                "-NoProfile",
+                "-Command",
+                "Write-Output ok"
+            ]
+        );
+    }
+
+    #[test]
+    fn windows_shell_mode_uses_minimal_cmd_fallback() {
+        assert_eq!(
+            resolve_shell_argv_for_platform("echo ok", ShellPlatform::Windows, |_| false),
+            ["cmd.exe", "/d", "/s", "/c", "echo ok"]
+        );
+    }
 }