# Sessions and accounts Inspect account status and usage, continue a conversation, switch providers, and handle interrupted work without duplicating it. ## Check the account before starting work Use these commands on an existing, initialized machine whose rollout prerequisites are satisfied. Each named profile isolates its managed provider configuration. Select the provider explicitly when checking sign-in state. ```text oompa account list oompa account show personal --provider codex oompa account usage personal --refresh ``` Codex usage reports observed limits and resets; `oompa account usage-history personal --limit 50 --json` reads its retained local history. Claude exposes sign-in status, not account quotas or usage history. Oompa does not pool subscription limits or automatically move a failed turn to another account. A pending Codex login can be checked with `oompa account show personal --provider codex` and canceled with `oompa account login-cancel personal --provider codex`. A lost one-time URL cannot be recovered by starting another login over the pending attempt. Claude recovery instead requires the exact acknowledged command reported by status, after you have confirmed the original login child exited. ## Continue the same conversation ```text oompa session list oompa session status --json oompa session send -- "Review the latest changes." oompa session stop ``` Use the returned session ID in scripts. A session name is convenient for people, but can change. For live observation, read `data.eventStream.cursor` from status and pass that exact cursor to `oompa session watch --cursor --jsonl` so the status snapshot and subsequent events join without a gap. Queue a message for later with `oompa session queue -- `. Use `oompa session steer -- ` for the current turn. The [attachment contract](https://github.com/hraness/oompa/blob/main/docs/attachments.md) lists accepted files and limits. ## Change the provider for the next turn When the session is idle and the target provider is signed in, switch it explicitly. Claude Code requires a Linux execution machine. ```text oompa session switch --provider claude --preset fable-max oompa session export --format json ``` The new provider receives the retained tail of Oompa's conversation record. Its native thread, hidden state, and cached context do not transfer. Oompa states a retention gap when older recorded history was pruned; it does not invent history from before a session was adopted. Switching providers within the same account profile preserves the session's working-memory binding. An eligible manual switch to another account can transfer custody only after outstanding memory submissions settle. That transfer purges the old working lane and starts a fresh empty epoch; it does not carry working-memory contents across accounts. A failed transfer remains recoverable before the session is rebound. Shared project memory stays project-scoped. Presets control future turns and do not reinterpret an already-bound historical model until you select a preset. ## Inspect an interrupted operation before retrying A lost connection is not proof that a command failed before taking effect. Keep the command ID and reuse the exact recovery command or idempotency key Oompa reports. An ambiguous result needs inspection, not a new send. ```text oompa status --json oompa session status --json oompa remote command oompa sync status ``` A recovery-required session stays fenced while Oompa cannot prove who owns the provider process. Do not delete state or launch a second writer to clear it. `oompa session abandon ` ends Oompa's local session with provider state still unknown; use it only when you accept that consequence. ## Presets and permissions > **Conditional walkthrough.** Current daemon and hosted command-writer rollout remains blocked on capacity. Do not initialize, start, or autostart either the admitted v0.7.1 daemon or the v0.8.0 candidate until the hosted operator records protected two-pass zero-debt capacity evidence and its exact .activated readback receipt. Artifact availability and the live sync service do not clear this gate. After activation, complete the update runbook's daemon and target marker-2 proofs before globally enabling hosted writers. Oompa reviews the bound provider's exact runtime profile immediately before each new provider-native session or turn. For Codex, that refresh includes model, reasoning effort, Fast service tier, permission profile, computer-use capability, and accessible apps. For Claude, Oompa admits only the pinned Fable profile and reviewed host-tool boundary. An unavailable requirement fails before the provider effect. Every successful start records that exact account generation and effective profile; `oompa session show` displays the bound provider's history and recorded public profile. Read the provider-neutral Oompa record with `oompa session export` or the transcript endpoint. Codex profiles include the requested model, reasoning effort, service tier, permission profile, computer-use capability, and accessible apps; an empty enabled-app list is reported as empty. Claude Code public profiles include the pinned CLI, model, reasoning effort, default permission mode, and stream formats. Oompa privately reviews the exact config-home authority for every Claude effect but omits that custody identity and legacy isolation marker from `session show`; managed and adopted personal-home sessions therefore share one non-identifying public shape. Each provider remains authoritative for its native permissions, tools, and hidden runtime state. - `low`: Codex Luna Max, currently `gpt-5.6-luna` with `max` reasoning. - `high`: Codex Astra Max, currently `gpt-6-astra` with `max` reasoning. - `ultra`: Codex Astra Ultra, currently `gpt-6-astra` with `ultra` reasoning. - `fable-max`: Claude Code Fable, currently `claude-fable-5-1` with `max` reasoning. - `fast on|off`: a Codex-only, explicit per-turn Fast or Standard overlay. Claude Code refuses Fast instead of ignoring it. A prior Fast value cannot leak into the next turn. New Oompa-created Codex sessions that use `high` or `ultra`, and explicit selections of either preset, use the Astra mapping above (contract 2). The `low` and `fable-max` bindings are unchanged. Codex sessions already bound to contract 1 keep their exact Sol model and effort until a preset is explicitly selected; unrelated metadata edits, restart recovery, and queued work do not reinterpret an established session. `oompa init` reports the required confirmation without changing local state; `oompa init --yes` creates your Documents directory when it is absent, verifies that it is a readable, writable, and traversable canonical directory, and accepts it as the default project. Initialization is a one-shot maintenance command: run it before opening the persistent shell. The shell rejects `/init` because its running daemon already owns local state. Codex turns use Codex's `auto_review` path, the exact advertised `:workspace` permission profile, and the selected project as the runtime workspace root. Codex remains authoritative for the profile's effective sandbox, network policy, computer use, plugins, and protected turn inspection. Claude Code runs in its default interactive permission mode under the selected project and maps supported tool-use requests into Oompa interactions; it does not expose Codex's permission-profile, app, plugin, or protected turn-inspection surfaces. ## Next - [Complete command reference](/docs/reference/) - [Update and recovery runbook](/docs/status/#install-and-update)