### System details

Omarchy version: 3.6.0  
Shell: bash  
mise: 2026.3.17 linux-x64 (2026-03-30)  
Node versions installed with mise: 24.15.0 and 25.9.0  
Affected wrapper: `codex`

### What's wrong?

Omarchy's generated `npx` wrappers launch tools through `node@latest`.

For example, `~/.local/bin/codex` currently contains:

```bash
#!/bin/bash
exec mise exec node@latest -- npx --yes @openai/codex "$@"
```

This appears to originate from `~/.local/share/omarchy/bin/omarchy-npx-install`, which generates wrappers using:

```bash
exec mise exec node@latest -- npx --yes $package "$@"
```

I understand why this was added. It makes sense for npx wrappers to use an independent Node runtime so tools can still start correctly inside projects pinned to older Node versions.

The issue is more specific: for long-running agent CLIs like Codex, the Node runtime used to bootstrap the CLI can be inherited by the agent process and by commands it runs inside the project.

So there are two separate contexts:

1. The Node runtime used to start Codex.
2. The Node/runtime used by commands executed inside the project.

It is reasonable for (1) to be independent from the current project. But (2) should still respect the project environment.

### Example

Given a project with:

```toml
# mise.toml
[tools]
node = "24.15.0"
```

Running directly with mise respects the pin:

```bash
mise exec -- node -v
# v24.15.0
```

But the Omarchy wrapper starts Codex through `node@latest`:

```bash
mise exec node@latest -- node -v
# v25.9.0
```

In my case, launching `codex` inside a project pinned to Node 24 caused commands inside Codex to use Node 25.9.0 instead of the project's Node 24.15.0.

I saw the same pattern in an older Node 20 project, where commands triggered engine warnings due to Node 25.9.0. Codex then started trying to work around the environment mismatch, for example by manually overriding `PATH`. In practice, this can confuse the agent and make it reason about the wrong problem.

### Reproduction Steps

1. Install two Node versions via mise, for example `24.15.0` and `25.9.0`.

2. Inside a project directory, create a `mise.toml`:

```toml
[tools]
node = "24.15.0"
```

3. Confirm the project Node version:

```bash
mise exec -- node -v
# v24.15.0
```

4. Compare with the wrapper's bootstrap runtime:

```bash
mise exec node@latest -- node -v
# v25.9.0
```

5. Launch an affected agent wrapper, for example `codex`, from that project.

6. Run project commands from inside the agent. They can inherit the wrapper's `node@latest` environment instead of the project's `mise.toml` environment.

### Expected Behavior

Omarchy wrappers may use an independent mise-managed Node runtime to bootstrap npx-based CLIs.

However, commands executed by agent-style CLIs inside a project should inherit the project's normal command environment and respect the project's `mise.toml`.

### Suggested direction

I do not think the fix is simply changing the wrapper to:

```bash
exec mise exec -- npx --yes $package "$@"
```

That would likely reintroduce the original problem: wrappers can break inside projects pinned to older Node versions.

The issue is that the bootstrap runtime leaks into the workspace command environment. Agent-style wrappers may need runtime isolation, or at least an override / escape hatch for tools like Codex.

Related: #5247 and #5341.