oh-my-codex 0.14.4 → 0.15.1

package/.agents/plugins/marketplace.json

@@ -0,0 +1,20 @@
+{
+  "name": "oh-my-codex-local",
+  "interface": {
+    "displayName": "oh-my-codex Local Plugins"
+  },
+  "plugins": [
+    {
+      "name": "oh-my-codex",
+      "source": {
+        "source": "local",
+        "path": "./plugins/oh-my-codex"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Developer Tools"
+    }
+  ]
+}

package/Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 4
+version = 3
 
 [[package]]
 name = "fs2"
@@ -32,11 +32,11 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "omx-explore-harness"
-version = "0.14.4"
+version = "0.15.1"
 
 [[package]]
 name = "omx-mux"
-version = "0.14.4"
+version = "0.15.1"
 dependencies = [
  "serde",
  "serde_json",
@@ -44,7 +44,7 @@ dependencies = [
 
 [[package]]
 name = "omx-runtime"
-version = "0.14.4"
+version = "0.15.1"
 dependencies = [
  "omx-mux",
  "omx-runtime-core",
@@ -53,7 +53,7 @@ dependencies = [
 
 [[package]]
 name = "omx-runtime-core"
-version = "0.14.4"
+version = "0.15.1"
 dependencies = [
  "fs2",
  "serde",
@@ -62,7 +62,7 @@ dependencies = [
 
 [[package]]
 name = "omx-sparkshell"
-version = "0.14.4"
+version = "0.15.1"
 dependencies = [
  "omx-mux",
 ]

package/Cargo.toml

@@ -10,9 +10,10 @@ resolver = "2"
 
 [workspace.package]
 
-version = "0.14.4"
+version = "0.15.1"
 
 edition = "2021"
+rust-version = "1.73"
 license = "MIT"
 repository = "https://github.com/Yeachan-Heo/oh-my-codex"
 

package/README.md

@@ -51,7 +51,7 @@ It keeps Codex as the execution engine and makes it easier to:
 | HaD0Yun | [@HaD0Yun](https://github.com/HaD0Yun) |
 | Junho Yeo | [@junhoyeo](https://github.com/junhoyeo) |
 | JiHongKim98 | [@JiHongKim98](https://github.com/JiHongKim98) |
-| Lor | — |
+| Lor | [@gobylor](https://github.com/gobylor) |
 | HyunjunJeon | [@HyunjunJeon](https://github.com/HyunjunJeon) |
 
 ## Recommended default flow
@@ -63,7 +63,9 @@ npm install -g @openai/codex oh-my-codex
 omx --madmax --high
 ```
 
-On a real `oh-my-codex` version bump, the global npm install now launches the interactive `omx setup` refresh automatically when a TTY is available. If npm scripts are skipped or the install is non-interactive, run `omx setup` manually or use `omx update` to force the same refresh path later.
+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 MCP servers and apps. 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.
 
 Then work normally inside Codex:
 
@@ -116,13 +118,41 @@ Launch OMX the recommended way:
 omx --madmax --high
 ```
 
-This starts the interactive leader session directly by default.
-If you explicitly want the leader session in tmux, use:
+On macOS/Linux interactive terminals with `tmux` available, this starts the
+leader in OMX-managed detached tmux by default so the HUD/runtime panes can be
+created and recovered.
+
+If you want a one-off launch with no OMX tmux/HUD management, use `--direct`:
+
+```bash
+omx --direct --yolo
+```
+
+For a persistent shell/profile preference, set an environment policy:
 
 ```bash
-omx --tmux --madmax --high
+OMX_LAUNCH_POLICY=direct omx --yolo
 ```
 
+Return to the auto/default behavior with:
+
+```bash
+unset OMX_LAUNCH_POLICY
+```
+
+CLI policy flags win over the environment, and the last CLI policy flag before
+`--` wins:
+
+```bash
+OMX_LAUNCH_POLICY=direct omx --tmux --yolo
+```
+
+Use `OMX_LAUNCH_POLICY=direct|tmux|detached-tmux|auto`. This iteration only
+adds CLI and environment controls; it intentionally does not add a config-file
+setting. If you run `--direct` from inside an existing tmux pane, OMX will not
+create HUD splits, enable mouse mode, or wrap extended-key handling, but the
+process still runs inside that already-open terminal pane.
+
 Then try the canonical workflow:
 
 ```text
@@ -149,7 +179,7 @@ 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`
-2. Let the interactive `omx setup` refresh run automatically on real OMX version bumps, or run `omx setup` / `omx update` yourself when scripts are skipped or you want to rerun it
+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`
@@ -179,7 +209,7 @@ These are useful, but they are not the main onboarding path.
 
 ### Team runtime
 
-Use the team runtime when you specifically need durable tmux/worktree coordination, not as the default way to begin using OMX.
+Use the team runtime when you specifically need durable tmux/worktree coordination, not as the default way to begin using OMX. In Codex App or plain outside-tmux sessions, treat `omx team` as a tmux-runtime shell surface rather than a directly available in-app workflow; launch OMX CLI from shell first if you actually want team execution.
 
 ```bash
 omx team 3:executor "fix the failing tests with verification"
@@ -191,8 +221,10 @@ 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 now includes plugin-scoped companion metadata for MCP servers and apps, 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`
   - 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
 - 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
@@ -231,6 +263,7 @@ If `Shift+Enter` still submits instead of inserting a newline inside an OMX-mana
 - `omx explore --prompt "..."` is for read-only repository lookup
 - `omx sparkshell <command>` is for shell-native inspection and bounded verification
 - when `.omx/wiki/` exists, `omx explore` can inject wiki-first context before falling back to broader repository search
+- fallback boundaries are explicit: sparkshell-backend fallback is reported on stderr, and spark-model fallback emits stderr metadata plus an `## OMX Explore fallback` notice in stdout so users can see when cost/behavior may differ from the low-cost path
 
 Examples:
 

package/crates/omx-explore/Cargo.toml

@@ -2,6 +2,7 @@
 name = "omx-explore-harness"
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 repository.workspace = true
 

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

@@ -38,10 +38,19 @@ struct AttemptResult {
     output_markdown: Option<String>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct FallbackEvent {
+    from_model: String,
+    to_model: String,
+    exit_code: i32,
+    stderr: String,
+}
+
 #[derive(Debug)]
 struct AllowlistEnvironment {
     bin_dir: PathBuf,
     shell_path: PathBuf,
+    sandbox_bin_dir: Option<PathBuf>,
     _root: TempDirGuard,
 }
 
@@ -110,21 +119,18 @@ where
         return Ok(());
     }
 
-    eprintln!(
-        "[omx explore] spark model `{}` unavailable or failed (exit {}). Falling back to `{}`.",
-        args.spark_model, spark_attempt.status_code, args.fallback_model
-    );
-    if !spark_attempt.stderr.trim().is_empty() {
-        eprintln!(
-            "[omx explore] spark stderr: {}",
-            spark_attempt.stderr.trim()
-        );
-    }
+    let fallback_event = FallbackEvent {
+        from_model: args.spark_model.clone(),
+        to_model: args.fallback_model.clone(),
+        exit_code: spark_attempt.status_code,
+        stderr: spark_attempt.stderr.clone(),
+    };
+    emit_model_fallback_event(&fallback_event);
 
     let fallback_attempt = invoke_codex(&args, &args.fallback_model, &prompt_contract)
         .map_err(|err| format!("fallback attempt failed to launch: {err}"))?;
     if fallback_attempt.status_code == 0 {
-        print_attempt_output(fallback_attempt)?;
+        print_attempt_output_with_fallback(fallback_attempt, &fallback_event)?;
         return Ok(());
     }
 
@@ -139,7 +145,27 @@ where
 }
 
 fn print_attempt_output(attempt: AttemptResult) -> Result<(), String> {
+    print_attempt_output_with_optional_fallback(attempt, None)
+}
+
+fn print_attempt_output_with_fallback(
+    attempt: AttemptResult,
+    fallback: &FallbackEvent,
+) -> Result<(), String> {
+    print_attempt_output_with_optional_fallback(attempt, Some(fallback))
+}
+
+fn print_attempt_output_with_optional_fallback(
+    attempt: AttemptResult,
+    fallback: Option<&FallbackEvent>,
+) -> Result<(), String> {
     if let Some(markdown) = attempt.output_markdown {
+        if let Some(event) = fallback {
+            print!("{}", fallback_output_notice(event));
+            if !markdown.starts_with('\n') {
+                println!();
+            }
+        }
         print!("{}", markdown);
         return Ok(());
     }
@@ -149,6 +175,31 @@ fn print_attempt_output(attempt: AttemptResult) -> Result<(), String> {
     )
 }
 
+fn emit_model_fallback_event(event: &FallbackEvent) {
+    eprintln!("{}", fallback_attempt_event_message(event));
+    eprintln!(
+        "[omx explore] spark model `{}` unavailable or failed (exit {}). Falling back to `{}`.",
+        event.from_model, event.exit_code, event.to_model
+    );
+    if !event.stderr.trim().is_empty() {
+        eprintln!("[omx explore] spark stderr: {}", event.stderr.trim());
+    }
+}
+
+fn fallback_attempt_event_message(event: &FallbackEvent) -> String {
+    format!(
+        "[omx explore] fallback-attempt=model from=`{}` to=`{}` reason=spark_attempt_failed exit={}. Cost/behavior boundary changed if fallback succeeds; stdout fallback notice is emitted only after successful fallback output.",
+        event.from_model, event.to_model, event.exit_code
+    )
+}
+
+fn fallback_output_notice(event: &FallbackEvent) -> String {
+    format!(
+        "## OMX Explore fallback\n- fallback: model\n- from: `{}`\n- to: `{}`\n- reason: spark attempt failed with exit {}\n- boundary: cost/behavior may differ from the low-cost spark path\n",
+        event.from_model, event.to_model, event.exit_code
+    )
+}
+
 fn parse_args<I>(mut args: I) -> Result<Args, String>
 where
     I: Iterator<Item = OsString>,
@@ -211,9 +262,11 @@ fn usage() -> &'static str {
     "Usage: omx-explore --cwd <dir> --prompt <text> --prompt-file <explore-prompt.md> --instructions-file <AGENTS.md> --model-spark <model> --model-fallback <model>"
 }
 
+#[allow(unknown_lints, clippy::io_other_error)]
 fn invoke_codex(args: &Args, model: &str, prompt_contract: &str) -> io::Result<AttemptResult> {
     let codex_launch = resolve_codex_launch();
-    let allowlist = prepare_allowlist_environment().map_err(io::Error::other)?;
+    let allowlist =
+        prepare_allowlist_environment().map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
     let output_path = temp_output_path();
     let final_prompt = compose_exec_prompt(&args.prompt, prompt_contract);
     let mut command = Command::new(&codex_launch.program);
@@ -241,7 +294,11 @@ fn invoke_codex(args: &Args, model: &str, prompt_contract: &str) -> io::Result<A
         .arg(&output_path)
         .arg(&final_prompt)
         .env(HARNESS_ROOT_ENV, &args.cwd)
-        .env("PATH", &allowlist.bin_dir)
+        .env(
+            "PATH",
+            build_codex_path(&allowlist.bin_dir, allowlist.sandbox_bin_dir.as_deref())
+                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?,
+        )
         .env("SHELL", &allowlist.shell_path);
     sanitize_explore_subprocess_env(&mut command);
     let output = command.output()?;
@@ -531,13 +588,49 @@ fn prepare_allowlist_environment() -> Result<AllowlistEnvironment, String> {
     write_executable(&shell_path, &bash_wrapper)?;
     write_executable(&bin_dir.join("sh"), &sh_wrapper)?;
 
+    let sandbox_bin_dir = prepare_sandbox_dependency_bin(&root.path)?;
+
     Ok(AllowlistEnvironment {
         bin_dir,
         shell_path,
+        sandbox_bin_dir,
         _root: root,
     })
 }
 
+fn build_codex_path(
+    allowlist_bin_dir: &Path,
+    sandbox_bin_dir: Option<&Path>,
+) -> Result<OsString, String> {
+    let mut entries = vec![allowlist_bin_dir.to_path_buf()];
+    if let Some(sandbox_bin_dir) = sandbox_bin_dir {
+        entries.push(sandbox_bin_dir.to_path_buf());
+    }
+    env::join_paths(entries).map_err(|err| format!("failed to construct restricted PATH: {err}"))
+}
+
+fn prepare_sandbox_dependency_bin(root: &Path) -> Result<Option<PathBuf>, String> {
+    let Some(bwrap_path) = resolve_host_command("bwrap") else {
+        return Ok(None);
+    };
+
+    let sandbox_bin_dir = root.join("sandbox-bin");
+    create_dir_all(&sandbox_bin_dir).map_err(|err| {
+        format!(
+            "failed to create sandbox dependency bin dir {}: {err}",
+            sandbox_bin_dir.display()
+        )
+    })?;
+    write_executable(
+        &sandbox_bin_dir.join("bwrap"),
+        &format!(
+            "#!/bin/sh\nexec {} \"$@\"\n",
+            shell_quote(&bwrap_path.display().to_string())
+        ),
+    )?;
+    Ok(Some(sandbox_bin_dir))
+}
+
 fn allowlist_platform_diagnostic(os: &str) -> Option<&'static str> {
     if os.eq_ignore_ascii_case("windows") {
         return Some(WINDOWS_UNSUPPORTED_ALLOWLIST_MESSAGE);
@@ -745,7 +838,7 @@ fn validate_shell_invocation(args: &[String]) -> Result<String, String> {
 
     let tokens: Vec<String> = command
         .split_whitespace()
-        .map(|token| token.trim_matches(['"', '\'']).to_string())
+        .map(|token| token.trim_matches(|ch| ch == '"' || ch == '\'').to_string())
         .filter(|token| !token.is_empty())
         .collect();
     let first = tokens
@@ -884,19 +977,28 @@ fn validate_repo_paths(command_name: &str, args: &[String]) -> Result<(), String
     let candidate_paths = command_path_operands(command_name, args);
     for operand in candidate_paths {
         let normalized = normalize_candidate_path(&repo_root, operand);
-        if !normalized.starts_with(&repo_root) {
+        let canonical_candidate = canonicalize_existing_prefix(&normalized);
+        let is_textually_inside = normalized.starts_with(&repo_root);
+        let is_canonically_inside = match (&canonical_candidate, &canonical_repo_root) {
+            (Some(candidate), Some(root)) => candidate.starts_with(root),
+            _ => false,
+        };
+
+        if !is_textually_inside && !is_canonically_inside {
             return Err(format!(
                 "path `{operand}` escapes the omx explore repository root {}",
                 repo_root.display()
             ));
         }
-        if let Some(canonical_candidate) = canonicalize_existing_prefix(&normalized) {
-            if let Some(canonical_repo_root) = &canonical_repo_root {
-                if !canonical_candidate.starts_with(canonical_repo_root) {
-                    return Err(format!(
-                        "path `{operand}` resolves outside the omx explore repository root {}",
-                        canonical_repo_root.display()
-                    ));
+        if is_textually_inside {
+            if let Some(canonical_candidate) = canonical_candidate {
+                if let Some(canonical_repo_root) = &canonical_repo_root {
+                    if !canonical_candidate.starts_with(canonical_repo_root) {
+                        return Err(format!(
+                            "path `{operand}` resolves outside the omx explore repository root {}",
+                            canonical_repo_root.display()
+                        ));
+                    }
                 }
             }
         }
@@ -971,6 +1073,7 @@ fn canonicalize_existing_prefix(path: &Path) -> Option<PathBuf> {
 }
 
 #[cfg(test)]
+#[allow(unused_unsafe)]
 mod tests {
     use super::*;
     use std::sync::{Mutex, OnceLock};
@@ -1162,7 +1265,7 @@ exec node "$basedir/../@openai/codex/bin/codex.js" "$@"
         create_dir_all(&good_bin).expect("create good bin");
 
         let blocked_directory = bad_bin.join("node");
-        create_dir_all(&blocked_directory).expect("create blocked directory");
+        create_dir_all(blocked_directory).expect("create blocked directory");
 
         let blocked_node = blocked_file_bin.join("node");
         write(&blocked_node, "#!/bin/sh\nexit 0\n").expect("write blocked file node");
@@ -1280,6 +1383,88 @@ exec node "$basedir/../@openai/codex/bin/codex.js" "$@"
         result
     }
 
+    #[test]
+    fn build_codex_path_keeps_allowlist_first_and_only_adds_sandbox_bin() {
+        let allowlist_bin = Path::new("/tmp/omx-explore-allowlist/bin");
+        let sandbox_bin = Path::new("/tmp/omx-explore-sandbox-bin");
+
+        let path = build_codex_path(allowlist_bin, Some(sandbox_bin)).expect("restricted path");
+        let entries: Vec<PathBuf> = env::split_paths(&path).collect();
+
+        assert_eq!(
+            entries,
+            vec![allowlist_bin.to_path_buf(), sandbox_bin.to_path_buf()]
+        );
+    }
+
+    #[test]
+    fn build_codex_path_omits_sandbox_bin_when_bwrap_is_absent() {
+        let allowlist_bin = Path::new("/tmp/omx-explore-allowlist/bin");
+
+        let path = build_codex_path(allowlist_bin, None).expect("restricted path");
+        let entries: Vec<PathBuf> = env::split_paths(&path).collect();
+
+        assert_eq!(entries, vec![allowlist_bin.to_path_buf()]);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn prepare_allowlist_environment_adds_controlled_bwrap_without_host_path() {
+        let _guard = env_lock();
+        let mut commands = vec!["bash", "sh"];
+        commands.extend(
+            ALLOWED_DIRECT_COMMANDS
+                .iter()
+                .copied()
+                .filter(|command| *command != "rg"),
+        );
+        let (_root, host_bin) = create_host_bin_with_commands(&commands);
+        let fake_bwrap = host_bin.join("bwrap");
+        write_executable(&fake_bwrap, "#!/bin/sh\nexit 0\n").expect("write fake bwrap");
+
+        let allowlist =
+            with_path(&host_bin, prepare_allowlist_environment).expect("allowlist environment");
+        let sandbox_bin = allowlist
+            .sandbox_bin_dir
+            .as_ref()
+            .expect("sandbox bin when bwrap exists");
+        let path = build_codex_path(&allowlist.bin_dir, allowlist.sandbox_bin_dir.as_deref())
+            .expect("codex path");
+        let entries: Vec<PathBuf> = env::split_paths(&path).collect();
+
+        assert_eq!(
+            entries,
+            vec![allowlist.bin_dir.clone(), sandbox_bin.clone()]
+        );
+        assert!(!entries.contains(&host_bin));
+        let controlled_bwrap =
+            read_to_string(sandbox_bin.join("bwrap")).expect("read controlled bwrap");
+        assert!(controlled_bwrap.contains(&fake_bwrap.display().to_string()));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn prepare_allowlist_environment_leaves_path_allowlist_only_without_bwrap() {
+        let _guard = env_lock();
+        let mut commands = vec!["bash", "sh"];
+        commands.extend(
+            ALLOWED_DIRECT_COMMANDS
+                .iter()
+                .copied()
+                .filter(|command| *command != "rg"),
+        );
+        let (_root, host_bin) = create_host_bin_with_commands(&commands);
+
+        let allowlist =
+            with_path(&host_bin, prepare_allowlist_environment).expect("allowlist environment");
+        let path = build_codex_path(&allowlist.bin_dir, allowlist.sandbox_bin_dir.as_deref())
+            .expect("codex path");
+        let entries: Vec<PathBuf> = env::split_paths(&path).collect();
+
+        assert!(allowlist.sandbox_bin_dir.is_none());
+        assert_eq!(entries, vec![allowlist.bin_dir]);
+    }
+
     #[cfg(unix)]
     #[test]
     fn prepare_allowlist_environment_tolerates_missing_rg_by_stubbing_wrapper() {
@@ -1808,7 +1993,7 @@ printf '# Answer\nok\n' > "$output_path"
         unsafe {
             env::set_var("BASH_ENV", &bash_env);
         }
-        let mut child = Command::new(&bash_path);
+        let mut child = Command::new(bash_path);
         child
             .arg("--noprofile")
             .arg("--norc")
@@ -1824,6 +2009,43 @@ printf '# Answer\nok\n' > "$output_path"
         assert_eq!(read_to_string(&bash_env_log).unwrap_or_default(), "");
     }
 
+    fn fallback_test_event() -> FallbackEvent {
+        FallbackEvent {
+            from_model: "spark-model".to_string(),
+            to_model: "fallback-model".to_string(),
+            exit_code: 17,
+            stderr: "spark timed out".to_string(),
+        }
+    }
+
+    #[test]
+    fn fallback_attempt_event_distinguishes_attempt_from_output_notice() {
+        let event = fallback_test_event();
+
+        let message = fallback_attempt_event_message(&event);
+        assert!(message.contains("fallback-attempt=model"));
+        assert!(message.contains("from=`spark-model`"));
+        assert!(message.contains("to=`fallback-model`"));
+        assert!(message.contains("spark_attempt_failed exit=17"));
+        assert!(message
+            .contains("stdout fallback notice is emitted only after successful fallback output"));
+        assert!(!message.contains("output includes a fallback notice"));
+        assert!(!message.contains("## OMX Explore fallback"));
+    }
+
+    #[test]
+    fn fallback_output_notice_records_model_boundary() {
+        let event = fallback_test_event();
+
+        let notice = fallback_output_notice(&event);
+        assert!(notice.contains("## OMX Explore fallback"));
+        assert!(notice.contains("fallback: model"));
+        assert!(notice.contains("from: `spark-model`"));
+        assert!(notice.contains("to: `fallback-model`"));
+        assert!(notice.contains("spark attempt failed with exit 17"));
+        assert!(notice.contains("cost/behavior may differ from the low-cost spark path"));
+    }
+
     #[test]
     fn print_attempt_output_requires_markdown_artifact() {
         let result = print_attempt_output(AttemptResult {

package/crates/omx-mux/Cargo.toml

@@ -2,6 +2,7 @@
 name = "omx-mux"
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 repository.workspace = true
 

package/crates/omx-runtime/Cargo.toml

@@ -2,6 +2,7 @@
 name = "omx-runtime"
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 repository.workspace = true
 

package/crates/omx-runtime-core/Cargo.toml

@@ -2,6 +2,7 @@
 name = "omx-runtime-core"
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 repository.workspace = true
 

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

@@ -236,8 +236,9 @@ fn epoch_days_to_date(total_days: u64) -> (u64, u64, u64) {
     (year, month, days + 1)
 }
 
+#[allow(unknown_lints, clippy::manual_is_multiple_of)]
 fn is_leap(year: u64) -> bool {
-    year.is_multiple_of(4) && (!year.is_multiple_of(100) || year.is_multiple_of(400))
+    year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)
 }
 
 #[cfg(test)]

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

@@ -236,7 +236,7 @@ impl RuntimeEngine {
         std::fs::create_dir_all(dir)?;
 
         let lock_file = std::fs::File::create(dir.join("engine.lock"))?;
-        lock_file.lock_exclusive()?;
+        FileExt::lock_exclusive(&lock_file)?;
 
         let snapshot_json = serde_json::to_string_pretty(&self.snapshot())?;
         std::fs::write(dir.join("snapshot.json"), snapshot_json)?;
@@ -291,7 +291,7 @@ impl RuntimeEngine {
         let lock_path = dir.join("engine.lock");
         let lock_file =
             std::fs::File::open(&lock_path).or_else(|_| std::fs::File::create(&lock_path))?;
-        lock_file.lock_shared()?;
+        FileExt::lock_shared(&lock_file)?;
 
         let events_json = std::fs::read_to_string(dir.join("events.json"))?;
         let mut events: Vec<RuntimeEvent> = serde_json::from_str(&events_json)?;

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

@@ -153,8 +153,9 @@ fn epoch_days_to_date(total_days: u64) -> (u64, u64, u64) {
     (year, month, days + 1)
 }
 
+#[allow(unknown_lints, clippy::manual_is_multiple_of)]
 fn is_leap(year: u64) -> bool {
-    year.is_multiple_of(4) && (!year.is_multiple_of(100) || year.is_multiple_of(400))
+    year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)
 }
 
 #[cfg(test)]

package/crates/omx-sparkshell/Cargo.toml

@@ -2,6 +2,7 @@
 name = "omx-sparkshell"
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 repository.workspace = true
 

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

@@ -286,6 +286,7 @@ fn render_section(name: &str, entries: &[String]) -> String {
 }
 
 #[cfg(test)]
+#[allow(unused_unsafe)]
 mod tests {
     use super::{
         normalize_summary, read_summary_timeout_ms, resolve_fallback_model,