# `CodexWrapper.ExecResume`
[🔗](https://github.com/genagent/codex_wrapper_ex/blob/v0.5.3/lib/codex_wrapper/exec_resume.ex#L1)

ExecResume command -- resume an existing session non-interactively.

Wraps `codex exec resume [session_id] [prompt]` with the full set of CLI flags.

## Usage

    config = CodexWrapper.Config.new(working_dir: "/path/to/project")

    # Resume the most recent session
    exec = CodexWrapper.ExecResume.new()
      |> CodexWrapper.ExecResume.last()
      |> CodexWrapper.ExecResume.prompt("continue with tests")

    {:ok, result} = CodexWrapper.ExecResume.execute(exec, config)

    # Resume a specific session by ID
    exec = CodexWrapper.ExecResume.new()
      |> CodexWrapper.ExecResume.session_id("abc-123")
      |> CodexWrapper.ExecResume.prompt("add error handling")

    {:ok, result} = CodexWrapper.ExecResume.execute(exec, config)

# `sandbox_mode`

```elixir
@type sandbox_mode() :: :read_only | :workspace_write | :danger_full_access
```

# `t`

```elixir
@type t() :: %CodexWrapper.ExecResume{
  all: boolean(),
  config_overrides: [String.t()],
  dangerously_bypass_approvals_and_sandbox: boolean(),
  dangerously_bypass_hook_trust: boolean(),
  disabled_features: [String.t()],
  enabled_features: [String.t()],
  ephemeral: boolean(),
  full_auto: boolean(),
  ignore_rules: boolean(),
  ignore_user_config: boolean(),
  images: [String.t()],
  json: boolean(),
  last: boolean(),
  model: String.t() | nil,
  output_last_message: String.t() | nil,
  output_schema: String.t() | nil,
  prompt: String.t() | nil,
  sandbox: sandbox_mode() | nil,
  session_id: String.t() | nil,
  skip_git_repo_check: boolean(),
  strict_config: boolean()
}
```

# `all`

```elixir
@spec all(t()) :: t()
```

Show all sessions (disables cwd filtering).

# `config`

```elixir
@spec config(t(), String.t()) :: t()
```

Add a config override (key=value).

# `dangerously_bypass_approvals_and_sandbox`

```elixir
@spec dangerously_bypass_approvals_and_sandbox(t()) :: t()
```

Bypass all approvals and sandbox. Use with extreme caution.

# `dangerously_bypass_hook_trust`

```elixir
@spec dangerously_bypass_hook_trust(t()) :: t()
```

Run enabled hooks without requiring persisted hook trust. Use with extreme caution.

Hook trust is what stops a repository from running arbitrary commands
the user never approved. Only appropriate for automation that already
vets where its hooks come from.

# `disable`

```elixir
@spec disable(t(), String.t()) :: t()
```

Disable a feature.

# `enable`

```elixir
@spec enable(t(), String.t()) :: t()
```

Enable a feature.

# `ephemeral`

```elixir
@spec ephemeral(t()) :: t()
```

Enable ephemeral mode (no session persistence).

# `execute`

```elixir
@spec execute(t(), CodexWrapper.Config.t()) ::
  {:ok, CodexWrapper.Result.t()} | {:error, term()}
```

Execute the command synchronously, returning a parsed `%Result{}`.

# `execute_json`

```elixir
@spec execute_json(t(), CodexWrapper.Config.t()) ::
  {:ok, [CodexWrapper.JsonLineEvent.t()]} | {:error, term()}
```

Execute the command with `--json` and return a list of parsed `%JsonLineEvent{}`.

Forces `--json` on the command, runs synchronously, then parses
each NDJSON line from stdout.

# `full_auto`

```elixir
@spec full_auto(t()) :: t()
```

Enable full-auto mode.

Deprecated upstream. Emits `-c sandbox_mode="workspace-write"`, the
config-key form of what the Codex CLI now tells you to use in place of
`--full-auto`. An explicit `sandbox/2` call is more specific and wins
over this.

# `ignore_rules`

```elixir
@spec ignore_rules(t()) :: t()
```

Do not load user or project execpolicy `.rules` files.

# `ignore_user_config`

```elixir
@spec ignore_user_config(t()) :: t()
```

Do not load `$CODEX_HOME/config.toml`.

Auth still resolves through `CODEX_HOME`; only the config file is
skipped. Pair with `config/2` overrides for a run that does not pick up
the developer's personal settings.

# `image`

```elixir
@spec image(t(), String.t()) :: t()
```

Add an image path.

# `json`

```elixir
@spec json(t()) :: t()
```

Enable JSON output.

# `last`

```elixir
@spec last(t()) :: t()
```

Resume the most recent session.

# `model`

```elixir
@spec model(t(), String.t()) :: t()
```

Set the model.

# `new`

```elixir
@spec new() :: t()
```

Create a new exec resume command.

# `output_last_message`

```elixir
@spec output_last_message(t(), String.t()) :: t()
```

Set the output-last-message path.

# `output_schema`

```elixir
@spec output_schema(t(), String.t()) :: t()
```

Set the JSON Schema path for the final response.

# `prompt`

```elixir
@spec prompt(t(), String.t()) :: t()
```

Set the continuation prompt.

# `sandbox`

```elixir
@spec sandbox(t(), sandbox_mode()) :: t()
```

Set the sandbox mode.

Emits `-c sandbox_mode="<mode>"` rather than `--sandbox <mode>`: the
flag is accepted by `codex exec` only, and `codex exec resume` rejects
it with `unexpected argument`. The config key is the supported
equivalent and takes the same three values.

# `session_id`

```elixir
@spec session_id(t(), String.t()) :: t()
```

Set the session ID to resume.

# `skip_git_repo_check`

```elixir
@spec skip_git_repo_check(t()) :: t()
```

Skip the git repo check.

# `stream`

```elixir
@spec stream(t(), CodexWrapper.Config.t()) :: Enumerable.t()
```

Execute the command and return a lazy `Stream` of `%JsonLineEvent{}`.

Reads NDJSON output line-by-line through the configured
`CodexWrapper.Runner`. Forces `--json` on the command.

# `strict_config`

```elixir
@spec strict_config(t()) :: t()
```

Error out when `config.toml` contains fields this Codex version does not recognize.

Turns a silently-ignored typo in a config file into a failed run, which
is usually what a programmatic caller wants.

---

*Consult [api-reference.md](api-reference.md) for complete listing*