diff --git a/.gitignore b/.gitignore
index 2660c26..51a9dc9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,8 +2,8 @@
 __pycache__/
 *.py[cod]
 *.egg-info/
-src/sevm/_revm*.so
-src/sevm/_revm*.pyd
+src/chasm_debugger/_revm*.so
+src/chasm_debugger/_revm*.pyd
 .eggs/
 build/
 dist/
diff --git a/AGENTS.md b/AGENTS.md
index 91bad67..bb643c1 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,10 +1,10 @@
-# AGENTS.md — sevm
+# AGENTS.md — Chasm
 
 Context for any agent working in this directory. Read before editing.
 
 ## What this is
 
-`sevm` is a fullscreen, gdb-compatible interactive debugger for Solidity, running on
+`chasm` is a fullscreen, gdb-compatible interactive debugger for Solidity, running on
 REVM. It stops *inside* a running transaction with the frame still alive: read
 uncommitted state, call view functions, rewrite a stack operand before the opcode
 consumes it, mutate storage through Solidity, and force out-of-gas at an exact
@@ -15,19 +15,19 @@ core is shared by the Python bridge and the headless JSON-RPC server.
 
 ## Layout (src layout)
 
-Every package `__init__.py` carries a map of its own modules, and `src/sevm/__init__.py`
+Every package `__init__.py` carries a map of its own modules, and `src/chasm_debugger/__init__.py`
 maps the whole tree. Read those first; `tests/test_layout.py` fails if one goes stale.
 
 ```
-sevm/
+debugger/
 ├── Cargo.toml            # Rust workspace: core, Python bridge, headless server
-├── pyproject.toml        # metadata, deps, `sevm` entry points, pytest + Maturin config
+├── pyproject.toml        # metadata, deps, `chasm` entry points, pytest + Maturin config
 ├── uv.lock               # pinned resolution
 ├── README.md             # landing page and usage
 ├── rust/                 # REVM core, PyO3 bridge, headless JSON-RPC server
 ├── docs/                 # commands, expressions, assembly, Foundry reference
-├── src/sevm/             # the package (import as `sevm`)
-│   ├── cli.py            # arg parsing + `main()`; `.py` vs `.sol` dispatch in `sevm run`
+├── src/chasm_debugger/   # the package (import as `chasm_debugger`)
+│   ├── cli.py            # arg parsing + `main()`; `.py` vs `.sol` dispatch in `chasm run`
 │   ├── session/          # source debugger over REVM: revm, snapshots, framelocals,
 │   │                     #   code, events
 │   ├── commands/         # the gdb command layer: processor + one module per verb group
@@ -36,22 +36,22 @@ sevm/
 │   ├── assembly/         # builtins, parser, execute
 │   ├── cheatcodes/       # registry, cheats, assertions, args, console
 │   ├── locals/           # layout, index, values
-│   ├── tui/              # app, pane, panes, layout, opcodes, theme, sevm.tcss
+│   ├── tui/              # app, pane, panes, layout, opcodes, theme, chasm.tcss
 │   ├── cache.py          # on-disk build cache: unit hashing, partial rebuilds
-│   ├── artifacts.py      # forge-shaped `out/sevm/<File.sol>/<Contract>.json`
+│   ├── artifacts.py      # forge-shaped `out/chasm/<File.sol>/<Contract>.json`
 │   ├── libs.py           # dependency resolution: imports -> repo -> clone -> remapping
 │   ├── foundry.py        # Foundry test runner: resolve project, discover, REVM driver
 │   ├── provider.py       # synchronous Web3 provider backed by the REVM session
-│   ├── revm_server.py    # `sevm-engine` headless-process entry point
+│   ├── revm_server.py    # `chasm-engine` headless-process entry point
 │   ├── frames.py, srcmap.py, decode.py, disasm.py, dispatch.py
-│   ├── doctor.py         # `sevm doctor`: compiler, runtimes, caches, overrides
+│   ├── doctor.py         # `chasm doctor`: compiler, runtimes, caches, overrides
 │   ├── breakpoints.py, clipboard.py
 │   └── console.py        # plain-text frontend (`--console`)
 ├── tests/                # one file per layer + conftest/harness/tui_harness
 └── examples/             # runnable, self-contained projects
 ```
 
-`sevm run` dispatches by extension: `.py` attaches to a web3 driver (below); `.sol`
+`chasm run` dispatches by extension: `.py` attaches to a web3 driver (below); `.sol`
 compiles + runs a Foundry test. Both paths resolve dependencies the same way. With no
 `-m` filter it debugs every test in the file: a
 fresh deploy + `setUp` + test per function, a breakpoint on each body, opening at the first
@@ -70,7 +70,7 @@ surface and v1 limits.
 
 ## Library resolution (libs.py)
 
-sevm ships no forge-std. `compile_foundry_project` walks the import graph
+chasm ships no forge-std. `compile_foundry_project` walks the import graph
 (`libs.import_closure`), and anything unresolved is installed: prefix -> `libs.ALIASES`,
 else npm registry metadata (`repository.url`) -> `git clone --depth 1 --branch <newest
 stable tag>` into `<root>/lib/<name>`, with the remapping derived from where the imported
@@ -101,7 +101,7 @@ from ~710ms to ~28ms. Inside the test contract itself the closure is nearly the
 project, so the cost stands.
 
 The second invocation is skipped outright for a bare identifier. `Evaluator._known_type`
-takes a bound local's type from the parameter sevm declares for it and a state variable's
+takes a bound local's type from the parameter chasm declares for it and a state variable's
 from solc's `typeString` in the AST, searching bindings first and then
 `linearizedBaseContracts`, which is the order Solidity itself shadows in. Both strings are
 what the probe's diagnostic would have named, so this is a lookup and not a second type
@@ -157,7 +157,7 @@ way; do not add `sys.path` hacks.
 resolved solc version, `optimize`, `evm_version`, the remappings, the output selection and
 every source's content hash. A hit loads `<cache>/<unit>.json.gz` (solc's standard-JSON
 output, `errors` stripped) and goes straight to `_build_project` without invoking solc. The
-cache is `cache/sevm/` inside a Foundry root, else `~/.cache/sevm/projects/<hash>`, so a
+cache is `cache/chasm/` inside a Foundry root, else `~/.cache/chasm/projects/<hash>`, so a
 plain directory is never written into.
 
 A miss with a usable base (same settings, same source *key set*) builds partially: solc
@@ -170,13 +170,13 @@ sees is unchanged, file ids, analysis and source maps come out identical to a fu
 `base_for` requires an identical key set because adding or removing a file shifts them.
 
 A build also leaves forge-shaped artifacts (`artifacts.write_out`): one JSON per contract
-under `<out>/sevm/<File.sol>/<Contract>.json`, `out` taken from foundry.toml. The `sevm/`
-nesting is load-bearing, not tidiness: sevm compiles optimizer-off, and overwriting
+under `<out>/chasm/<File.sol>/<Contract>.json`, `out` taken from foundry.toml. The `chasm/`
+nesting is load-bearing, not tidiness: chasm compiles optimizer-off, and overwriting
 `out/<File.sol>/<Contract>.json` would leave forge's own cache calling it fresh, so the
-next `forge test` would run sevm's build. Contract names that collide across sources with
+next `forge test` would run chasm's build. Contract names that collide across sources with
 the same basename get a `.1` suffix, and `sourceName` says which source each came from.
 Artifacts are written when a build happens, or when a hit finds the `out` tree gone; they
-carry no `metadata`, which is the one forge field sevm does not request from solc.
+carry no `metadata`, which is the one forge field chasm does not request from solc.
 
 Every cache failure is a miss, never an error. Tests must never touch `~/.cache`:
 `conftest.isolated_cache` points `XDG_CACHE_HOME` at tmp per test, which is also what lets
@@ -195,18 +195,18 @@ the standing instruction.
 Everything runs through uv. Do not call bare `pip`/`python` against a system interpreter.
 
 ```bash
-uv sync                 # editable install of sevm + dev group into .venv
-uv run sevm --help      # run the CLI
-uv run sevm run --contracts tests/contracts examples/debug_bank.py   # fullscreen TUI
-uv run sevm run --console --contracts tests/contracts examples/debug_bank.py
-uv run sevm compile tests/contracts                                  # what sevm sees
+uv sync                 # editable install of chasm + dev group into .venv
+uv run chasm --help      # run the CLI
+uv run chasm run --contracts tests/contracts examples/debug_bank.py   # fullscreen TUI
+uv run chasm run --console --contracts tests/contracts examples/debug_bank.py
+uv run chasm compile tests/contracts                                  # what chasm sees
 uv run pytest -q        # test suite (751 tests; ~2.5 min, solc compile is the slow part)
-SEVM_NETWORK_TESTS=1 uv run pytest -q -m network   # 4 more, against the real forge-std/npm
+CHASM_NETWORK_TESTS=1 uv run pytest -q -m network   # 4 more, against the real forge-std/npm
 uv run ruff check src tests examples   # lint (config in pyproject [tool.ruff])
 uv run ruff format src tests examples  # format (line length 90)
 uv run mypy src         # type check (pragmatic config, not strict)
 uv build                # wheel + sdist
-uv tool install .       # install the `sevm` command globally
+uv tool install .       # install the `chasm` command globally
 ```
 
 Style is enforced by ruff, not by hand: run `ruff format` and `ruff check --fix` before
@@ -217,7 +217,7 @@ fixture tuple and using only some fields is normal). Every module carries
 `from __future__ import annotations`, so annotations use builtin generics (`dict`,
 `list`, `X | None`), not `typing.Dict`/`Optional`.
 
-CLI shape: `sevm {run,compile,doctor}`. Options go **before** the target script; everything
+CLI shape: `chasm {run,compile,doctor}`. Options go **before** the target script; everything
 after the script is forwarded to it. Recognition of user contracts is by bytecode
 (runtime code matched against compiled artifacts, metadata hash stripped, immutables
 masked), so an unmodified web3 script works as a `run` target.
@@ -251,7 +251,7 @@ for directory trees only.
 ## Dependencies
 
 Declared in `pyproject.toml` and the Cargo manifests. Rule: every third-party Python
-package imported under `src/sevm` is a direct dependency rather than left to transitive
+package imported under `src/chasm_debugger` is a direct dependency rather than left to transitive
 resolution. `test_packaging.py` walks the imports and fails if one goes undeclared,
 mapping import names such as `solcx` to their distributions.
 Dev-only tools (`pytest`, `textual-dev`) live in the PEP 735 `[dependency-groups] dev`,
@@ -259,11 +259,11 @@ not in the runtime deps, and are not shipped in the wheel.
 
 Do not add `web3[tester]`, `eth-tester`, or `py-evm`: Web3 calls run through
 `provider.RevmProvider`. `eth-hash[pycryptodome]` is named directly so the keccak backend
-sevm relies on is not left to a transitive dependency.
+chasm relies on is not left to a transitive dependency.
 
 Two files are package data, both loaded relative to their module and included by the
-Maturin build: the Textual stylesheet `src/sevm/tui/sevm.tcss` and the node
-driver `src/sevm/compile/soljson.js`. If you move or rename either, update `CSS_PATH` in
+Maturin build: the Textual stylesheet `src/chasm_debugger/tui/chasm.tcss` and the node
+driver `src/chasm_debugger/compile/soljson.js`. If you move or rename either, update `CSS_PATH` in
 `tui/app.py` or `DRIVER` in `compile/wasm.py`, and re-check `uv build` still bundles it.
 Nothing else is: forge-std is no longer vendored.
 
@@ -277,14 +277,14 @@ release list publishes, and proves the result by running `--version` — a downl
 is not evidence it can execute, since the Linux builds are glibc-linked and musl or NixOS
 cannot run them. An existing `~/.solcx` binary, one of Foundry's under `~/.svm`, or a
 matching `solc` on PATH is used before anything is downloaded, and `--solc-binary` /
-`SEVM_SOLC` overrides the lot (that binary then also names the version, because it is what
+`CHASM_SOLC` overrides the lot (that binary then also names the version, because it is what
 runs and the version keys the build cache). py-solc-x still *invokes* solc through
 `compile_standard(solc_binary=...)`.
 
 Where no native build exists or the one downloaded cannot execute, `compile/wasm.py` runs
-solc's Emscripten build (`soljson.js`, cached under `~/.cache/sevm/solc-wasm/`) through
+solc's Emscripten build (`soljson.js`, cached under `~/.cache/chasm/solc-wasm/`) through
 node, which is the only option on musl, NixOS and unpublished architectures — it is a JS
-bundle, not a WASI module, so no Python runtime can load it. `SEVM_NODE` names the
+bundle, not a WASI module, so no Python runtime can load it. `CHASM_NODE` names the
 runtime. Output is identical to the native compiler's, which the build cache depends on
 since it is keyed on the solc version and not on the backend, so `solcbin.Compiler` is
 what the rest of the package holds rather than a path. Tests and examples use solc
@@ -298,14 +298,14 @@ what the rest of the package holds rather than a path. Tests and examples use so
 `Debugger` helper; `conftest.py` holds the fixtures every file shares and `tui_harness.py`
 the Textual pilot helpers. Test files import them with `from harness import ...`, which
 works because `pyproject.toml` sets
-`[tool.pytest.ini_options] pythonpath = ["tests"]`; the `sevm` package itself is imported
+`[tool.pytest.ini_options] pythonpath = ["tests"]`; the `chasm_debugger` package is imported
 from the editable install. Fixtures are self-contained under `tests/contracts/`
 (`Bank.sol`, `Locals.sol`, `Vault.sol`) — do not reach outside the project for a contract.
 
 `test_cheatcodes.py` covers the cheat registry itself. Every registered signature is
 exercised once and `test_every_cheat_is_exercised` fails if one is added without a case.
 The expected values are not invented, each was read off a run of the same call under real
-`forge test`, so the file doubles as sevm's differential record of Foundry behaviour. The
+`forge test`, so the file doubles as chasm's differential record of Foundry behaviour. The
 generated `vm.assert*` overloads are driven from the signature rather than a hand-written
 table, which is the only way 116 of them stay covered. Cheats that touch VM state are
 proven a second time end to end in `test_foundry.py`, where they reach a real REVM
@@ -320,7 +320,7 @@ provisioning against faked release lists and downloads: which list each platform
 version comes from, the checksum gate, and that an already-installed binary (including
 svm's) is preferred to a download. `test_wasm.py` covers the fallback with a stub runtime
 in place of node, and its one network test compiles a fixture both ways and requires the
-documents to be equal. `test_doctor.py` covers which facts `sevm doctor` calls problems,
+documents to be equal. `test_doctor.py` covers which facts `chasm doctor` calls problems,
 since that is what its exit status is. `test_packaging.py` guards `pyproject.toml`: no dependency may
 ask for the `tester` extra, every package the sources import is declared, and keccak
 answers on the pycryptodome backend. `test_layout.py` guards the package tree itself: every module
@@ -339,7 +339,7 @@ and its own `lib/forge-std/src/`, which must be used untouched). Both are copied
 end by running each test to completion (the test's own `assertEq`s prove the effect).
 
 Tests marked `network` reach the real forge-std, npm and openzeppelin repositories, and
-are skipped unless `SEVM_NETWORK_TESTS=1`. One of them asserts sevm implements every
+are skipped unless `CHASM_NETWORK_TESTS=1`. One of them asserts chasm implements every
 `assert*` the current forge-std declares, so a new overload upstream fails the suite
 rather than surfacing as "unimplemented cheatcode" at run time.
 
@@ -357,7 +357,7 @@ rather than surfacing as "unimplemented cheatcode" at run time.
    debuggable artifact.
 8. Implement the `vm.assert*` cheats as real comparisons. forge-std calls the `*Decimal`
    and `*ApproxEq*` forms unconditionally, so a blanket revert fails passing assertions.
-9. Bind `msg.data`/`msg.sig` from the frame. The injected `__sevm_eval` is reached by a
+9. Bind `msg.data`/`msg.sig` from the frame. The injected `__chasm_eval` is reached by a
    real call, so read directly they report *that* call's calldata (`0x365a2820` plus the
    bound locals), silently and plausibly wrong.
 10. Apply a delegate-call prank to both caller identity and target/storage context in the
@@ -384,7 +384,7 @@ pushes a new internal frame; and REVERT pauses only surface while a debugger is
 REVM 43.0.2, Rust 1.92.0, Maturin 1.15.0, web3 7.16.0, py-solc-x 2.0.5, solc 0.8.28,
 git 2.x, forge-std 1.16.2, and CPython 3.12. `requires-python = ">=3.10"`; the Rust
 workspace requires 1.91+. All 832 offline tests pass as of 2026-09-14 (5 more with
-`SEVM_NETWORK_TESTS=1`), covering every registered cheatcode
+`CHASM_NETWORK_TESTS=1`), covering every registered cheatcode
 against values taken from real forge, Foundry multi-test coverage, library install and
 remapping derivation, the assertion engine, the Yul assembly surface, the build cache and
 its artifacts, the snapshot refresh after a mutation, the dispatcher and selector layer,
diff --git a/Cargo.lock b/Cargo.lock
index 4658ece..ae8713b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -768,6 +768,34 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
 
+[[package]]
+name = "chasm-revm-core"
+version = "0.1.0"
+dependencies = [
+ "crossbeam-channel",
+ "revm",
+]
+
+[[package]]
+name = "chasm-revm-headless"
+version = "0.1.0"
+dependencies = [
+ "chasm-revm-core",
+ "revm",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "chasm-revm-python"
+version = "0.1.0"
+dependencies = [
+ "chasm-revm-core",
+ "chasm-revm-headless",
+ "pyo3",
+ "revm",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.45"
@@ -2591,34 +2619,6 @@ dependencies = [
  "syn 3.0.5",
 ]
 
-[[package]]
-name = "sevm-revm-core"
-version = "0.1.0"
-dependencies = [
- "crossbeam-channel",
- "revm",
-]
-
-[[package]]
-name = "sevm-revm-headless"
-version = "0.1.0"
-dependencies = [
- "revm",
- "serde",
- "serde_json",
- "sevm-revm-core",
-]
-
-[[package]]
-name = "sevm-revm-python"
-version = "0.1.0"
-dependencies = [
- "pyo3",
- "revm",
- "sevm-revm-core",
- "sevm-revm-headless",
-]
-
 [[package]]
 name = "sha2"
 version = "0.10.9"
diff --git a/Cargo.toml b/Cargo.toml
index 6c55e3b..426a021 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,5 +10,5 @@ license = "MIT"
 
 [workspace.dependencies]
 revm = { version = "=43.0.2", default-features = false, features = ["std"] }
-sevm-revm-core = { path = "rust/core" }
-sevm-revm-headless = { path = "rust/headless" }
+chasm-revm-core = { path = "rust/core" }
+chasm-revm-headless = { path = "rust/headless" }
diff --git a/README.md b/README.md
index b44ec57..7cc8fba 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-# sevm
+# Chasm
 
-`sevm` is an interactive, gdb-style Solidity/EVM debugger on REVM, built for red-team dynamic analysis.
+Chasm is an interactive, gdb-style Solidity/EVM debugger on REVM, built for red-team dynamic analysis.
 
 - **Full control**: Stepping through Solidity is only half of what this debugger does. Here you are `root` on the EVM, free to rewrite state, the stack, memory, storage, and gas while the transaction is still live.
-- **Go low or high level**: Whether you are checking invariants with the source in hand, or dropping into raw EVM to build a jump-oriented programming (JOP) chain from a contract's bytecode, sevm handles both.
-- **See everything**: No source, no problem. sevm maps every public function and the flow through it, wired into the decompiled output, so you can see what storage and memory changed at each step.
+- **Go low or high level**: Whether you are checking invariants with the source in hand, or dropping into raw EVM to build a jump-oriented programming (JOP) chain from a contract's bytecode, Chasm handles both.
+- **See everything**: No source, no problem. Chasm maps every public function and the flow through it, wired into the decompiled output, so you can see what storage and memory changed at each step.
 - **Foundry compatible**: Use Foundry cheatcodes while debugging.
 - **Frontend-independent**: Drive the Rust engine through the bundled JSON-RPC process
   from an editor, web service, terminal UI, or any other client.
@@ -40,7 +40,7 @@
 
 ## Install
 
-Clone the repository and install `sevm` as a global command:
+Clone the repository and install `chasm` as a global command:
 
 ```bash
 git clone https://github.com/ChasmHQ/debugger && cd debugger
@@ -51,62 +51,65 @@ pipx install uv
 uv tool install .
 ```
 
-Building from this checkout needs Python 3.10+, Rust 1.91+, and `git`. sevm downloads solc
+Building from this checkout needs Python 3.10+, Rust 1.91+, and `git`. chasm downloads solc
 itself into `~/.solcx`, picking the build for this machine. x86-64 and arm64 Linux, Intel
 and Apple silicon macOS, and Windows are covered, and a solc already installed by Foundry
 (`~/.svm`) or sitting on `PATH` is used instead. Anywhere else, on musl systems like
-Alpine, NixOS, or an architecture Solidity does not publish for, sevm falls back to
-solc's WebAssembly build, which needs `node` on PATH (or named by `SEVM_NODE`). Failing
-that, point sevm at a compiler you have:
+Alpine, NixOS, or an architecture Solidity does not publish for, chasm falls back to
+solc's WebAssembly build, which needs `node` on PATH (or named by `CHASM_NODE`). Failing
+that, point chasm at a compiler you have:
 
 ```bash
-sevm compile --solc-binary /usr/bin/solc examples/bank/src
+chasm compile --solc-binary /usr/bin/solc examples/bank/src
 ```
 
-`SEVM_SOLC=/usr/bin/solc` does the same for every command.
+`CHASM_SOLC=/usr/bin/solc` does the same for every command.
 
 ## Usage
 
-sevm has the following subcommands:
+Chasm has the following subcommands:
 - `run`: debug a Foundry test, or a web3.py driver script.
-- `compile`: compile the contracts and report what sevm sees.
-- `doctor`: report the compiler, runtimes and caches sevm found on this machine.
+- `compile`: compile the contracts and report what chasm sees.
+- `doctor`: report the compiler, runtimes and caches chasm found on this machine.
 
 For detailed information on each command and its options, run:
 
 ```bash
-sevm -h
-sevm <COMMAND> -h
+chasm -h
+chasm <COMMAND> -h
 ```
 
-By default `sevm run` opens the fullscreen interface in the screenshot above. The examples
+By default `chasm run` opens the fullscreen interface in the screenshot above. The examples
 below use `--console`, the plain-text frontend, but the commands are identical in both.
 
 ### Debug a Foundry test
 
-Point `sevm run` at a `.sol` test and it runs without an existing Foundry project, even
-when the file imports forge-std or other libraries. sevm resolves the imports, clones what
+Point `chasm run` at a `.sol` test and it runs without an existing Foundry project, even
+when the file imports forge-std or other libraries. chasm resolves the imports, clones what
 is missing, writes the remappings, and breaks on the first line of the test body:
 
 ```bash
-$ sevm run --console -y examples/standalone/Vault.t.sol
-standalone test at examples/standalone; compiling ...
-installing forge-std from https://github.com/foundry-rs/forge-std @ v1.16.2
+$ chasm run --console -y examples/standalone/Vault.t.sol
+standalone test at /tmp/debugger2/examples/standalone; compiling ...
+installing forge-std from https://github.com/foundry-rs/forge-std @ v1.17.0
 installing @openzeppelin/contracts from https://github.com/OpenZeppelin/openzeppelin-contracts @ v5.7.0
 wrote 2 remapping(s) to remappings.txt
-wrote 25 artifact(s) to out/sevm
+wrote 25 artifact(s) to out/chasm
 debugging 1 test(s): VaultTest.testDeal
+Chasm - Solidity/EVM debugger. gdb commands; `help` for the list.
 Breakpoint 1, VaultTest.testDeal() at Vault.t.sol:11
   11          vm.deal(alice, 3 ether);
+pc 0x0c3d  PUSH20  sp 3  gas 29,978,755  step 126
+(chasm)
 ```
 
 Each test gets a fresh deploy, a `setUp()` and the test call, as forge isolates them. With
-no filter, sevm debugs every test it discovers and `continue` runs to the next test body.
+no filter, chasm debugs every test it discovers and `continue` runs to the next test body.
 `-m/--match` narrows to test functions matching a substring, `--match-contract` to a
 contract:
 
 ```bash
-sevm run --console -m testDeposit examples/bank/test/Bank.t.sol
+chasm run --console -m testDeposit examples/bank/test/Bank.t.sol
 ```
 
 Inside a project with a `foundry.toml`, nothing is fetched. The project's `remappings.txt`,
@@ -114,21 +117,23 @@ Inside a project with a `foundry.toml`, nothing is fetched. The project's `remap
 
 ### Debug a web3.py script
 
-`sevm run` also takes a plain web3.py script. A script that constructs
-`EthereumTesterProvider` runs unmodified: while the driver is active, sevm supplies its
+`chasm run` also takes a plain web3.py script. A script that constructs
+`EthereumTesterProvider` runs unmodified: while the driver is active, chasm supplies its
 REVM-backed provider, runs the script on a worker thread, and stops the first time
 execution enters code it recognises:
 
 ```bash
-$ sevm run --console --contracts examples/bank/src examples/debug_bank.py
-compiling examples/bank/src ...
-cache hit (1 sources)
+$ chasm run --console --contracts examples/bank/src examples/debug_bank.py
+compiling /tmp/debugger/examples/bank/src ...
+wrote 2 artifact(s) to out/chasm
 2 contract(s): Bank, Callee
-bank : 0xF2E246BB76DF876Cef8b38ae84130F4F55De395b
-alice: 0x2da044dB7416b5210C46b2dCdd521DBff696F3aa
+bank : 0x092cAc6DB1DE08aE9590C7528a5E050FEA367552
+alice: 0x72C7F68b160Fd5bF38A207097B3e8cFBC4C9E084
+Chasm - Solidity/EVM debugger. gdb commands; `help` for the list.
 Bank.deposit() at src/Bank.sol:51
   51      function deposit() public payable {
-(sevm)
+pc 0x0379  JUMPDEST sp 1  gas 278,754  step 570
+(chasm)
 ```
 
 Recognition is by bytecode, not by instrumentation, which is why an unmodified script
@@ -136,17 +141,17 @@ works. Startup commands run before the prompt opens, so a session can land where
 it:
 
 ```bash
-sevm run -x 'b _credit' -x c --contracts examples/bank/src examples/debug_bank.py
+chasm run -x 'b _credit' -x c --contracts examples/bank/src examples/debug_bank.py
 ```
 
 ### Connect another frontend
 
-`sevm-engine` exposes the same Rust debugger core as JSON-RPC 2.0 over newline-delimited
+`chasm-engine` exposes the same Rust debugger core as JSON-RPC 2.0 over newline-delimited
 standard input and output. A frontend can own presentation and process lifecycle without
 embedding Python or depending on the console or TUI:
 
 ```bash
-sevm-engine < examples/headless-session.jsonl
+chasm-engine < examples/headless-session.jsonl
 ```
 
 The protocol supports persistent chains, transactions, stepping, breakpoints, snapshots,
@@ -162,12 +167,12 @@ For a script that takes its calldata as an argument, that is the whole iterate l
 one session, without relaunching anything:
 
 ```bash
-(sevm) b CALLDATACOPY
-(sevm) c
+(chasm) b CALLDATACOPY
+(chasm) c
 Breakpoint 1, ...
 pc 0x015c  CALLDATACOPY sp 1->7  gas 29,976,201  step 101
-(sevm) run 0x000040c3...your next attempt...
-(sevm) c                        # breakpoint survived the restart
+(chasm) run 0x000040c3...your next attempt...
+(chasm) c                        # breakpoint survived the restart
 ```
 
 Every stop ends with a one-line machine echo, giving pc, opcode, gas, step, and the stack
@@ -179,9 +184,9 @@ will accept as one line, so an argument of the form `@path` is read from that fi
 instead, with whitespace stripped. It works at launch, at the prompt, and standalone:
 
 ```bash
-sevm run ... script.py @C:/path/to/payload.hex   # at launch
-(sevm) run @C:/path/to/payload.hex               # at the prompt
-python script.py @payload.hex                    # without sevm at all
+chasm run ... script.py @C:/path/to/payload.hex   # at launch
+(chasm) run @C:/path/to/payload.hex               # at the prompt
+python script.py @payload.hex                    # without chasm at all
 ```
 
 ### Set breakpoints
@@ -190,24 +195,24 @@ Break on a function, a source line, a raw program counter, or on every occurrenc
 opcode in any contract:
 
 ```bash
-(sevm) b _credit                 # a function, by name or Contract.name
-(sevm) b Bank.sol:46             # a source line, snapped to the next line with code
-(sevm) b *0x108                  # a raw program counter
-(sevm) b SSTORE                  # every SSTORE, anywhere
-(sevm) b Bank.sol:46 if amount > 1 ether
+(chasm) b _credit                 # a function, by name or Contract.name
+(chasm) b Bank.sol:46             # a source line, snapped to the next line with code
+(chasm) b *0x108                  # a raw program counter
+(chasm) b SSTORE                  # every SSTORE, anywhere
+(chasm) b Bank.sol:46 if amount > 1 ether
 ```
 
 An opcode breakpoint is the way into code you have no line numbers for:
 
 ```bash
-(sevm) b SSTORE
+(chasm) b SSTORE
 Breakpoint 1 on every SSTORE
-(sevm) c
+(chasm) c
 Breakpoint 1, Bank._credit(address, uint256) at src/Bank.sol:46
   46          balances[who] += amount - fee;
 ```
 
-sevm also stops on reverts by default, at the failing instruction, and decodes the reason
+chasm also stops on reverts by default, at the failing instruction, and decodes the reason
 as `reverted: "..."`, `panic 0x11`, or a custom error with its arguments.
 
 ### Inspect the frame
@@ -215,7 +220,7 @@ as `reverted: "..."`, `panic 0x11`, or a custom error with its arguments.
 `info registers` is the machine at a glance:
 
 ```bash
-(sevm) info registers
+(chasm) info registers
 pc           0x09b5
 opcode       PUSH0 (0x5f)
 gas          278,719 remaining / 217 used of 278,936
@@ -234,7 +239,7 @@ step         582
 single slot number:
 
 ```bash
-(sevm) info storage
+(chasm) info storage
 Bank at 0xf2e246bb76df876cef8b38ae84130f4f55de395b
   slot   0+0  owner            address                = 0x7e5f4552091a69125d5dfcb7b8c2659029395bdf (cold)
   slot   0+20 feeBps           uint96                 = 25 (cold)
@@ -242,14 +247,14 @@ Bank at 0xf2e246bb76df876cef8b38ae84130f4f55de395b
   slot   2+0  balances         mapping(address => uint256) = <mapping: query a key> (cold)
   slot   3+0  accounts         mapping(address => struct Bank.Account) = <mapping: query a key> (cold)
   slot   4+0  history          uint256[]              = [0 items] [] (cold)
-  slot   5+0  name             string                 = "sevm-bank" (cold)
+  slot   5+0  name             string                 = "chasm-bank" (cold)
 ```
 
 `bt` walks the call stack. Internal Solidity calls get their own frames even though the EVM
 never changed depth:
 
 ```bash
-(sevm) bt
+(chasm) bt
 -> #0 Bank._credit(address, uint256) at src/Bank.sol:45
    #1 Bank.deposit() at src/Bank.sol:52
    #2 Bank at pc 0x380
@@ -259,7 +264,7 @@ never changed depth:
 line each instruction belongs to, and `x/NFU` examines memory in gdb syntax:
 
 ```bash
-(sevm) l
+(chasm) l
 src/Bank.sol
  .   40      function _fee(uint256 amount) internal view returns (uint256) {
  .   41          return (amount * feeBps) / 10000;
@@ -272,13 +277,13 @@ src/Bank.sol
  .   48          history.push(amount);
      49      }
      50  
-(sevm) disas
+(chasm) disas
    09b3  JUMP L51
    09b4  JUMPDEST L44
 => 09b5  PUSH0 L45
    09b6  PUSH2 0x09be L45
    09b9  DUP3 L45
-(sevm) x/32xb 0x80
+(chasm) x/32xb 0x80
 0x0080: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 0x0090: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 (memory is 96 bytes; the rest reads as zero)
@@ -290,62 +295,62 @@ src/Bank.sol
 state snapshot, and throws the snapshot away, so it cannot disturb the run:
 
 ```bash
-(sevm) p balances[who] + 100 ether
+(chasm) p balances[who] + 100 ether
 $1 = 100000000000000000000 (100 ether)  (uint256)
-(sevm) p keccak256(abi.encode(who, amount))
+(chasm) p keccak256(abi.encode(who, amount))
 $2 = 0x7a26c77763128d91079351eafa8c68f983a19e3262ef0fcc7ac5a257c2253c3a  (bytes32)
-(sevm) p type(uint256).max
+(chasm) p type(uint256).max
 $3 = 115792089237316195423570985008687907853269984665640564039457584007913129639935  (uint256)
 ```
 
 Because it *is* Solidity, `internal` and `private` functions are callable too:
 
 ```bash
-(sevm) p _fee(1 ether)
+(chasm) p _fee(1 ether)
 $4 = 2500000000000000 (0.002500 ether)  (uint256)
 ```
 
 `p` discards its side effects. `call` keeps them:
 
 ```bash
-(sevm) call setNickname("hodler")
+(chasm) call setNickname("hodler")
 done (gas 27599)
-(sevm) p accounts[msg.sender].nickname
+(chasm) p accounts[msg.sender].nickname
 $5 = "hodler"  (string memory)
-(sevm) call history.push(7)
+(chasm) call history.push(7)
 done (gas 44484)
-(sevm) p history.length
+(chasm) p history.length
 $6 = 1  (uint256)
 ```
 
 `display` re-evaluates an expression at every stop, and `ptype` reports a type:
 
 ```bash
-(sevm) display fee
+(chasm) display fee
 1: fee = <EvalError: local `fee` cannot be used in an expression: this instruction allocates it; step once to
 see it>
-(sevm) n
+(chasm) n
 Bank._credit(address, uint256) at src/Bank.sol:46
   46          balances[who] += amount - fee;
 1: fee = 5000000000000000 (0.005000 ether)
-(sevm) ptype balances[who]
+(chasm) ptype balances[who]
 type = uint256
 ```
 
 ### Read local variables
 
-solc emits no location for locals, so sevm reconstructs them from the AST and the run's
+solc emits no location for locals, so chasm reconstructs them from the AST and the run's
 stack heights. `info locals` names, types and decodes them:
 
 ```bash
-(sevm) info locals
+(chasm) info locals
   who            address            = 0x2da044db7416b5210c46b2dcdd521dbff696f3aa (param)
   amount         uint256            = 2000000000000000000 (2 ether) (param)
   fee            uint256            = <unavailable>  this instruction allocates it; step once to see it
-(sevm) n
+(chasm) n
 Bank._credit(address, uint256) at src/Bank.sol:46
   46          balances[who] += amount - fee;
-(sevm) p amount - fee
+(chasm) p amount - fee
 $1 = 1995000000000000000 (1.995000 ether)  (uint256)
 ```
 
@@ -356,9 +361,9 @@ A local that cannot be read says why rather than printing a wrong number.
 A watchpoint breaks when a value changes, and reports the old and new values:
 
 ```bash
-(sevm) watch totalDeposits
+(chasm) watch totalDeposits
 Watchpoint 2: totalDeposits (slot 0x1 of 0xf2e2..395b)
-(sevm) c
+(chasm) c
 Watchpoint 2 totalDeposits: 0xde0b6b3a7640000 -> 0x299060a1be4b8000
   Bank._credit(address, uint256) at src/Bank.sol:47
   47          totalDeposits += amount - fee;
@@ -374,11 +379,11 @@ correctly. The write lands in the transaction that is still running, and it chan
 outcome:
 
 ```bash
-(sevm) set var fee = 1 ether
+(chasm) set var fee = 1 ether
 fee = 1000000000000000000 (1 ether)
-(sevm) set var balances[who] = 5 ether
+(chasm) set var balances[who] = 5 ether
 balances[who] = 5000000000000000000 (5 ether)
-(sevm) c
+(chasm) c
 total deposits: 2000000000000000000
 alice balance : 6000000000000000000
 ```
@@ -389,10 +394,10 @@ Without those two writes the same script prints `2995000000000000000` and
 The lower-level writes are there too:
 
 ```bash
-(sevm) set $stack[0] = 0xc0ffee     # rewrite an operand before its opcode consumes it
-(sevm) set $mem[0x80] = 1
-(sevm) set $storage[0] = 0xdead
-(sevm) jump 0x108                   # move the program counter, JUMPDESTs only
+(chasm) set $stack[0] = 0xc0ffee     # rewrite an operand before its opcode consumes it
+(chasm) set $mem[0x80] = 1
+(chasm) set $storage[0] = 0xdead
+(chasm) jump 0x108                   # move the program counter, JUMPDESTs only
 ```
 
 ### Force an out-of-gas
@@ -400,9 +405,9 @@ The lower-level writes are there too:
 Set the gas counter to whatever you need and let the transaction run into the wall:
 
 ```bash
-(sevm) set $gas = 100
+(chasm) set $gas = 100
 $gas = 100
-(sevm) c
+(chasm) c
 Stopped on error: OutOfGas: out of gas; `set $gas = N` then `c` retries this instruction
   Bank._fee(uint256) at src/Bank.sol:41
   41          return (amount * feeBps) / 10000;
@@ -414,8 +419,8 @@ meter and continue, and the failed instruction is retried on its original stack.
 transaction then runs as if it had been sent with the larger limit:
 
 ```bash
-(sevm) set $gas = 5000000
-(sevm) c
+(chasm) set $gas = 5000000
+(chasm) c
 ```
 
 The failure is real, not simulated. The script's own output shows the deposit never
@@ -431,7 +436,7 @@ alice balance : 0
 `info gas` breaks the spend down by source line and by opcode:
 
 ```bash
-(sevm) info gas
+(chasm) info gas
 limit        278,936
 used         28,864
 remaining    250,072
@@ -459,19 +464,19 @@ A failed forge-std assertion stops the debugger where it broke, with the compari
 decoded, and `up` walks back to your test:
 
 ```bash
-$ sevm run --console -y -m testBalanceIgnoresFee examples/bank/test/FailingAssertion.t.sol
+$ chasm run --console -y -m testBalanceIgnoresFee examples/bank/test/FailingAssertion.t.sol
 debugging 1 test(s): FailingAssertionTest.testBalanceIgnoresFee
 Breakpoint 1, FailingAssertionTest.testBalanceIgnoresFee() at test/FailingAssertion.t.sol:18
   18          vm.prank(alice);
-(sevm) c
+(chasm) c
 Stopped on error: reverted: "assertion failed: 997500000000000000 != 1000000000000000000"
   StdAssertions.assertEq(uint256, uint256) at lib/forge-std/src/StdAssertions.sol:121
  121              vm.assertEq(left, right);
-(sevm) up
+(chasm) up
 #1  FailingAssertionTest.testBalanceIgnoresFee() at test/FailingAssertion.t.sol:20
 ```
 
-This works because sevm implements the `vm.assert*` family as real comparisons, all 116
+This works because chasm implements the `vm.assert*` family as real comparisons, all 116
 overloads that forge-std's own `assertEq` and friends call into.
 
 ### Use Foundry cheatcodes
@@ -480,15 +485,15 @@ Cheatcodes run against live REVM state, both from inside the test and typed at t
 against the frame you are stopped in:
 
 ```bash
-(sevm) vm.warp(12345)
+(chasm) vm.warp(12345)
 vm.warp -> ok
-(sevm) p block.timestamp
+(chasm) p block.timestamp
 $1 = 12345  (uint256)
-(sevm) vm.deal(alice, 5 ether)
+(chasm) vm.deal(alice, 5 ether)
 vm.deal -> ok
-(sevm) p alice.balance
+(chasm) p alice.balance
 $2 = 5000000000000000000 (5 ether)  (uint256)
-(sevm) vm.prank(address(0xcafe))
+(chasm) vm.prank(address(0xcafe))
 vm.prank -> ok
 ```
 
@@ -498,7 +503,7 @@ address the way Solidity's own `address(0xcafe)` does. When nothing fits, the er
 the argument and keeps solc's reason:
 
 ```bash
-(sevm) vm.prank(alcie)
+(chasm) vm.prank(alcie)
 error: vm.prank: argument 1 (alcie) is not a valid address (Undeclared identifier. Did you mean "alice"? (in
 `alcie`))
 ```
@@ -516,11 +521,11 @@ Type a Yul builtin and it runs on the paused frame through REVM's opcode
 implementations. This is the low-level twin of `set var`:
 
 ```bash
-(sevm) mload(0x40)
+(chasm) mload(0x40)
 mload(0x40) -> $1 = 0x80 (128)  (gas 12)
-(sevm) sstore(3, add(sload(3), 1))
+(chasm) sstore(3, add(sload(3), 1))
 sstore(3, add(sload(3), 1)) -> ok  (gas 22,103)
-(sevm) asm mstore(0x80, 1); mstore8(0xa0, 0x61); mload(0x80)
+(chasm) asm mstore(0x80, 1); mstore8(0xa0, 0x61); mload(0x80)
 mstore(0x80, 1) -> ok  (gas 18)
 mstore8(0xa0, 0x61) -> ok  (gas 21)
 mload(0x80) -> $2 = 0x1 (1)  (gas 18)
@@ -531,7 +536,7 @@ transaction that succeeds into one that runs out of gas. Control-flow builtins a
 frame terminators are refused, with the reason:
 
 ```bash
-(sevm) jump(0x10)
+(chasm) jump(0x10)
 error: `jump`: Yul has no `jump`; use the debugger's `jump 0xPC` or `set $pc = 0xPC`
 ```
 
@@ -541,13 +546,13 @@ Convenience variables bypass solc, so they work on contracts you have no source
 they still mix into a Solidity expression:
 
 ```bash
-(sevm) p $pc
+(chasm) p $pc
 $1 = 2497  (uint256)
-(sevm) p $storage[1] + 1 ether
+(chasm) p $storage[1] + 1 ether
 $2 = 2000000000000000000 (2 ether)  (uint256)
-(sevm) p $stack[0]
+(chasm) p $stack[0]
 $3 = 5000000000000000 (0.005000 ether)  (uint256)
-(sevm) x/32xb $mem[0x40]
+(chasm) x/32xb $mem[0x40]
 0x0080: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 0x0090: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 ```
@@ -559,9 +564,9 @@ Selectors come out of the bytecode rather than the ABI, so a 4-byte value from a
 be traced to the pc it routes to even when nothing here declares it:
 
 ```bash
-(sevm) sig transfer(address,uint256)
+(chasm) sig transfer(address,uint256)
 transfer(address,uint256)  0xa9059cbb  (hashed here; not in this ABI)
-(sevm) info address 0xa9059cbb
+(chasm) info address 0xa9059cbb
 selector     0xa9059cbb
 the dispatcher never tests this selector: a call carrying it lands in the fallback
 ```
@@ -576,12 +581,12 @@ implementation's JUMPDEST behind it, which is the pc every caller converges on.
 hit includes instruction alignment and the nearest preceding JUMPDEST:
 
 ```bash
-(sevm) find 5b
+(chasm) find 5b
 ```
 
 ### Debug from an AI client (MCP)
 
-`sevm mcp` serves the debugger over the Model Context Protocol (stdio). It provides
+`chasm mcp` serves the debugger over the Model Context Protocol (stdio). It provides
 windowed reads with explicit truncation, a stop report after every navigation, and a
 diff of what the last step changed. Operand provenance (`why N`) traces stack values
 through recorded opcodes. The server also checks compiled runtime bytecode against a
@@ -590,11 +595,11 @@ and client configuration.
 
 ### Compile a project
 
-`sevm compile` runs the same build the debugger does and reports what it produced, which is
+`chasm compile` runs the same build the debugger does and reports what it produced, which is
 the fastest way to check whether a contract will be debuggable at all:
 
 ```bash
-$ sevm compile examples/bank/src
+$ chasm compile examples/bank/src
 cache hit (1 sources)
 solc 0.8.36, optimizer off
   src/Bank.sol id=0 lines=99
@@ -606,31 +611,31 @@ solc 0.8.36, optimizer off
 compilation unit, so an edit recompiles the file and its importers rather than the project:
 
 ```bash
-$ cd examples/bank && time sevm compile .
-wrote 27 artifact(s) to out/sevm
+$ cd examples/bank && time chasm compile .
+wrote 27 artifact(s) to out/chasm
 real  1.95
 
-$ time sevm compile .
+$ time chasm compile .
 cache hit (22 sources)
 real  0.53
 
-$ time sevm compile .        # after editing one test
+$ time chasm compile .        # after editing one test
 recompiled 1 of 22 sources
 real  1.02
 ```
 
-Artifacts land in `out/sevm/` in forge's layout, and the cache in `cache/sevm/`. Both are
+Artifacts land in `out/chasm/` in forge's layout, and the cache in `cache/chasm/`. Both are
 cleared by `forge clean`. A directory with no `foundry.toml` gets nothing written into it.
 
 ### Check the environment
 
-`sevm doctor` says which compiler this machine will use, where it came from, and what is
+`chasm doctor` says which compiler this machine will use, where it came from, and what is
 missing. It downloads nothing: a compiler that is not installed yet is reported as the
 URL it would be fetched from:
 
 ```bash
-$ sevm doctor
-  sevm       0.1.0
+$ chasm doctor
+  chasm       0.1.0
   python     3.12.14 (CPython) at /home/fev/Projects/debugger/.venv/bin/python3
   platform   linux-arm64 (Linux aarch64, glibc 2.43)
   git        git version 2.55.0
@@ -639,13 +644,13 @@ $ sevm doctor
   available  68 releases, 0.5.0 .. 0.8.36
   wasm solc  /home/fev/.local/share/mise/installs/node/latest/bin/node v26.8.1
   binaries   /home/fev/.solcx
-  cache      /home/fev/.cache/sevm
+  cache      /home/fev/.cache/chasm
 ```
 
-Anything that would stop sevm working is marked `!` and makes the command exit non-zero,
-so it doubles as a CI check. `platform` is the build sevm downloads for, and `available`
+Anything that would stop chasm working is marked `!` and makes the command exit non-zero,
+so it doubles as a CI check. `platform` is the build chasm downloads for, and `available`
 is what that platform publishes. Where nothing is published, `wasm solc` is what will run
-instead, and an override from `SEVM_SOLC`, `SEVM_NODE` or `SOLCX_BINARY_PATH` is listed on
+instead, and an override from `CHASM_SOLC`, `CHASM_NODE` or `SOLCX_BINARY_PATH` is listed on
 an `overrides` line so a stale environment variable cannot hide.
 
 ## Reference
@@ -665,7 +670,7 @@ Set up an editable environment:
 
 ```bash
 uv sync
-uv run sevm --help
+uv run chasm --help
 ```
 
 Format, lint, type-check, and build:
@@ -683,7 +688,7 @@ The suite runs under pytest and lives in `tests/`:
 
 ```bash
 uv run pytest -q                                   
-SEVM_NETWORK_TESTS=1 uv run pytest -q -m network   
+CHASM_NETWORK_TESTS=1 uv run pytest -q -m network
 ```
 
 ## License
diff --git a/assets/screenshot.png b/assets/screenshot.png
index 87c0c5e..6d4a138 100644
Binary files a/assets/screenshot.png and b/assets/screenshot.png differ
diff --git a/docs/assembly.md b/docs/assembly.md
index a066585..e1cd95d 100644
--- a/docs/assembly.md
+++ b/docs/assembly.md
@@ -8,17 +8,17 @@ that is actually running.
 [back to README](../README.md)
 
 ```bash
-(sevm) mload(0x40)
+(chasm) mload(0x40)
 mload(0x40) -> $1 = 0x80 (128)  (gas 12)
-(sevm) mstore(0x80, 0xdeadbeef)
+(chasm) mstore(0x80, 0xdeadbeef)
 mstore(0x80, 0xdeadbeef) -> ok  (gas 18)
-(sevm) sstore(3, add(sload(3), 1))
+(chasm) sstore(3, add(sload(3), 1))
 sstore(3, add(sload(3), 1)) -> ok  (gas 22,103)
-(sevm) asm mstore(0x80, 1); mstore8(0xa0, 0x61); mload(0x80)
+(chasm) asm mstore(0x80, 1); mstore8(0xa0, 0x61); mload(0x80)
 mstore(0x80, 1) -> ok  (gas 18)
 mstore8(0xa0, 0x61) -> ok  (gas 21)
 mload(0x80) -> $2 = 0x1 (1)  (gas 18)
-(sevm) keccak256(0x80, 32)
+(chasm) keccak256(0x80, 32)
 keccak256(0x80, 32) -> $3 = 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6  (gas 51)
 ```
 
@@ -41,7 +41,7 @@ literal (`"hi"`, right-padded as Yul pads it), a nested call, or any convenience
 Refused, with the reason:
 
 ```bash
-(sevm) jump(0x10)
+(chasm) jump(0x10)
 error: `jump`: Yul has no `jump`; use the debugger's `jump 0xPC` or `set $pc = 0xPC`
 ```
 
diff --git a/docs/commands.md b/docs/commands.md
index fce43c1..03d2958 100644
--- a/docs/commands.md
+++ b/docs/commands.md
@@ -19,7 +19,7 @@ expressions are Solidity and the machine underneath is the EVM.
 | `u` / `until LOC` | run to a line or `*PC` |
 
 `step` and `next` understand *internal* Solidity calls. Those compile to `JUMP`, so EVM
-depth never changes, and sevm tracks them through the source map's `i` and `o` jump
+depth never changes, and chasm tracks them through the source map's `i` and `o` jump
 markers.
 
 Every stop ends with a one-line machine echo, so opcode-level stepping always shows what
@@ -27,7 +27,7 @@ the last step did to the machine — the stack height as old->new when it change
 reads `sp 13->12`), plus pc, opcode, gas remaining and step count:
 
 ```bash
-(sevm) si
+(chasm) si
 pc 0x0077  POP     sp 13->12  gas 2,843,413  step 5
 ```
 
@@ -38,7 +38,7 @@ tester chain — a genuine clean slate for iterating on calldata. An argument of
 `@path` (at launch, or to `run`) is replaced by that file's whitespace-stripped contents:
 payload hex runs to thousands of characters, past what a Windows console or command line
 will carry. The same `@file` syntax works at launch
-(`sevm run ... script.py @payload.hex`), at the prompt (`run @payload.hex`) and anywhere
+(`chasm run ... script.py @payload.hex`), at the prompt (`run @payload.hex`) and anywhere
 else the script's arguments are set.
 
 ## Breakpoints
@@ -58,7 +58,7 @@ else the script's arguments are set.
 Watchpoints work on state variables, on mapping elements (`watch balances[msg.sender]`),
 and on memory (`watch *0x80`).
 
-sevm also stops on reverts by default, at the failing instruction, and decodes the reason
+chasm also stops on reverts by default, at the failing instruction, and decodes the reason
 as `reverted: "..."`, `panic 0x11`, or a custom error with its arguments.
 
 ## Inspection
@@ -86,7 +86,7 @@ as `reverted: "..."`, `panic 0x11`, or a custom error with its arguments.
 `info storage` decodes the whole layout, packed slots included:
 
 ```bash
-(sevm) info storage
+(chasm) info storage
 Bank at 0x4f9da333dcf4e5a53772791b95c161b2fc041859
   slot   0+0  owner            address                = 0xf2e246bb...5b (cold)
   slot   0+20 feeBps           uint96                 = 25 (cold)
@@ -105,22 +105,22 @@ three, and the implementation's JUMPDEST is the pc every caller converges on, so
 there catches a proxy, a raw-calldata call and an internal call alike:
 
 ```bash
-(sevm) sig balances
+(chasm) sig balances
 balances(address)  0x27e235e3
-(sevm) info address balances
+(chasm) info address balances
 Bank.balances(address)
 selector     0x27e235e3
 dispatch     0x0096  where the dispatcher compares it
 wrapper      0x0167  the external entry: guards, then decodes calldata
 internal     0x052f  src/Bank.sol:17
 break there with `b *0x52f`
-(sevm) b *0x52f
+(chasm) b *0x52f
 Breakpoint 4 at pc 0x52f
-(sevm) c
+(chasm) c
 Breakpoint 4, Bank at src/Bank.sol:17
   17      mapping(address => uint256) public balances;   // slot 2
 pc 0x052f  JUMPDEST sp 3  gas 29,400,111  step 2027
-(sevm) bt
+(chasm) bt
 -> #0 <compiler-generated> at src/Bank.sol:17
    #1 Bank at pc 0x18c
    #2 BankTest.testDeposit() at test/Bank.t.sol:19
@@ -135,9 +135,9 @@ Neither needs an ABI. A signature this contract does not declare is hashed, as `
 does, and the selector is looked for in the bytecode anyway:
 
 ```bash
-(sevm) sig transfer(address,uint256)
+(chasm) sig transfer(address,uint256)
 transfer(address,uint256)  0xa9059cbb  (hashed here; not in this ABI)
-(sevm) info address 0xa9059cbb
+(chasm) info address 0xa9059cbb
 selector     0xa9059cbb
 the dispatcher never tests this selector: a call carrying it lands in the fallback
 ```
@@ -169,5 +169,5 @@ They bypass solc, so they work on contracts with no source and still mix into a
 expression:
 
 ```bash
-(sevm) p $storage[1] + 1 ether
+(chasm) p $storage[1] + 1 ether
 ```
diff --git a/docs/expressions.md b/docs/expressions.md
index fa34360..81187a9 100644
--- a/docs/expressions.md
+++ b/docs/expressions.md
@@ -9,13 +9,13 @@ same thing and keeps the effects.
 ## Evaluating Solidity
 
 ```bash
-(sevm) p balances[who] + 100 ether
+(chasm) p balances[who] + 100 ether
 $1 = 100000000000000000000 (100 ether)  (uint256)
-(sevm) p keccak256(abi.encode(who, amount))
+(chasm) p keccak256(abi.encode(who, amount))
 $2 = 0x6515e1c6183591491b775874fa6d6c2f905cfd817ab77e8ece0958bcc578bf7b  (bytes32)
-(sevm) p type(uint256).max
+(chasm) p type(uint256).max
 $3 = 115792089237316195423570985008687907853269984665640564039457584007913129639935  (uint256)
-(sevm) p accounts[msg.sender].nickname
+(chasm) p accounts[msg.sender].nickname
 $4 = "hodler"  (string memory)
 ```
 
@@ -27,23 +27,23 @@ expression, so a `display` costs one compile.
 `msg.*` reads the frame you are stopped in, calldata included:
 
 ```bash
-(sevm) p msg.sig
+(chasm) p msg.sig
 $5 = 0xd0e30db0  (bytes4)
-(sevm) p msg.data.length
+(chasm) p msg.data.length
 $6 = 4  (uint256)
 ```
 
 Calldata slices decode as they would in Solidity, so an argument can be pulled out of a
-frame whose signature sevm has no source for:
+frame whose signature chasm has no source for:
 
 ```bash
-(sevm) p abi.decode(msg.data[36:], (uint256))
+(chasm) p abi.decode(msg.data[36:], (uint256))
 ```
 
 A mapping or a struct has to be indexed rather than printed whole:
 
 ```bash
-(sevm) ptype balances
+(chasm) ptype balances
 error: EvalError: cannot display a whole mapping; index it with a key
 ```
 
@@ -53,22 +53,22 @@ error: EvalError: cannot display a whole mapping; index it with a key
 takes expressions over them:
 
 ```bash
-(sevm) info locals
+(chasm) info locals
   who            address            = 0x0278bdd7808aa64dc93c361ae55fc52cf1a918cf (param)
   amount         uint256            = 2000000000000000000 (2 ether) (param)
   fee            uint256            = 5000000000000000 (0.005000 ether)
-(sevm) p amount - fee
+(chasm) p amount - fee
 $1 = 1995000000000000000 (1.995000 ether)  (uint256)
-(sevm) set var fee = 1 ether
+(chasm) set var fee = 1 ether
 ```
 
-solc emits no location for locals, so sevm reconstructs it from the AST and the run's stack
+solc emits no location for locals, so chasm reconstructs it from the AST and the run's stack
 heights, the way Truffle and Remix do. A value shows only when the frame was observed from
 entry, when the slot is still below the top of the stack, and when the current instruction
 is inside the declaration's scope. Otherwise you get `<unavailable>` with the reason:
 
 ```bash
-(sevm) info locals
+(chasm) info locals
   fee            uint256            = <unavailable>  this instruction allocates it;
                                       step once to see it
 ```
diff --git a/docs/foundry.md b/docs/foundry.md
index ccc9e2e..6e6b4ef 100644
--- a/docs/foundry.md
+++ b/docs/foundry.md
@@ -1,16 +1,16 @@
 # Foundry projects, libraries and the build cache
 
-sevm reads a Foundry project the way `forge` does, and writes back into it in a way that
+Chasm reads a Foundry project the way `forge` does, and writes back into it in a way that
 cannot disturb `forge`. This page covers the parts the README summarises.
 
 [back to README](../README.md)
 
-`sevm run` dispatches on the extension. A `.py` argument is a web3 driver, a `.sol`
+`chasm run` dispatches on the extension. A `.py` argument is a web3 driver, a `.sol`
 argument is a Foundry test.
 
 ```bash
-sevm run test/Counter.t.sol                     # fullscreen TUI, opens in the first test
-sevm run --console -m testDeposit examples/bank/test/Bank.t.sol   # one test by name
+chasm run test/Counter.t.sol                     # fullscreen TUI, opens in the first test
+chasm run --console -m testDeposit examples/bank/test/Bank.t.sol   # one test by name
 ```
 
 Each test gets a fresh deploy, a `setUp()` and the test call, as forge isolates them, and
@@ -36,12 +36,12 @@ contract VaultTest is Test {
 ```
 
 ```bash
-$ sevm run --console -y examples/standalone/Vault.t.sol
+$ chasm run --console -y examples/standalone/Vault.t.sol
 standalone test at examples/standalone; compiling ...
 installing forge-std from https://github.com/foundry-rs/forge-std @ v1.16.2
 installing @openzeppelin/contracts from https://github.com/OpenZeppelin/openzeppelin-contracts @ v5.7.0
 wrote 2 remapping(s) to remappings.txt
-wrote 25 artifact(s) to out/sevm
+wrote 25 artifact(s) to out/chasm
 debugging 1 test(s): VaultTest.testDeal
 Breakpoint 1, VaultTest.testDeal() at Vault.t.sol:11
   11          vm.deal(alice, 3 ether);
@@ -55,30 +55,30 @@ examples/standalone
 ├── foundry.toml        [profile.default] with libs = ["lib"], no src/test
 ├── remappings.txt      forge-std/=lib/forge-std/src/
 │                       @openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/
-├── cache/sevm          the compilation unit, keyed by solc version, settings, sources
-├── out/sevm            one JSON per contract, in forge's layout
+├── cache/chasm          the compilation unit, keyed by solc version, settings, sources
+├── out/chasm            one JSON per contract, in forge's layout
 └── lib
     ├── forge-std                 v1.16.2
     └── openzeppelin-contracts    v5.7.0
 ```
 
-Drop `-y` and sevm asks once before writing anything:
+Drop `-y` and chasm asks once before writing anything:
 
 ```bash
-$ sevm run --console examples/standalone/Vault.t.sol
-sevm will:
+$ chasm run --console examples/standalone/Vault.t.sol
+chasm will:
   - create examples/standalone/foundry.toml
   - install forge-std, @openzeppelin/contracts into examples/standalone/lib
 [y/N]
 ```
 
-Answer `n` and sevm writes nothing, compiling against what is already there. A
+Answer `n` and chasm writes nothing, compiling against what is already there. A
 non-interactive run declines by itself. `--no-install` skips the prompt and refuses the
 same way, with the manual recipe:
 
 ```bash
-$ sevm run --console --no-install examples/standalone/Vault.t.sol
-compile failed: unresolved import 'forge-std/Test.sol' in Vault.t.sol, and sevm was told
+$ chasm run --console --no-install examples/standalone/Vault.t.sol
+compile failed: unresolved import 'forge-std/Test.sol' in Vault.t.sol, and chasm was told
 not to install it. Run again with -y to let it, or install it yourself:
   forge install <org>/<repo>
   echo 'forge-std/=lib/<repo>/src/' >> remappings.txt
@@ -87,7 +87,7 @@ not to install it. Run again with -y to let it, or install it yourself:
 ## Inside a Foundry project
 
 ```bash
-$ sevm run --console examples/bank/test/Bank.t.sol
+$ chasm run --console examples/bank/test/Bank.t.sol
 foundry project at examples/bank; compiling ...
 debugging 3 test(s): BankTest.testDeposit, BankTest.testFeeIsTakenOnDeposit,
 FailingAssertionTest.testBalanceIgnoresFee
@@ -101,13 +101,13 @@ has none.
 
 ## How an import is resolved
 
-sevm looks up the prefix in its own table (`forge-std`, `ds-test`, `solmate`, `solady`,
+chasm looks up the prefix in its own table (`forge-std`, `ds-test`, `solmate`, `solady`,
 openzeppelin), then in npm's registry metadata for anything else, and clones the repository
 it finds at the newest release tag. Prereleases are skipped. The remapping comes from where
 the imported file actually landed in the clone, so `src/`, `contracts/` and flat layouts
 all work.
 
-A clone is a pin. sevm never updates it. To move a version, delete `lib/<name>` or run
+A clone is a pin. chasm never updates it. To move a version, delete `lib/<name>` or run
 `forge install <org>/<repo>@<tag>` yourself. git is required, the `forge` binary is not, and
 only the first run for a given library needs the network.
 
@@ -116,43 +116,43 @@ only the first run for a given library needs the network.
 The first run compiles. The next one does not.
 
 ```bash
-$ time sevm compile .
-wrote 27 artifact(s) to out/sevm
+$ time chasm compile .
+wrote 27 artifact(s) to out/chasm
 solc 0.8.36, optimizer off
 real  1.95
 
-$ time sevm compile .
+$ time chasm compile .
 cache hit (22 sources)
 real  0.53
 
 $ $EDITOR test/Bank.t.sol
-$ time sevm compile .
+$ time chasm compile .
 recompiled 1 of 22 sources
-wrote 27 artifact(s) to out/sevm
+wrote 27 artifact(s) to out/chasm
 real  1.02
 ```
 
 A build leaves the same two directories forge does:
 
 ```
-cache/sevm/     the compilation unit, keyed by solc version, settings and source content
-out/sevm/       one JSON per contract, in forge's layout: out/sevm/Token.sol/Token.json
+cache/chasm/     the compilation unit, keyed by solc version, settings and source content
+out/chasm/       one JSON per contract, in forge's layout: out/chasm/Token.sol/Token.json
 ```
 
 An edit invalidates the file you changed and everything that imports it. The rest is
 reused, so solc only has to emit the parts that moved. `forge clean` clears both of those
 along with forge's own.
 
-Artifacts are nested under `out/sevm/` rather than written straight into `out/`, because
-sevm compiles with the optimizer off. Overwriting `out/Token.sol/Token.json` would leave
-forge's cache calling it fresh, and the next `forge test` would run sevm's build. They
+Artifacts are nested under `out/chasm/` rather than written straight into `out/`, because
+chasm compiles with the optimizer off. Overwriting `out/Token.sol/Token.json` would leave
+forge's cache calling it fresh, and the next `forge test` would run chasm's build. They
 carry `abi`, `bytecode`, `deployedBytecode`, `methodIdentifiers`, `storageLayout` and the
-source id, with forge's field names. `metadata` is the one thing missing, as sevm never
+source id, with forge's field names. `metadata` is the one thing missing, as chasm never
 asks solc for it.
 
 A directory with no `foundry.toml` gets nothing written into it. Its cache lives under
-`~/.cache/sevm/` and no artifacts are written at all. `--force` recompiles and rewrites the
-entry, `--no-cache` (or `SEVM_NO_CACHE=1`) writes nothing anywhere.
+`~/.cache/chasm/` and no artifacts are written at all. `--force` recompiles and rewrites the
+entry, `--no-cache` (or `CHASM_NO_CACHE=1`) writes nothing anywhere.
 
 ## Cheatcodes
 
@@ -177,25 +177,25 @@ Implemented:
 - `assume`, and the full `vm.assert*` family (`assertEq`, `assertGt`, `assertApproxEqRel`,
   the `*Decimal` forms, 116 overloads) that forge-std's own `assertEq` calls into.
 - gas-metering knobs (`pauseGasMetering resumeGasMetering resetGasMetering`) and `skip` are
-  accepted as no-ops, since sevm meters gas itself and produces no gas snapshots.
+  accepted as no-ops, since chasm meters gas itself and produces no gas snapshots.
 
 A failed assertion stops the debugger where it broke, with the comparison:
 
 ```bash
-(sevm) c
+(chasm) c
 Stopped on error: reverted: "assertion failed: 997500000000000000 != 1000000000000000000"
   StdAssertions.assertEq(uint256, uint256) at lib/forge-std/src/StdAssertions.sol:121
  121              vm.assertEq(left, right);
-(sevm) up
+(chasm) up
 #1  FailingAssertionTest.testBalanceIgnoresFee() at test/FailingAssertion.t.sol:20
 ```
 
 Fire one at the prompt against the frame you are stopped in:
 
 ```bash
-(sevm) vm.warp(12345)
+(chasm) vm.warp(12345)
 vm.warp -> ok
-(sevm) p block.timestamp
+(chasm) p block.timestamp
 $1 = 12345  (uint256)
 ```
 
@@ -204,13 +204,13 @@ as one, and otherwise a Solidity expression evaluated against the paused frame,
 `p` evaluates one:
 
 ```bash
-(sevm) vm.deal(alice, 5 ether)
+(chasm) vm.deal(alice, 5 ether)
 vm.deal -> ok
-(sevm) p alice.balance
+(chasm) p alice.balance
 $2 = 5000000000000000000 (5 ether)  (uint256)
-(sevm) vm.label(bank.owner(), "owner")
+(chasm) vm.label(bank.owner(), "owner")
 vm.label -> ok
-(sevm) vm.getLabel(bank.owner())
+(chasm) vm.getLabel(bank.owner())
 vm.getLabel -> owner
 ```
 
@@ -223,7 +223,7 @@ parameter. If that does not fit either, the error names the argument and carries
 reason:
 
 ```bash
-(sevm) vm.prank(alcie)
+(chasm) vm.prank(alcie)
 error: vm.prank: argument 1 (alcie) is not a valid address (Undeclared identifier. Did you mean "alice"? (in
 `alcie`))
 ```
diff --git a/docs/headless.md b/docs/headless.md
index c25adda..b33d5b7 100644
--- a/docs/headless.md
+++ b/docs/headless.md
@@ -1,6 +1,6 @@
 # Headless REVM protocol
 
-The REVM engine can run without the sevm console or fullscreen interface.
+The REVM engine can run without the Chasm console or fullscreen interface.
 Any frontend that can launch a process and exchange newline-delimited JSON can control the
 same live debugger session. This includes editor extensions, browser backends, terminal
 interfaces, and clients written in languages other than Python.
@@ -16,8 +16,8 @@ complete request stream that pauses before `SSTORE`, changes its value operand f
 to `9`, resumes, and reads the committed storage from the finish event:
 
 ```bash
-$ uv run sevm-engine < examples/headless-session.jsonl
-{"id":1,"jsonrpc":"2.0","result":{"methods":["hello","open","start","transact","wait_event","snapshot","set_breakpoints","set_stack","write_memory","set_gas","set_pc","step","read_storage","write_storage","state","evaluate","evaluate_call","execute_opcode","set_prank","respond_host","resume","close","shutdown"],"protocol":"sevm-debugger/1","transport":"jsonl-stdio"}}
+$ uv run chasm-engine < examples/headless-session.jsonl
+{"id":1,"jsonrpc":"2.0","result":{"methods":["hello","open","start","transact","wait_event","snapshot","set_breakpoints","set_stack","write_memory","set_gas","set_pc","step","read_storage","write_storage","state","evaluate","evaluate_call","execute_opcode","set_prank","respond_host","resume","close","shutdown"],"protocol":"chasm-debugger/1","transport":"jsonl-stdio"}}
 {"id":2,"jsonrpc":"2.0","result":{"started":true}}
 {"id":3,"jsonrpc":"2.0","result":{"snapshot":{"address":"0x1000000000000000000000000000000000000001","calldata":"0x","caller":"0x2000000000000000000000000000000000000002","code_address":"0x1000000000000000000000000000000000000001","depth":0,"frames":[{"address":"0x1000000000000000000000000000000000000001","calldata":"0x","caller":"0x2000000000000000000000000000000000000002","code":"0x600160005500","code_address":"0x1000000000000000000000000000000000000001","depth":0,"gas_limit":79000,"gas_remaining":78994,"is_static":false,"kind":"call","opcode":85,"pc":4,"value":"0x0"}],"gas_limit":79000,"gas_refund":0,"gas_remaining":78994,"gas_used":6,"is_static":false,"memory":"0x","memory_size":0,"mnemonic":"SSTORE","opcode":85,"origin":"0x2000000000000000000000000000000000000002","pc":4,"reason":"breakpoint","stack":["0x0","0x1"],"step":3,"value":"0x0"},"type":"paused"}}
 {"id":4,"jsonrpc":"2.0","result":"0x9"}
@@ -26,12 +26,12 @@ $ uv run sevm-engine < examples/headless-session.jsonl
 {"id":7,"jsonrpc":"2.0","result":null}
 ```
 
-An installed package exposes the same process as `sevm-engine`. A frontend launches that
+An installed package exposes the same process as `chasm-engine`. A frontend launches that
 command and keeps its standard input and standard output pipes open. A Rust application
-can instead depend on `sevm-revm-headless` and call `serve` with any buffered reader and
+can instead depend on `chasm-revm-headless` and call `serve` with any buffered reader and
 writer.
 
-Call `hello` first and require `sevm-debugger/1`. A client should stop if it receives a
+Call `hello` first and require `chasm-debugger/1`. A client should stop if it receives a
 protocol version it does not support.
 
 ## Requests
diff --git a/docs/mcp.md b/docs/mcp.md
index 8fda76f..f6b2b17 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -1,6 +1,6 @@
-# sevm MCP server for AI clients
+# Chasm MCP server for AI clients
 
-`sevm mcp` runs the REVM debugger as a [Model Context Protocol](https://modelcontextprotocol.io)
+`chasm mcp` runs the REVM debugger as a [Model Context Protocol](https://modelcontextprotocol.io)
 server over stdio. Its tools return compact JSON for clients that inspect and step
 through transactions.
 
@@ -11,7 +11,7 @@ through transactions.
 | A human... | An AI client... | So the tools... |
 |---|---|---|
 | scrolls the memory pane | gets one fixed response | every windowed read takes `offset`/`words` and returns `{items, total, truncated}`; narrow the window for more |
-| watches panes change live | only sees tool results | `sevm_diff_since_last_stop` reports stack pushes/pops, changed memory ranges and gas after each step |
+| watches panes change live | only sees tool results | `chasm_diff_since_last_stop` reports stack pushes/pops, changed memory ranges and gas after each step |
 | knows where they are | must be told, every time | every navigation tool returns the same stop report (pc, opcode, gas, sp, location, stack top, stack delta) |
 | reads syntax highlighting | pays per token | output is plain JSON: full-width hex words, decimal counts, no markup |
 | restarts on a typo | cannot recover silently | failures return `{"error": "..."}` with the fix in the message |
@@ -19,9 +19,9 @@ through transactions.
 ## Running it
 
 ```bash
-sevm mcp
-uv run sevm mcp
-sevm mcp --timeout 300
+chasm mcp
+uv run chasm mcp
+chasm mcp --timeout 300
 ```
 
 Any MCP client that speaks stdio can connect. Generic configuration:
@@ -29,8 +29,8 @@ Any MCP client that speaks stdio can connect. Generic configuration:
 ```json
 {
   "mcpServers": {
-    "sevm": {
-      "command": "sevm",
+    "chasm": {
+      "command": "chasm",
       "args": ["mcp"]
     }
   }
@@ -45,46 +45,46 @@ One debug session is active at a time. Starting a new target replaces it.
 
 | Tool | Meaning |
 |---|---|
-| `sevm_start_session` | compile and start a web3.py driver script or a `.t.sol` Foundry test. Extra `args` go to scripts, and `match`/`match_contract` select tests. Returns the first stop report |
-| `sevm_stop_session` | dispose the session (chain state is discarded) |
-| `sevm_restart_session` | re-run from scratch: fresh chain, breakpoints kept, optional new script args |
+| `chasm_start_session` | compile and start a web3.py driver script or a `.t.sol` Foundry test. Extra `args` go to scripts, and `match`/`match_contract` select tests. Returns the first stop report |
+| `chasm_stop_session` | dispose the session (chain state is discarded) |
+| `chasm_restart_session` | re-run from scratch: fresh chain, breakpoints kept, optional new script args |
 
 ### Navigation
 
 | Tool | Meaning |
 |---|---|
-| `sevm_continue` | run to the next breakpoint/watchpoint/error, or program end |
-| `sevm_step_opcodes` | `count` opcodes (≤1000) |
-| `sevm_step_lines` / `sevm_next_lines` | Solidity lines, into / over internal calls |
-| `sevm_finish_frame` | run to the end of the current frame |
-| `sevm_run_to` | a pc, or a location like `Bank.sol:46` / `*0x108` |
-| `sevm_get_status` | the stop report alone |
-| `sevm_diff_since_last_stop` | what the last navigation changed |
+| `chasm_continue` | run to the next breakpoint/watchpoint/error, or program end |
+| `chasm_step_opcodes` | `count` opcodes (≤1000) |
+| `chasm_step_lines` / `chasm_next_lines` | Solidity lines, into / over internal calls |
+| `chasm_finish_frame` | run to the end of the current frame |
+| `chasm_run_to` | a pc, or a location like `Bank.sol:46` / `*0x108` |
+| `chasm_get_status` | the stop report alone |
+| `chasm_diff_since_last_stop` | what the last navigation changed |
 
 ### Inspection (windowed, truncation-flagged)
 
 | Tool | Meaning |
 |---|---|
-| `sevm_read_memory` | 32-byte words with region names. `beyond: true` marks unallocated reads as zero |
-| `sevm_read_stack` | operand stack, index 0 = top |
-| `sevm_read_storage` | decoded layout by default (names, types, packed slots), or raw slots |
-| `sevm_read_calldata` | windowed. The first window includes selector and signature |
-| `sevm_get_backtrace` | Solidity and EVM frames interleaved |
-| `sevm_get_locals` / `sevm_get_arguments` | decoded locals / ABI-decoded call arguments |
-| `sevm_disassemble` | rows `{pc, text, jumpdest, line}` around a pc |
-| `sevm_read_source` | numbered source window, current line flagged |
-| `sevm_get_gas_profile` | spend by opcode and by source line |
-| `sevm_get_logs` | events so far, names decoded |
-| `sevm_list_contracts` / `sevm_list_functions` | the compiled surface |
+| `chasm_read_memory` | 32-byte words with region names. `beyond: true` marks unallocated reads as zero |
+| `chasm_read_stack` | operand stack, index 0 = top |
+| `chasm_read_storage` | decoded layout by default (names, types, packed slots), or raw slots |
+| `chasm_read_calldata` | windowed. The first window includes selector and signature |
+| `chasm_get_backtrace` | Solidity and EVM frames interleaved |
+| `chasm_get_locals` / `chasm_get_arguments` | decoded locals / ABI-decoded call arguments |
+| `chasm_disassemble` | rows `{pc, text, jumpdest, line}` around a pc |
+| `chasm_read_source` | numbered source window, current line flagged |
+| `chasm_get_gas_profile` | spend by opcode and by source line |
+| `chasm_get_logs` | events so far, names decoded |
+| `chasm_list_contracts` / `chasm_list_functions` | the compiled surface |
 
 ### Search, provenance, and bytecode parity
 
 | Tool | Meaning |
 |---|---|
-| `sevm_find_bytes` | hex pattern in `code` (gadget hunting: pc, instruction alignment, nearest preceding JUMPDEST), `memory`, or `calldata` |
-| `sevm_set_provenance` / `sevm_why_stack(index)` | record opcode steps within a frame and trace stack values to constants, calldata, memory, storage, and frame entry |
-| `sevm_export_trace` | the recording as anvil/geth structLog JSON (to a file, or a windowed inline slice) |
-| `sevm_check_parity` | compare a compiled runtime against deployed bytecode. `sevm_start_session(reference_runtime_hex=...)` stops on divergence |
+| `chasm_find_bytes` | hex pattern in `code` (gadget hunting: pc, instruction alignment, nearest preceding JUMPDEST), `memory`, or `calldata` |
+| `chasm_set_provenance` / `chasm_why_stack(index)` | record opcode steps within a frame and trace stack values to constants, calldata, memory, storage, and frame entry |
+| `chasm_export_trace` | the recording as anvil/geth structLog JSON (to a file, or a windowed inline slice) |
+| `chasm_check_parity` | compare a compiled runtime against deployed bytecode. `chasm_start_session(reference_runtime_hex=...)` stops on divergence |
 
 **Provenance semantics**: REVM pauses at each opcode while recording is enabled.
 The slice follows recorded values and positions within a frame. It skips the
@@ -95,31 +95,31 @@ Hand mutations (`set $stack[i]`) are not recorded, so ask `why` before mutating.
 
 | Tool | Meaning |
 |---|---|
-| `sevm_set_breakpoint` | `File.sol:LINE`, `*0xPC`, or a function name, with an optional Solidity `condition` |
-| `sevm_set_opcode_breakpoint` | every occurrence of an opcode (`SSTORE`, `DELEGATECALL`, ...) |
-| `sevm_set_watchpoint` | storage value written/read/accessed, or `*0x40` memory |
-| `sevm_list_breakpoints` / `sevm_delete_breakpoint` | management |
+| `chasm_set_breakpoint` | `File.sol:LINE`, `*0xPC`, or a function name, with an optional Solidity `condition` |
+| `chasm_set_opcode_breakpoint` | every occurrence of an opcode (`SSTORE`, `DELEGATECALL`, ...) |
+| `chasm_set_watchpoint` | storage value written/read/accessed, or `*0x40` memory |
+| `chasm_list_breakpoints` / `chasm_delete_breakpoint` | management |
 
 ### Mutation and evaluation
 
 | Tool | Meaning |
 |---|---|
-| `sevm_evaluate` | real Solidity against the paused frame (state, mappings, locals, `keccak256`, `abi.encode`, units). `keep: true` keeps side effects like gdb's `call` |
-| `sevm_set_gas` | overwrite the gas meter. At an out-of-gas stop, continuing retries the failed instruction |
-| `sevm_set_stack_slot` | rewrite an operand before its opcode consumes it |
-| `sevm_write_memory` / `sevm_write_storage` | raw writes |
-| `sevm_set_pc` | move the pc (JUMPDESTs only) |
-| `sevm_command` | raw gdb-verb passthrough for everything else: `vm.*` cheatcodes, Yul, `jump`, `reseat`, `x/32xb 0x40` |
+| `chasm_evaluate` | real Solidity against the paused frame (state, mappings, locals, `keccak256`, `abi.encode`, units). `keep: true` keeps side effects like gdb's `call` |
+| `chasm_set_gas` | overwrite the gas meter. At an out-of-gas stop, continuing retries the failed instruction |
+| `chasm_set_stack_slot` | rewrite an operand before its opcode consumes it |
+| `chasm_write_memory` / `chasm_write_storage` | raw writes |
+| `chasm_set_pc` | move the pc (JUMPDESTs only) |
+| `chasm_command` | raw gdb-verb passthrough for everything else: `vm.*` cheatcodes, Yul, `jump`, `reseat`, `x/32xb 0x40` |
 
 ## A first session
 
 ```
-sevm_start_session(target="exploit.py", contracts="contracts/", optimize=true)
-sevm_find_bytes(pattern="5b50505050", scope="code")      # gadget hunt
-sevm_set_breakpoint(location="*0x1a2")                   # or "deposit", "SSTORE"
-sevm_continue()
-sevm_read_memory(offset=0x40, words=4)
-sevm_evaluate(expression="balances[msg.sender]")
-sevm_diff_since_last_stop()
-sevm_restart_session(args=["0x<new payload>"])
+chasm_start_session(target="exploit.py", contracts="contracts/", optimize=true)
+chasm_find_bytes(pattern="5b50505050", scope="code")      # gadget hunt
+chasm_set_breakpoint(location="*0x1a2")                   # or "deposit", "SSTORE"
+chasm_continue()
+chasm_read_memory(offset=0x40, words=4)
+chasm_evaluate(expression="balances[msg.sender]")
+chasm_diff_since_last_stop()
+chasm_restart_session(args=["0x<new payload>"])
 ```
diff --git a/examples/README.md b/examples/README.md
index c5d2121..ac5e327 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -10,9 +10,9 @@ examples/
 ```
 
 ```bash
-sevm run examples/bank/test/Bank.t.sol                        # a Foundry test
-sevm run -y examples/standalone/Vault.t.sol                   # clones forge-std first
-sevm run --contracts examples/bank/src examples/debug_bank.py # a web3.py script
+chasm run examples/bank/test/Bank.t.sol                        # a Foundry test
+chasm run -y examples/standalone/Vault.t.sol                   # clones forge-std first
+chasm run --contracts examples/bank/src examples/debug_bank.py # a web3.py script
 ```
 
 Running the first two writes `lib/`, `out/`, `cache/` and `remappings.txt` next to the
diff --git a/examples/bank/foundry.toml b/examples/bank/foundry.toml
index 774639a..7ea83ab 100644
--- a/examples/bank/foundry.toml
+++ b/examples/bank/foundry.toml
@@ -2,5 +2,5 @@
 src = "src"
 test = "test"
 libs = ["lib"]
-# sevm forces the optimizer OFF for debuggable builds regardless of this file.
+# chasm forces the optimizer OFF for debuggable builds regardless of this file.
 optimizer = false
diff --git a/examples/debug_bank.py b/examples/debug_bank.py
index 0188e53..b402153 100644
--- a/examples/debug_bank.py
+++ b/examples/debug_bank.py
@@ -5,7 +5,7 @@
 from eth_account import Account
 from web3 import EthereumTesterProvider, Web3
 
-from sevm.compile import compile_project
+from chasm_debugger.compile import compile_project
 
 CONTRACTS = os.path.join(os.path.dirname(os.path.abspath(__file__)), "bank", "src")
 
@@ -17,7 +17,7 @@ def main():
 
     art = project.artifact("Bank")
     factory = w3.eth.contract(abi=art.abi, bytecode=art.bytecode.hex())
-    tx = factory.constructor("sevm-bank").transact(
+    tx = factory.constructor("chasm-bank").transact(
         {"value": w3.to_wei(1, "ether"), "gas": 3_000_000}
     )
     bank_address = w3.eth.wait_for_transaction_receipt(tx)["contractAddress"]
diff --git a/pyproject.toml b/pyproject.toml
index 7c61ac6..43530db 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,9 +3,9 @@ requires = ["maturin>=1.10,<2.0"]
 build-backend = "maturin"
 
 [project]
-name = "sevm"
+name = "chasm-debugger"
 version = "0.1.0"
-description = "sevm is an interactive, gdb-style Solidity/EVM debugger on REVM, built for red-team dynamic analysis."
+description = "Chasm is an interactive, gdb-style Solidity/EVM debugger on REVM, built for red-team dynamic analysis."
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
@@ -21,13 +21,13 @@ classifiers = [
 ]
 
 # Runtime dependencies. Every third-party package imported by the sources under
-# src/sevm is declared here (not left to transitive resolution). `eth`, `eth_abi`,
-# `eth_utils` and `eth_account` all arrive with web3, but sevm imports them directly,
+# src/chasm_debugger is declared here (not left to transitive resolution). `eth`, `eth_abi`,
+# `eth_utils` and `eth_account` all arrive with web3, but chasm imports them directly,
 # so they are named explicitly.
 #
-# Do not use `web3[tester]`: sevm supplies its own REVM provider, and the tester extra
+# Do not use `web3[tester]`: chasm supplies its own REVM provider, and the tester extra
 # would restore the archived Py-EVM stack. The pycryptodome backend is named directly so
-# the keccak implementation sevm relies on is not left to a transitive dependency.
+# the keccak implementation chasm relies on is not left to a transitive dependency.
 dependencies = [
     "web3>=7.0",
     "eth-hash[pycryptodome]>=0.5.1",
@@ -47,16 +47,16 @@ dependencies = [
 ]
 
 [project.scripts]
-sevm = "sevm.cli:main"
-sevm-engine = "sevm.revm_server:main"
+chasm = "chasm_debugger.cli:main"
+chasm-engine = "chasm_debugger.revm_server:main"
 
 [project.urls]
-Homepage = "https://github.com/your-org/sevm"
-Documentation = "https://github.com/your-org/sevm/blob/main/README.md"
+Homepage = "https://github.com/ChasmHQ/debugger"
+Documentation = "https://github.com/ChasmHQ/debugger/blob/main/README.md"
 
 [tool.maturin]
 manifest-path = "rust/python/Cargo.toml"
-module-name = "sevm._revm"
+module-name = "chasm_debugger._revm"
 python-source = "src"
 
 [dependency-groups]
@@ -70,10 +70,10 @@ dev = [
 ]
 
 [tool.pytest.ini_options]
-markers = ["network: hits the network; run with SEVM_NETWORK_TESTS=1"]
+markers = ["network: hits the network; run with CHASM_NETWORK_TESTS=1"]
 testpaths = ["tests"]
 # Put tests/ on sys.path so the shared `harness` module imports cleanly, and rely
-# on the installed (editable) `sevm` package for `import sevm.*` - no sys.path hacks.
+# on the installed (editable) `chasm_debugger` package - no sys.path hacks.
 pythonpath = ["tests"]
 addopts = "-ra"
 
diff --git a/rust/core/Cargo.toml b/rust/core/Cargo.toml
index b9c1fbc..b40e9ed 100644
--- a/rust/core/Cargo.toml
+++ b/rust/core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
-name = "sevm-revm-core"
-description = "REVM debugger core for sevm"
+name = "chasm-revm-core"
+description = "REVM debugger core for chasm"
 version.workspace = true
 edition.workspace = true
 rust-version.workspace = true
diff --git a/rust/core/src/engine.rs b/rust/core/src/engine.rs
index 9636939..2b07ebf 100644
--- a/rust/core/src/engine.rs
+++ b/rust/core/src/engine.rs
@@ -42,7 +42,7 @@ const STATE_RUNNING: u8 = 1;
 const STATE_PAUSED: u8 = 2;
 const STATE_STOPPED: u8 = 3;
 
-type SevmContext = Context<BlockEnv, TxEnv, CfgEnv, InMemoryDB>;
+type ChasmContext = Context<BlockEnv, TxEnv, CfgEnv, InMemoryDB>;
 
 enum EngineCommand {
     Transact(TransactionRequest),
@@ -64,7 +64,7 @@ struct StepBackup {
     gas: Gas,
 }
 
-struct SevmInspector {
+struct ChasmInspector {
     commands: Receiver<Command>,
     events: Sender<DebugEvent>,
     breakpoints: HashSet<(Address, usize)>,
@@ -81,7 +81,7 @@ struct SevmInspector {
     steps_until_pause: Option<usize>,
 }
 
-impl SevmInspector {
+impl ChasmInspector {
     fn snapshot(&self, interpreter: &Interpreter<EthInterpreter>, reason: PauseReason) -> Snapshot {
         let address = interpreter.input.target_address();
         let code_address = interpreter
@@ -145,7 +145,7 @@ impl SevmInspector {
     fn pause(
         &mut self,
         interpreter: &mut Interpreter<EthInterpreter>,
-        context: &mut SevmContext,
+        context: &mut ChasmContext,
         reason: PauseReason,
     ) -> bool {
         self.state.store(STATE_PAUSED, Ordering::Release);
@@ -319,7 +319,7 @@ impl SevmInspector {
         )
     }
 
-    fn host_call(&mut self, context: &mut SevmContext, inputs: &CallInputs) -> CallOutcome {
+    fn host_call(&mut self, context: &mut ChasmContext, inputs: &CallInputs) -> CallOutcome {
         self.state.store(STATE_PAUSED, Ordering::Release);
         let event = HostCall {
             address: inputs.bytecode_address,
@@ -374,7 +374,7 @@ impl SevmInspector {
         call_result(inputs, Bytes::new(), true)
     }
 
-    fn apply_prank(&mut self, context: &mut SevmContext, inputs: &mut CallInputs) {
+    fn apply_prank(&mut self, context: &mut ChasmContext, inputs: &mut CallInputs) {
         let Some(prank) = self.prank.clone() else {
             return;
         };
@@ -425,7 +425,7 @@ fn call_result(inputs: &CallInputs, output: Bytes, revert: bool) -> CallOutcome
 }
 
 fn execute_state_command(
-    context: &mut SevmContext,
+    context: &mut ChasmContext,
     command: StateCommand,
 ) -> Result<CommandValue, SessionError> {
     let invalid = |error| SessionError::InvalidCommand(format!("{error:?}"));
@@ -582,7 +582,7 @@ fn execute_state_command(
 
 #[allow(clippy::too_many_arguments)]
 fn execute_evaluation(
-    context: &mut SevmContext,
+    context: &mut ChasmContext,
     interpreter: &Interpreter<EthInterpreter>,
     code: Bytes,
     data: Bytes,
@@ -608,7 +608,7 @@ fn execute_evaluation(
         gas_limit,
     );
     let instructions =
-        EthInstructions::<EthInterpreter, SevmContext>::new_mainnet_with_spec(SpecId::CANCUN);
+        EthInstructions::<EthInterpreter, ChasmContext>::new_mainnet_with_spec(SpecId::CANCUN);
     let action = nested.run_plain(
         instructions.instruction_table(),
         instructions.gas_table(),
@@ -631,7 +631,7 @@ fn execute_evaluation(
 }
 
 fn execute_opcode(
-    context: &mut SevmContext,
+    context: &mut ChasmContext,
     interpreter: &mut Interpreter<EthInterpreter>,
     opcode: u8,
     arguments: Vec<U256>,
@@ -669,7 +669,7 @@ fn execute_opcode(
 
     let checkpoint = context.journal_mut().checkpoint();
     let instructions =
-        EthInstructions::<EthInterpreter, SevmContext>::new_mainnet_with_spec(SpecId::CANCUN);
+        EthInstructions::<EthInterpreter, ChasmContext>::new_mainnet_with_spec(SpecId::CANCUN);
     let result = (|| {
         let static_gas = instructions.gas_table()[opcode as usize] as u64;
         if !nested.gas.record_regular_cost(static_gas) {
@@ -713,10 +713,10 @@ fn execute_opcode(
     result
 }
 
-impl Inspector<SevmContext> for SevmInspector {
+impl Inspector<ChasmContext> for ChasmInspector {
     fn frame_start(
         &mut self,
-        context: &mut SevmContext,
+        context: &mut ChasmContext,
         frame_input: &mut FrameInput,
     ) -> Option<revm::handler::FrameResult> {
         let depth = self.frames.len();
@@ -769,7 +769,7 @@ impl Inspector<SevmContext> for SevmInspector {
     fn initialize_interp(
         &mut self,
         interpreter: &mut Interpreter<EthInterpreter>,
-        _context: &mut SevmContext,
+        _context: &mut ChasmContext,
     ) {
         if let Some(frame) = self.frames.last_mut() {
             Self::update_frame(frame, interpreter);
@@ -778,7 +778,7 @@ impl Inspector<SevmContext> for SevmInspector {
 
     fn frame_end(
         &mut self,
-        context: &mut SevmContext,
+        context: &mut ChasmContext,
         _frame_input: &FrameInput,
         _frame_result: &mut revm::handler::FrameResult,
     ) {
@@ -789,7 +789,7 @@ impl Inspector<SevmContext> for SevmInspector {
         }
     }
 
-    fn step(&mut self, interpreter: &mut Interpreter<EthInterpreter>, context: &mut SevmContext) {
+    fn step(&mut self, interpreter: &mut Interpreter<EthInterpreter>, context: &mut ChasmContext) {
         self.step_index = self.step_index.saturating_add(1);
         if let Some(frame) = self.frames.last_mut() {
             Self::update_frame(frame, interpreter);
@@ -830,7 +830,7 @@ impl Inspector<SevmContext> for SevmInspector {
     fn step_end(
         &mut self,
         interpreter: &mut Interpreter<EthInterpreter>,
-        context: &mut SevmContext,
+        context: &mut ChasmContext,
     ) {
         let result = interpreter
             .bytecode
@@ -873,7 +873,7 @@ impl Inspector<SevmContext> for SevmInspector {
         self.backup = None;
     }
 
-    fn call(&mut self, context: &mut SevmContext, inputs: &mut CallInputs) -> Option<CallOutcome> {
+    fn call(&mut self, context: &mut ChasmContext, inputs: &mut CallInputs) -> Option<CallOutcome> {
         if matches!(inputs.bytecode_address, CHEATCODE_ADDRESS | CONSOLE_ADDRESS) {
             return Some(self.host_call(context, inputs));
         }
@@ -1158,7 +1158,7 @@ fn run_worker(
                 .map_err(|error| format!("{error:?}"))?;
         }
     }
-    let inspector = SevmInspector {
+    let inspector = ChasmInspector {
         commands: commands.clone(),
         events: events.clone(),
         breakpoints: config
diff --git a/rust/core/tests/prototype.rs b/rust/core/tests/prototype.rs
index 376b65e..47fd25b 100644
--- a/rust/core/tests/prototype.rs
+++ b/rust/core/tests/prototype.rs
@@ -2,7 +2,7 @@ use revm::{
     bytecode::opcode,
     primitives::{Address, B256, Bytes, U256, address, keccak256},
 };
-use sevm_revm_core::{
+use chasm_revm_core::{
     AccountSpec, Breakpoint, CHEATCODE_ADDRESS, ChainConfig, CommandValue, DEFAULT_CALLER,
     DEFAULT_TARGET, DebugEngine, DebugEvent, FrameKind, PauseReason, PrankConfig, PrototypeSession,
     SessionConfig, StateCommand, TransactionRequest,
@@ -11,14 +11,14 @@ use std::time::Duration;
 
 const TIMEOUT: Duration = Duration::from_secs(5);
 
-fn paused(session: &PrototypeSession) -> sevm_revm_core::Snapshot {
+fn paused(session: &PrototypeSession) -> chasm_revm_core::Snapshot {
     match session.wait(TIMEOUT).unwrap() {
         DebugEvent::Paused(snapshot) => *snapshot,
         event => panic!("expected pause, got {event:?}"),
     }
 }
 
-fn finished(session: &PrototypeSession) -> sevm_revm_core::Finished {
+fn finished(session: &PrototypeSession) -> chasm_revm_core::Finished {
     match session.wait(TIMEOUT).unwrap() {
         DebugEvent::Finished(result) => result,
         event => panic!("expected finish, got {event:?}"),
diff --git a/rust/headless/Cargo.toml b/rust/headless/Cargo.toml
index 8ee5baa..3915dff 100644
--- a/rust/headless/Cargo.toml
+++ b/rust/headless/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
-name = "sevm-revm-headless"
-description = "Transport-neutral JSON-RPC server for the sevm REVM engine"
+name = "chasm-revm-headless"
+description = "Transport-neutral JSON-RPC server for the chasm REVM engine"
 version.workspace = true
 edition.workspace = true
 rust-version.workspace = true
@@ -10,4 +10,4 @@ license.workspace = true
 revm.workspace = true
 serde = { version = "1.0.229", features = ["derive"] }
 serde_json = "1.0.151"
-sevm-revm-core.workspace = true
+chasm-revm-core.workspace = true
diff --git a/rust/headless/src/lib.rs b/rust/headless/src/lib.rs
index 597dbcd..56d1102 100644
--- a/rust/headless/src/lib.rs
+++ b/rust/headless/src/lib.rs
@@ -1,7 +1,7 @@
 use revm::primitives::{Address, B256, Bytes, U256};
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use serde_json::{Value, json};
-use sevm_revm_core::{
+use chasm_revm_core::{
     AccountSpec, Breakpoint, ChainConfig, CommandValue, DEFAULT_CALLER, DebugCommand, DebugEngine,
     DebugEvent, FrameContext, FrameKind, PauseReason, PrankConfig, SessionConfig, SessionError,
     Snapshot, StateCommand, TransactionKind, TransactionRequest,
@@ -13,7 +13,7 @@ use std::{
     time::Duration,
 };
 
-pub const PROTOCOL_VERSION: &str = "sevm-debugger/1";
+pub const PROTOCOL_VERSION: &str = "chasm-debugger/1";
 
 const PARSE_ERROR: i32 = -32700;
 const INVALID_REQUEST: i32 = -32600;
diff --git a/rust/headless/src/main.rs b/rust/headless/src/main.rs
index 325869a..e8d77d0 100644
--- a/rust/headless/src/main.rs
+++ b/rust/headless/src/main.rs
@@ -3,8 +3,8 @@ use std::io;
 fn main() {
     let stdin = io::stdin();
     let stdout = io::stdout();
-    if let Err(error) = sevm_revm_headless::serve(stdin.lock(), stdout.lock()) {
-        eprintln!("sevm REVM headless server failed: {error}");
+    if let Err(error) = chasm_revm_headless::serve(stdin.lock(), stdout.lock()) {
+        eprintln!("chasm REVM headless server failed: {error}");
         std::process::exit(1);
     }
 }
diff --git a/rust/headless/tests/protocol.rs b/rust/headless/tests/protocol.rs
index 0ee6ac6..c6e85dc 100644
--- a/rust/headless/tests/protocol.rs
+++ b/rust/headless/tests/protocol.rs
@@ -1,6 +1,6 @@
 use revm::primitives::keccak256;
 use serde_json::{Value, json};
-use sevm_revm_headless::{PROTOCOL_VERSION, serve};
+use chasm_revm_headless::{PROTOCOL_VERSION, serve};
 use std::{
     io::{Cursor, Read, Write},
     process::{Command, Stdio},
@@ -102,7 +102,7 @@ fn reports_protocol_and_recovers_after_bad_input() {
 
 #[test]
 fn binary_serves_the_protocol_on_stdio() {
-    let mut child = Command::new(env!("CARGO_BIN_EXE_sevm-revm-headless"))
+    let mut child = Command::new(env!("CARGO_BIN_EXE_chasm-revm-headless"))
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .spawn()
diff --git a/rust/python/Cargo.toml b/rust/python/Cargo.toml
index da6f688..8e99422 100644
--- a/rust/python/Cargo.toml
+++ b/rust/python/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
-name = "sevm-revm-python"
-description = "Python bridge for the sevm REVM debugger core"
+name = "chasm-revm-python"
+description = "Python bridge for the chasm REVM debugger core"
 version.workspace = true
 edition.workspace = true
 rust-version.workspace = true
@@ -13,5 +13,5 @@ crate-type = ["cdylib"]
 [dependencies]
 pyo3 = { version = "0.29.2", features = ["abi3-py310", "extension-module"] }
 revm.workspace = true
-sevm-revm-core.workspace = true
-sevm-revm-headless.workspace = true
+chasm-revm-core.workspace = true
+chasm-revm-headless.workspace = true
diff --git a/rust/python/src/lib.rs b/rust/python/src/lib.rs
index 5132c13..bd9dbd6 100644
--- a/rust/python/src/lib.rs
+++ b/rust/python/src/lib.rs
@@ -7,7 +7,7 @@ use revm::{
     bytecode::OpCode,
     primitives::{Address, B256, Bytes, U256},
 };
-use sevm_revm_core::{
+use chasm_revm_core::{
     AccountSpec, Breakpoint, CHEATCODE_ADDRESS, CONSOLE_ADDRESS, ChainConfig, CommandValue,
     DEFAULT_CALLER, DEFAULT_TARGET, DebugEngine, DebugEvent, FrameContext, FrameKind, PauseReason,
     PrankConfig, SessionConfig, SessionError, Snapshot, StateCommand, TransactionRequest,
@@ -212,7 +212,7 @@ fn event_dict<'py>(py: Python<'py>, event: DebugEvent) -> PyResult<Bound<'py, Py
     }
 }
 
-#[pyclass(module = "sevm._revm")]
+#[pyclass(module = "chasm_debugger._revm")]
 struct RevmChain {
     inner: DebugEngine,
 }
@@ -753,7 +753,7 @@ impl RevmChain {
     }
 }
 
-#[pyclass(module = "sevm._revm")]
+#[pyclass(module = "chasm_debugger._revm")]
 struct RevmSession {
     inner: DebugEngine,
 }
@@ -902,7 +902,7 @@ fn serve_stdio(py: Python<'_>) -> PyResult<()> {
     py.detach(|| {
         let stdin = io::stdin();
         let stdout = io::stdout();
-        sevm_revm_headless::serve(stdin.lock(), stdout.lock())
+        chasm_revm_headless::serve(stdin.lock(), stdout.lock())
     })
     .map_err(|error| PyRuntimeError::new_err(error.to_string()))
 }
diff --git a/src/sevm/__init__.py b/src/chasm_debugger/__init__.py
similarity index 81%
rename from src/sevm/__init__.py
rename to src/chasm_debugger/__init__.py
index 1e3660f..1662c07 100644
--- a/src/sevm/__init__.py
+++ b/src/chasm_debugger/__init__.py
@@ -1,4 +1,4 @@
-"""sevm: an interactive EVM playground on REVM, built for red-team dynamic analysis.
+"""Chasm: an interactive EVM playground on REVM, built for red-team dynamic analysis.
 
 Where things live:
 
@@ -13,19 +13,19 @@
   tui/           the Textual fullscreen frontend
   console.py     the plain-text frontend (`--console`)
 
-  artifacts.py   forge-shaped `out/sevm/<File.sol>/<Contract>.json`
+  artifacts.py   forge-shaped `out/chasm/<File.sol>/<Contract>.json`
   breakpoints.py the breakpoint and watchpoint set
   cache.py       the on-disk build cache
   clipboard.py   copying through the platform's own tool
   decode.py      storage layout, calldata and revert decoding
   disasm.py      the opcode table and disassembler
-  doctor.py      what `sevm doctor` reports: compiler, runtimes, caches
+  doctor.py      what `chasm doctor` reports: compiler, runtimes, caches
   dispatch.py    the external dispatcher read back out of runtime bytecode
   foundry.py     the Foundry test runner
   frames.py      EVM and Solidity frames, and the snapshot handed to the UI
   libs.py        dependency resolution: imports -> repo -> clone -> remapping
   provider.py    the REVM-backed Web3 provider for Python driver scripts
-  revm_server.py the headless REVM JSON-RPC process (`sevm-engine`)
+  revm_server.py the headless REVM JSON-RPC process (`chasm-engine`)
   srcmap.py      solc source maps: pc <-> source location
 """
 
diff --git a/src/sevm/__main__.py b/src/chasm_debugger/__main__.py
similarity index 100%
rename from src/sevm/__main__.py
rename to src/chasm_debugger/__main__.py
diff --git a/src/sevm/artifacts.py b/src/chasm_debugger/artifacts.py
similarity index 92%
rename from src/sevm/artifacts.py
rename to src/chasm_debugger/artifacts.py
index 0167e04..acfd11e 100644
--- a/src/sevm/artifacts.py
+++ b/src/chasm_debugger/artifacts.py
@@ -1,10 +1,10 @@
 """Forge-shaped artifacts on disk, so a build leaves something readable behind.
 
 The layout and field names are forge's own (`<File.sol>/<Contract>.json`), nested one level
-under the project's `out` directory. That nesting is deliberate: sevm compiles with the
+under the project's `out` directory. That nesting is deliberate: chasm compiles with the
 optimizer off, forge's cache would still call an overwritten artifact fresh, and the next
-`forge test` would silently run sevm's build. `metadata`/`rawMetadata` are the one thing
-forge writes and this does not; sevm never asks solc for them.
+`forge test` would silently run chasm's build. `metadata`/`rawMetadata` are the one thing
+forge writes and this does not; chasm never asks solc for them.
 """
 
 from __future__ import annotations
@@ -16,7 +16,7 @@
 if TYPE_CHECKING:
     from .compile import Artifact, Project
 
-SUBDIR = "sevm"
+SUBDIR = "chasm"
 
 
 def out_dir(root: str, out: str = "out") -> str:
diff --git a/src/sevm/assembly/__init__.py b/src/chasm_debugger/assembly/__init__.py
similarity index 100%
rename from src/sevm/assembly/__init__.py
rename to src/chasm_debugger/assembly/__init__.py
diff --git a/src/sevm/assembly/builtins.py b/src/chasm_debugger/assembly/builtins.py
similarity index 100%
rename from src/sevm/assembly/builtins.py
rename to src/chasm_debugger/assembly/builtins.py
diff --git a/src/sevm/assembly/execute.py b/src/chasm_debugger/assembly/execute.py
similarity index 100%
rename from src/sevm/assembly/execute.py
rename to src/chasm_debugger/assembly/execute.py
diff --git a/src/sevm/assembly/parser.py b/src/chasm_debugger/assembly/parser.py
similarity index 100%
rename from src/sevm/assembly/parser.py
rename to src/chasm_debugger/assembly/parser.py
diff --git a/src/sevm/breakpoints.py b/src/chasm_debugger/breakpoints.py
similarity index 100%
rename from src/sevm/breakpoints.py
rename to src/chasm_debugger/breakpoints.py
diff --git a/src/sevm/cache.py b/src/chasm_debugger/cache.py
similarity index 96%
rename from src/sevm/cache.py
rename to src/chasm_debugger/cache.py
index 4acb056..e2aaa0e 100644
--- a/src/sevm/cache.py
+++ b/src/chasm_debugger/cache.py
@@ -41,17 +41,17 @@
 
 def user_cache_dir() -> str:
     base = os.environ.get("XDG_CACHE_HOME") or os.path.expanduser("~/.cache")
-    return os.path.join(base, "sevm")
+    return os.path.join(base, "chasm")
 
 
 def cache_dir(root: str) -> str:
     """Where this root's units live.
 
-    A Foundry project gets `cache/sevm/`, which its .gitignore already covers and
-    `forge clean` already removes. Anywhere else sevm keeps out of the directory.
+    A Foundry project gets `cache/chasm/`, which its .gitignore already covers and
+    `forge clean` already removes. Anywhere else chasm keeps out of the directory.
     """
     if os.path.isfile(os.path.join(root, "foundry.toml")):
-        return os.path.join(root, "cache", "sevm")
+        return os.path.join(root, "cache", "chasm")
     digest = hashlib.sha256(os.path.abspath(root).encode()).hexdigest()[:16]
     return os.path.join(user_cache_dir(), "projects", digest)
 
@@ -232,7 +232,7 @@ def _prune(self, units: dict) -> None:
 
 
 def open_cache(root: str, enabled: bool = True) -> BuildCache | None:
-    if not enabled or os.environ.get("SEVM_NO_CACHE"):
+    if not enabled or os.environ.get("CHASM_NO_CACHE"):
         return None
     return BuildCache(cache_dir(root))
 
diff --git a/src/sevm/cheatcodes/__init__.py b/src/chasm_debugger/cheatcodes/__init__.py
similarity index 100%
rename from src/sevm/cheatcodes/__init__.py
rename to src/chasm_debugger/cheatcodes/__init__.py
diff --git a/src/sevm/cheatcodes/args.py b/src/chasm_debugger/cheatcodes/args.py
similarity index 100%
rename from src/sevm/cheatcodes/args.py
rename to src/chasm_debugger/cheatcodes/args.py
diff --git a/src/sevm/cheatcodes/assertions.py b/src/chasm_debugger/cheatcodes/assertions.py
similarity index 100%
rename from src/sevm/cheatcodes/assertions.py
rename to src/chasm_debugger/cheatcodes/assertions.py
diff --git a/src/sevm/cheatcodes/cheats.py b/src/chasm_debugger/cheatcodes/cheats.py
similarity index 96%
rename from src/sevm/cheatcodes/cheats.py
rename to src/chasm_debugger/cheatcodes/cheats.py
index 9e9c0f7..3149201 100644
--- a/src/sevm/cheatcodes/cheats.py
+++ b/src/chasm_debugger/cheatcodes/cheats.py
@@ -236,21 +236,21 @@ def _warm_slot(ctx: CheatContext) -> None:
 
 
 # ---- gas metering / control: no-ops that keep a test running ----------------------------
-# sevm meters and reports gas itself; these forge knobs only affect gas *snapshots*, which
-# sevm does not produce, so accepting them as no-ops lets a test that toggles them run.
+# chasm meters and reports gas itself; these forge knobs only affect gas *snapshots*, which
+# chasm does not produce, so accepting them as no-ops lets a test that toggles them run.
 
 
-@_cheat("pauseGasMetering()", doc="no-op (sevm does not take gas snapshots)")
+@_cheat("pauseGasMetering()", doc="no-op (chasm does not take gas snapshots)")
 def _pause_gas(ctx: CheatContext) -> None:
     return None
 
 
-@_cheat("resumeGasMetering()", doc="no-op (sevm does not take gas snapshots)")
+@_cheat("resumeGasMetering()", doc="no-op (chasm does not take gas snapshots)")
 def _resume_gas(ctx: CheatContext) -> None:
     return None
 
 
-@_cheat("resetGasMetering()", doc="no-op (sevm does not take gas snapshots)")
+@_cheat("resetGasMetering()", doc="no-op (chasm does not take gas snapshots)")
 def _reset_gas(ctx: CheatContext) -> None:
     return None
 
diff --git a/src/sevm/cheatcodes/console.py b/src/chasm_debugger/cheatcodes/console.py
similarity index 100%
rename from src/sevm/cheatcodes/console.py
rename to src/chasm_debugger/cheatcodes/console.py
diff --git a/src/sevm/cheatcodes/convert.py b/src/chasm_debugger/cheatcodes/convert.py
similarity index 100%
rename from src/sevm/cheatcodes/convert.py
rename to src/chasm_debugger/cheatcodes/convert.py
diff --git a/src/sevm/cheatcodes/env.py b/src/chasm_debugger/cheatcodes/env.py
similarity index 98%
rename from src/sevm/cheatcodes/env.py
rename to src/chasm_debugger/cheatcodes/env.py
index c62996a..706f618 100644
--- a/src/sevm/cheatcodes/env.py
+++ b/src/chasm_debugger/cheatcodes/env.py
@@ -1,7 +1,7 @@
 """The `vm.env*` family: read process environment variables into Solidity values.
 
 These read `os.environ`, exactly as forge reads the process environment, so a value is set
-by exporting it before launching sevm (`payload=0x... uv run sevm run ...`) or with
+by exporting it before launching chasm (`payload=0x... uv run chasm run ...`) or with
 `vm.setEnv` at the prompt. Each type has a scalar form and a `(name, delimiter)` array form;
 `envOr` returns a caller-supplied default instead of reverting when the key is absent.
 """
diff --git a/src/sevm/cheatcodes/registry.py b/src/chasm_debugger/cheatcodes/registry.py
similarity index 99%
rename from src/sevm/cheatcodes/registry.py
rename to src/chasm_debugger/cheatcodes/registry.py
index aa15740..a0aa7bc 100644
--- a/src/sevm/cheatcodes/registry.py
+++ b/src/chasm_debugger/cheatcodes/registry.py
@@ -1,7 +1,7 @@
 """The cheat registry, and the dispatch that runs one.
 
 Foundry cheatcodes are calls to the magic address `0x7109709E...` (the last 20 bytes of
-keccak256("hevm cheat code")). A real EVM does not know it; Foundry and sevm intercept the
+keccak256("hevm cheat code")). A real EVM does not know it; Foundry and chasm intercept the
 call and interpret it. `apply_cheat` decodes the selector and arguments, mutates live REVM
 state or session bookkeeping, and returns ABI-encoded data to the caller.
 
diff --git a/src/sevm/cheatcodes/wallet.py b/src/chasm_debugger/cheatcodes/wallet.py
similarity index 100%
rename from src/sevm/cheatcodes/wallet.py
rename to src/chasm_debugger/cheatcodes/wallet.py
diff --git a/src/sevm/cli.py b/src/chasm_debugger/cli.py
similarity index 96%
rename from src/sevm/cli.py
rename to src/chasm_debugger/cli.py
index f66758a..86d9254 100644
--- a/src/sevm/cli.py
+++ b/src/chasm_debugger/cli.py
@@ -1,7 +1,7 @@
-"""`sevm run script.py` - the entry point.
+"""`chasm run script.py` - the entry point.
 
 By decision, the debugger attaches to the user's own script rather than owning the
-setup. The script drives web3 exactly as it already does; sevm compiles the contracts,
+setup. The script drives web3 exactly as it already does; chasm compiles the contracts,
 temporarily supplies its REVM-backed Web3 provider, runs the script on the VM thread, and
 stops the first time execution enters code it recognises.
 
@@ -55,7 +55,7 @@ def target() -> None:
 
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
-        prog="sevm",
+        prog="chasm",
         description="A gdb-style interactive Solidity/EVM debugger.",
     )
     sub = parser.add_subparsers(dest="command", required=True)
@@ -63,7 +63,7 @@ def build_parser() -> argparse.ArgumentParser:
     run = sub.add_parser(
         "run",
         help="debug a Python script that drives web3",
-        usage="sevm run [options] SCRIPT [script args...]",
+        usage="chasm run [options] SCRIPT [script args...]",
         epilog="Options must come BEFORE the script; everything after it is passed to the script.",
     )
     run.add_argument(
@@ -81,7 +81,7 @@ def build_parser() -> argparse.ArgumentParser:
         "--solc-binary",
         default=None,
         metavar="PATH",
-        help="use this solc executable instead of downloading one (env: SEVM_SOLC)",
+        help="use this solc executable instead of downloading one (env: CHASM_SOLC)",
     )
     run.add_argument(
         "--console", action="store_true", help="plain text frontend instead of the TUI"
@@ -138,7 +138,7 @@ def build_parser() -> argparse.ArgumentParser:
         "--force", action="store_true", help="recompile even if the cache has this build"
     )
     compile_cmd = sub.add_parser(
-        "compile", help="compile contracts and report what sevm sees"
+        "compile", help="compile contracts and report what chasm sees"
     )
     compile_cmd.add_argument("contracts", help="directory or file of .sol sources")
     compile_cmd.add_argument("--solc", default=None)
@@ -164,14 +164,14 @@ def build_parser() -> argparse.ArgumentParser:
     )
 
     sub.add_parser(
-        "doctor", help="report the compiler, runtimes and caches sevm found here"
+        "doctor", help="report the compiler, runtimes and caches chasm found here"
     )
 
     mcp_cmd = sub.add_parser(
         "mcp",
         help="run the MCP server for AI clients (stdio transport)",
         description=(
-            "Run sevm as a Model Context Protocol server over stdio. An MCP client "
+            "Run chasm as a Model Context Protocol server over stdio. An MCP client "
             "starts/steps debug sessions and reads structured, windowed state — "
             "see docs/mcp.md for the tool list and client configuration."
         ),
@@ -187,7 +187,7 @@ def build_parser() -> argparse.ArgumentParser:
 
 
 def cmd_doctor(_args: argparse.Namespace) -> int:
-    """Print what sevm found, and fail if none of it can compile."""
+    """Print what chasm found, and fail if none of it can compile."""
     from . import doctor
 
     lines = doctor.report()
@@ -253,7 +253,7 @@ def cmd_run(args: argparse.Namespace) -> int:
         console.print(f"[bold red]no such script:[/bold red] {script}")
         return 1
 
-    # Everything after the script is forwarded to it verbatim, so a sevm option placed
+    # Everything after the script is forwarded to it verbatim, so a chasm option placed
     # there silently does nothing; name that failure instead of leaving it confusing.
     stray = [
         a
@@ -278,8 +278,8 @@ def cmd_run(args: argparse.Namespace) -> int:
     if stray:
         console.print(
             f"[yellow]note:[/yellow] {' '.join(stray)} came after the script, so "
-            "it was passed to the script rather than to sevm. Options go before it:\n"
-            f"  sevm run {' '.join(stray)} {script}"
+            "it was passed to the script rather than to chasm. Options go before it:\n"
+            f"  chasm run {' '.join(stray)} {script}"
         )
 
     # Dispatch by extension: a Foundry Solidity test, or the classic web3 Python driver.
@@ -509,7 +509,7 @@ def _debug(
         return 0 if session.exit_error is None else 1
 
     try:
-        from .tui.app import SevmApp
+        from .tui.app import ChasmApp
     except ImportError as exc:
         console.print(
             f"[yellow]the TUI needs Textual ({exc}). Install it with "
@@ -520,7 +520,7 @@ def _debug(
         ConsoleFrontend(session, evaluator).run(first_event=first)
         return 0 if session.exit_error is None else 1
 
-    app = SevmApp(
+    app = ChasmApp(
         session, evaluator, first_event=first, startup_commands=startup_commands
     )
     # Mouse on: every pane renders Textual `Content`, which the framework can
diff --git a/src/sevm/clipboard.py b/src/chasm_debugger/clipboard.py
similarity index 100%
rename from src/sevm/clipboard.py
rename to src/chasm_debugger/clipboard.py
diff --git a/src/sevm/commands/__init__.py b/src/chasm_debugger/commands/__init__.py
similarity index 100%
rename from src/sevm/commands/__init__.py
rename to src/chasm_debugger/commands/__init__.py
diff --git a/src/sevm/commands/breaking.py b/src/chasm_debugger/commands/breaking.py
similarity index 100%
rename from src/sevm/commands/breaking.py
rename to src/chasm_debugger/commands/breaking.py
diff --git a/src/sevm/commands/execution.py b/src/chasm_debugger/commands/execution.py
similarity index 100%
rename from src/sevm/commands/execution.py
rename to src/chasm_debugger/commands/execution.py
diff --git a/src/sevm/commands/help.py b/src/chasm_debugger/commands/help.py
similarity index 95%
rename from src/sevm/commands/help.py
rename to src/chasm_debugger/commands/help.py
index d0dbb1d..8b32b5d 100644
--- a/src/sevm/commands/help.py
+++ b/src/chasm_debugger/commands/help.py
@@ -57,7 +57,7 @@
                          a bare local name writes its stack slot: [dim]set var fee = 1 ether[/dim]
   [cyan]set[/cyan] $pc = 0x108        jump; [cyan]set[/cyan] $gas = N; [cyan]set[/cyan] $stack[0] = V; [cyan]set[/cyan] $storage[1] = V
   [cyan]reseat[/cyan]                 name the frame at the current pc after a JOP/manual jump
-  [cyan]bind[/cyan] x = $stack[3]     pin a local to a stack slot sevm could not observe
+  [cyan]bind[/cyan] x = $stack[3]     pin a local to a stack slot chasm could not observe
 
 [bold]Assembly[/bold]
   [cyan]mstore[/cyan](0x80, 1)        type a builtin call straight at the prompt
@@ -129,7 +129,7 @@
 implementation's JUMPDEST, which is the pc every caller converges on, so
 `b *0x544` catches a proxy, a raw-calldata call and an internal call alike.
 
-Both work on code sevm never compiled: a target already qualified as a signature or a
+Both work on code chasm never compiled: a target already qualified as a signature or a
 selector is read straight off the running bytecode, ABI or no ABI. Add `Contract.` to
 ask about a contract other than the one in view.
 """,
@@ -199,7 +199,7 @@
   reseat                              re-name the Solidity frame at the current pc, after a
   reseat 7 --push                     JOP gadget or manual `jump` landed outside solc's
                                       calling convention (optional frame base; --push nests)
-  bind arr = $stack[3]                pin a local sevm could not observe to a stack slot
+  bind arr = $stack[3]                pin a local chasm could not observe to a stack slot
                                       (n counts from the top, as the STACK pane shows)
 
   mstore(0x80, 1)                     raw assembly; see `help assembly`
@@ -221,7 +221,7 @@
   b LOC if amount > 1     conditions over them
   set var fee = 1 ether  writes the local's stack slot
 
-solc emits no location info for locals; sevm reconstructs it from the AST (name, type,
+solc emits no location info for locals; chasm reconstructs it from the AST (name, type,
 scope) plus the stack slot at the current pc. A local shadows a state variable of the
 same name, as in the contract.
 
@@ -312,16 +312,16 @@ def _cheatcode_help() -> str:
 HELP_TOPICS["yul"] = HELP_TOPICS["assembly"]
 HELP_TOPICS["foundry"] = """
 [bold]Foundry projects and libraries[/bold]
-sevm compiles a `.t.sol` the way forge does, and installs what is missing first.
+chasm compiles a `.t.sol` the way forge does, and installs what is missing first.
 
-  sevm run test/Counter.t.sol        inside a project: its foundry.toml, remappings.txt
+  chasm run test/Counter.t.sol        inside a project: its foundry.toml, remappings.txt
                                      and lib/ are used as they are
-  sevm run /tmp/scratch/Demo.t.sol   outside one: writes foundry.toml, clones forge-std
+  chasm run /tmp/scratch/Demo.t.sol   outside one: writes foundry.toml, clones forge-std
                                      into lib/, appends remappings.txt
-  sevm run -y ...                    skip the confirmation prompt
-  sevm run --no-install ...          resolve from disk only; refuse a missing import
+  chasm run -y ...                    skip the confirmation prompt
+  chasm run --no-install ...          resolve from disk only; refuse a missing import
 
-An unresolved import is looked up in sevm's table, then on npm, and cloned from its git
+An unresolved import is looked up in chasm's table, then on npm, and cloned from its git
 repository at the newest release tag:
 
   import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
diff --git a/src/sevm/commands/info.py b/src/chasm_debugger/commands/info.py
similarity index 100%
rename from src/sevm/commands/info.py
rename to src/chasm_debugger/commands/info.py
diff --git a/src/sevm/commands/inspecting.py b/src/chasm_debugger/commands/inspecting.py
similarity index 100%
rename from src/sevm/commands/inspecting.py
rename to src/chasm_debugger/commands/inspecting.py
diff --git a/src/sevm/commands/misc.py b/src/chasm_debugger/commands/misc.py
similarity index 100%
rename from src/sevm/commands/misc.py
rename to src/chasm_debugger/commands/misc.py
diff --git a/src/sevm/commands/mutation.py b/src/chasm_debugger/commands/mutation.py
similarity index 98%
rename from src/sevm/commands/mutation.py
rename to src/chasm_debugger/commands/mutation.py
index c881706..5892274 100644
--- a/src/sevm/commands/mutation.py
+++ b/src/chasm_debugger/commands/mutation.py
@@ -133,7 +133,7 @@ def cmd_reseat(proc: CommandProcessor, args: list[str], rest: str) -> CommandRes
 def cmd_bind(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult:
     """`bind <local> = $stack[<n>]`: pin a local to a stack slot by hand.
 
-    For a local sevm could not observe because the frame was entered outside the
+    For a local chasm could not observe because the frame was entered outside the
     prologue (a JOP landing). `n` counts from the top, as the STACK pane shows it.
     """
     body = rest.strip()
diff --git a/src/sevm/commands/parsing.py b/src/chasm_debugger/commands/parsing.py
similarity index 100%
rename from src/sevm/commands/parsing.py
rename to src/chasm_debugger/commands/parsing.py
diff --git a/src/sevm/commands/processor.py b/src/chasm_debugger/commands/processor.py
similarity index 100%
rename from src/sevm/commands/processor.py
rename to src/chasm_debugger/commands/processor.py
diff --git a/src/sevm/commands/render.py b/src/chasm_debugger/commands/render.py
similarity index 100%
rename from src/sevm/commands/render.py
rename to src/chasm_debugger/commands/render.py
diff --git a/src/sevm/commands/result.py b/src/chasm_debugger/commands/result.py
similarity index 100%
rename from src/sevm/commands/result.py
rename to src/chasm_debugger/commands/result.py
diff --git a/src/sevm/commands/symbols.py b/src/chasm_debugger/commands/symbols.py
similarity index 99%
rename from src/sevm/commands/symbols.py
rename to src/chasm_debugger/commands/symbols.py
index a3a8825..0bb114e 100644
--- a/src/sevm/commands/symbols.py
+++ b/src/chasm_debugger/commands/symbols.py
@@ -79,7 +79,7 @@ def info_address(proc: CommandProcessor, args: list[str]) -> CommandResult:
 
     The target is a name, a canonical signature or a selector, optionally qualified as
     `Contract.name`. A signature no ABI here declares is hashed, as `cast sig` does, so
-    a selector can be traced through code sevm never compiled.
+    a selector can be traced through code chasm never compiled.
     """
     contract, target = _split_contract("".join(args))
     art, code = _address_code(proc, contract, target)
diff --git a/src/sevm/compile/__init__.py b/src/chasm_debugger/compile/__init__.py
similarity index 100%
rename from src/sevm/compile/__init__.py
rename to src/chasm_debugger/compile/__init__.py
diff --git a/src/sevm/compile/build.py b/src/chasm_debugger/compile/build.py
similarity index 100%
rename from src/sevm/compile/build.py
rename to src/chasm_debugger/compile/build.py
diff --git a/src/sevm/compile/foundry_config.py b/src/chasm_debugger/compile/foundry_config.py
similarity index 96%
rename from src/sevm/compile/foundry_config.py
rename to src/chasm_debugger/compile/foundry_config.py
index 86c5565..fab1804 100644
--- a/src/sevm/compile/foundry_config.py
+++ b/src/chasm_debugger/compile/foundry_config.py
@@ -35,7 +35,7 @@
 test = "test"
 libs = ["lib"]
 
-# sevm forces the optimizer OFF for debuggable builds regardless of this file.
+# chasm forces the optimizer OFF for debuggable builds regardless of this file.
 """
 
 # For a lone .sol outside any project: no src/test layout to declare, just somewhere to
@@ -44,7 +44,7 @@
 [profile.default]
 libs = ["lib"]
 
-# sevm forces the optimizer OFF for debuggable builds regardless of this file.
+# chasm forces the optimizer OFF for debuggable builds regardless of this file.
 """
 
 
@@ -188,7 +188,7 @@ def _collect_project_sources(
 def _install_hint(import_path: str, importer: str) -> str:
     """Said when installs are off, whether by --no-install or by a declined prompt."""
     return (
-        f"unresolved import {import_path!r} in {importer}, and sevm was told not to "
+        f"unresolved import {import_path!r} in {importer}, and chasm was told not to "
         f"install it. Run again with -y to let it, or install it yourself:\n"
         f"  forge install <org>/<repo>\n"
         f"  echo '{package_of(import_path)}/=lib/<repo>/src/' >> remappings.txt"
@@ -274,7 +274,7 @@ def unresolved_prefixes(
 ) -> list[str]:
     """Library prefixes the sources import but cannot reach on disk.
 
-    Reads files only, so `sevm run` can say what it would install before compiling.
+    Reads files only, so `chasm run` can say what it would install before compiling.
     """
     cfg = cfg or read_foundry_config(root)
     sources = _collect_project_sources(root, (), source_dirs, cfg.libs)
diff --git a/src/sevm/compile/model.py b/src/chasm_debugger/compile/model.py
similarity index 99%
rename from src/sevm/compile/model.py
rename to src/chasm_debugger/compile/model.py
index ec3f7c9..6af6df1 100644
--- a/src/sevm/compile/model.py
+++ b/src/chasm_debugger/compile/model.py
@@ -1,4 +1,4 @@
-"""The artifact model: what a compiled project looks like to the rest of sevm.
+"""The artifact model: what a compiled project looks like to the rest of Chasm.
 
 Everything downstream depends only on these dataclasses, so a Foundry `out/*.json`
 importer could be added later by producing the same shapes.
diff --git a/src/sevm/compile/solc.py b/src/chasm_debugger/compile/solc.py
similarity index 100%
rename from src/sevm/compile/solc.py
rename to src/chasm_debugger/compile/solc.py
diff --git a/src/sevm/compile/solcbin.py b/src/chasm_debugger/compile/solcbin.py
similarity index 95%
rename from src/sevm/compile/solcbin.py
rename to src/chasm_debugger/compile/solcbin.py
index 4ea9b8c..6e28c45 100644
--- a/src/sevm/compile/solcbin.py
+++ b/src/chasm_debugger/compile/solcbin.py
@@ -3,7 +3,7 @@
 py-solc-x downloads from `binaries.soliditylang.org/{linux,macosx,windows}-amd64` and
 detects the OS only — there is no architecture check anywhere in it. On arm64 Linux or
 Apple silicon it therefore fetches an x86-64 binary and dies validating it, which is why
-sevm ran on x86_64 alone. Provisioning happens here instead; py-solc-x still *invokes*
+chasm ran on x86_64 alone. Provisioning happens here instead; py-solc-x still *invokes*
 solc (`compile_standard(solc_binary=...)`), which is the part of it that works.
 
 The platform map follows svm, Foundry's version manager, because it is the one
@@ -69,7 +69,7 @@
 _MACOS_UNIVERSAL = Version("0.8.24")
 
 _TIMEOUT = 30
-_HEADERS = {"User-Agent": "sevm"}
+_HEADERS = {"User-Agent": "chasm"}
 
 # Set by `--solc-binary`, and read before anything is looked up or downloaded: on a
 # platform with no published build, a compiler the user already has is the whole answer.
@@ -132,8 +132,8 @@ def use_binary(path: str | None) -> None:
 
 
 def override() -> str | None:
-    """The compiler the user pointed sevm at, if any."""
-    return _override or os.environ.get("SEVM_SOLC")
+    """The compiler the user pointed chasm at, if any."""
+    return _override or os.environ.get("CHASM_SOLC")
 
 
 def override_version() -> str | None:
@@ -150,7 +150,7 @@ def platform_key() -> str:
     """This machine, named the way solc's own download directories are.
 
     `unsupported` means no published build exists (32-bit x86, armv7, FreeBSD, ...), not
-    that sevm is broken there: `SEVM_SOLC` still points it at a compiler.
+    that chasm is broken there: `CHASM_SOLC` still points it at a compiler.
     """
     arm = platform.machine().lower() in ("aarch64", "arm64", "armv8b", "armv8l")
     if sys.platform.startswith("linux"):
@@ -326,8 +326,8 @@ def version_of(path: str) -> str | None:
 def find(version: str) -> str | None:
     """An already-usable solc of `version`, or None. Never downloads.
 
-    `--solc-binary` and `SEVM_SOLC` override everything, including the version, because
-    pointing sevm at a compiler is the escape hatch for a machine no download works on.
+    `--solc-binary` and `CHASM_SOLC` override everything, including the version, because
+    pointing chasm at a compiler is the escape hatch for a machine no download works on.
     """
     chosen = override()
     if chosen:
@@ -435,7 +435,7 @@ def _fetch_wasm_index() -> dict[str, list[str]]:
 
 
 def wasm_dir() -> str:
-    """soljson.js bundles live in sevm's cache, not `~/.solcx`, which holds binaries."""
+    """soljson.js bundles live in chasm's cache, not `~/.solcx`, which holds binaries."""
     return os.path.join(cache.user_cache_dir(), "solc-wasm")
 
 
@@ -476,7 +476,7 @@ def compiler(version: str) -> Compiler:
         if wasm.runtime() is None:
             raise CompileError(
                 f"{native}\n\nsolc also has a WebAssembly build that runs anywhere, but "
-                "it needs a JS runtime: install node (or name one with SEVM_NODE)."
+                "it needs a JS runtime: install node (or name one with CHASM_NODE)."
             ) from native
         try:
             return Compiler(version, ensure_wasm(version), wasm=True)
@@ -488,8 +488,8 @@ def _no_build_message(version: str, key: str) -> str:
     if key == "unsupported":
         return (
             f"no solc {version} build is published for {platform.system()} "
-            f"{platform.machine()}. Point sevm at a compiler you built or installed "
-            "yourself with SEVM_SOLC=/path/to/solc."
+            f"{platform.machine()}. Point chasm at a compiler you built or installed "
+            "yourself with CHASM_SOLC=/path/to/solc."
         )
     known = release_index(key)
     detail = "the release list could not be fetched" if not known else "no such release"
@@ -498,7 +498,7 @@ def _no_build_message(version: str, key: str) -> str:
         extra = " (arm64 Linux builds start at 0.5.0)"
     return (
         f"no solc {version} for {key}: {detail}{extra}. Pick a version that exists with "
-        "--solc, or set SEVM_SOLC=/path/to/solc."
+        "--solc, or set CHASM_SOLC=/path/to/solc."
     )
 
 
@@ -507,5 +507,5 @@ def _will_not_run_message(version: str, path: str) -> str:
         f"solc {version} downloaded to {path} but will not run on this machine. The "
         "official Linux builds are dynamically linked against glibc, so musl systems "
         "(Alpine) need gcompat and NixOS needs a wrapped solc. Install one yourself and "
-        "set SEVM_SOLC=/path/to/solc."
+        "set CHASM_SOLC=/path/to/solc."
     )
diff --git a/src/sevm/compile/soljson.js b/src/chasm_debugger/compile/soljson.js
similarity index 93%
rename from src/sevm/compile/soljson.js
rename to src/chasm_debugger/compile/soljson.js
index 0dcd76a..5bf4bee 100644
--- a/src/sevm/compile/soljson.js
+++ b/src/chasm_debugger/compile/soljson.js
@@ -3,7 +3,7 @@
 // soljson.js is a ~9MB JS bundle with the wasm inlined, not a WASI module, so a JS
 // runtime is the only way to call it — there is no pure-Python route. It exposes solc's
 // C entry point, which the solc-js package wraps and which is stable from 0.6:
-// `solidity_compile(input, readCallback, context)`. sevm inlines every source in the
+// `solidity_compile(input, readCallback, context)`. chasm inlines every source in the
 // standard-JSON input, so the import callback is never needed and is passed as null.
 //
 // Usage: node soljson.js <path to soljson> < input.json > output.json
diff --git a/src/sevm/compile/versions.py b/src/chasm_debugger/compile/versions.py
similarity index 100%
rename from src/sevm/compile/versions.py
rename to src/chasm_debugger/compile/versions.py
diff --git a/src/sevm/compile/wasm.py b/src/chasm_debugger/compile/wasm.py
similarity index 93%
rename from src/sevm/compile/wasm.py
rename to src/chasm_debugger/compile/wasm.py
index 5968503..e08218d 100644
--- a/src/sevm/compile/wasm.py
+++ b/src/chasm_debugger/compile/wasm.py
@@ -6,8 +6,8 @@
 the build cache stays valid across the two.
 
 It costs a JS runtime: soljson.js is an Emscripten bundle, not a WASI module, so wasmtime
-and friends cannot load it and there is no pure-Python option. `node` is what sevm looks
-for (`SEVM_NODE` names another). Loading the ~9MB bundle and compiling a small contract
+and friends cannot load it and there is no pure-Python option. `node` is what chasm looks
+for (`CHASM_NODE` names another). Loading the ~9MB bundle and compiling a small contract
 takes ~0.4s end to end against ~0.01s native, which is the reason this is a fallback and
 not the default.
 """
@@ -29,7 +29,7 @@
 
 def runtime() -> str | None:
     """The JS runtime to drive soljson.js with, or None if the machine has none."""
-    named = os.environ.get("SEVM_NODE")
+    named = os.environ.get("CHASM_NODE")
     candidates = (named,) if named else _RUNTIMES
     for candidate in candidates:
         found = shutil.which(candidate)
@@ -49,7 +49,7 @@ def compile_standard(soljson: str, payload: dict) -> dict:
     if node is None:
         raise CompileError(
             "no JS runtime to run solc's WebAssembly build with. Install node, or name "
-            "one with SEVM_NODE, or point sevm at a native compiler with SEVM_SOLC."
+            "one with CHASM_NODE, or point chasm at a native compiler with CHASM_SOLC."
         )
     done = subprocess.run(
         [node, DRIVER, soljson],
@@ -69,7 +69,7 @@ def compile_standard(soljson: str, payload: dict) -> dict:
 
 
 # Solidity gives its builtins negative ids (`msg` is -15), and the Emscripten build
-# serialises them as unsigned 32-bit: `referencedDeclaration: 4294967281`. Nothing sevm
+# serialises them as unsigned 32-bit: `referencedDeclaration: 4294967281`. Nothing chasm
 # reads resolves a builtin, but normalising keeps the two backends' documents
 # interchangeable, which the build cache assumes — it is keyed on the compiler version,
 # never on which backend produced the entry.
diff --git a/src/sevm/console.py b/src/chasm_debugger/console.py
similarity index 95%
rename from src/sevm/console.py
rename to src/chasm_debugger/console.py
index 44dafb0..f45328f 100644
--- a/src/sevm/console.py
+++ b/src/chasm_debugger/console.py
@@ -1,6 +1,6 @@
 """The plain-text frontend.
 
-Exists so the engine can be proved correct without a UI in the way, and so `sevm run
+Exists so the engine can be proved correct without a UI in the way, and so `chasm run
 --console` works over ssh, in CI, and anywhere the TUI cannot draw. It is the same
 CommandProcessor the TUI drives, so behaviour cannot drift between the two.
 """
@@ -13,7 +13,7 @@
 from .evaluate import Evaluator
 from .session import DebugSession, Finished, Paused
 
-BANNER = """[bold]sevm[/bold] - Solidity/EVM debugger. [dim]gdb commands; `help` for the list.[/dim]"""
+BANNER = """[bold]Chasm[/bold] - Solidity/EVM debugger. [dim]gdb commands; `help` for the list.[/dim]"""
 
 
 class ConsoleFrontend:
@@ -69,7 +69,7 @@ def run(self, first_event=None) -> None:
         self.on_first_stop(first_event)
         while True:
             try:
-                raw = self.console.input("[bold green](sevm)[/bold green] ")
+                raw = self.console.input("[bold green](chasm)[/bold green] ")
             except (EOFError, KeyboardInterrupt):
                 self.console.print()
                 break
diff --git a/src/sevm/decode.py b/src/chasm_debugger/decode.py
similarity index 100%
rename from src/sevm/decode.py
rename to src/chasm_debugger/decode.py
diff --git a/src/sevm/disasm.py b/src/chasm_debugger/disasm.py
similarity index 100%
rename from src/sevm/disasm.py
rename to src/chasm_debugger/disasm.py
diff --git a/src/sevm/dispatch.py b/src/chasm_debugger/dispatch.py
similarity index 100%
rename from src/sevm/dispatch.py
rename to src/chasm_debugger/dispatch.py
diff --git a/src/sevm/doctor.py b/src/chasm_debugger/doctor.py
similarity index 91%
rename from src/sevm/doctor.py
rename to src/chasm_debugger/doctor.py
index a5bb361..8c8ed65 100644
--- a/src/sevm/doctor.py
+++ b/src/chasm_debugger/doctor.py
@@ -1,4 +1,4 @@
-"""What sevm found on this machine, and what it would do about it.
+"""What chasm found on this machine, and what it would do about it.
 
 Every question this answers came from a real support round: which build of solc this
 platform gets, whether the one already installed runs, whether the WebAssembly fallback
@@ -23,7 +23,7 @@
 
 @dataclass(frozen=True)
 class Line:
-    """One reported fact. `problem` marks the ones that stop sevm working."""
+    """One reported fact. `problem` marks the ones that stop chasm working."""
 
     label: str
     value: str
@@ -65,7 +65,7 @@ def _solc_lines(version: str, node: str | None) -> list[Line]:
         lines.append(
             Line(
                 "solc",
-                f"{override} (SEVM_SOLC or --solc-binary)"
+                f"{override} (CHASM_SOLC or --solc-binary)"
                 + (f", reports {reported}" if reported else ", DOES NOT RUN"),
                 problem=reported is None,
             )
@@ -102,13 +102,13 @@ def _solc_lines(version: str, node: str | None) -> list[Line]:
 
 
 def report() -> list[Line]:
-    """Everything `sevm doctor` prints, in order."""
+    """Everything `chasm doctor` prints, in order."""
     node = wasm.runtime()
     node_version = _tool_version(node, "--version") if node else None
     git = _tool_version("git", "--version")
 
     lines = [
-        Line("sevm", _sevm_version()),
+        Line("chasm", _chasm_version()),
         Line(
             "python",
             f"{platform.python_version()} ({platform.python_implementation()}) "
@@ -133,7 +133,7 @@ def report() -> list[Line]:
 
     overrides = [
         f"{name}={os.environ[name]}"
-        for name in ("SEVM_SOLC", "SEVM_NODE", "SOLCX_BINARY_PATH", "SEVM_NO_CACHE")
+        for name in ("CHASM_SOLC", "CHASM_NODE", "SOLCX_BINARY_PATH", "CHASM_NO_CACHE")
         if os.environ.get(name)
     ]
     if overrides:
@@ -141,11 +141,11 @@ def report() -> list[Line]:
     return lines
 
 
-def _sevm_version() -> str:
+def _chasm_version() -> str:
     from importlib.metadata import PackageNotFoundError, version
 
     try:
-        return version("sevm")
+        return version("chasm")
     except PackageNotFoundError:  # pragma: no cover - running from a source tree
         return "unknown"
 
diff --git a/src/sevm/evaluate/__init__.py b/src/chasm_debugger/evaluate/__init__.py
similarity index 92%
rename from src/sevm/evaluate/__init__.py
rename to src/chasm_debugger/evaluate/__init__.py
index 0a46592..1e7bcd4 100644
--- a/src/sevm/evaluate/__init__.py
+++ b/src/chasm_debugger/evaluate/__init__.py
@@ -1,7 +1,7 @@
 """Solidity expression evaluation at a breakpoint.
 
 The trick is to borrow the real Solidity compiler rather than write an interpreter: splice
-`function __sevm_eval() returns (T) { return (<expr>); }` into the paused contract's
+`function __chasm_eval() returns (T) { return (<expr>); }` into the paused contract's
 source, compile it, swap the runtime code in on a state snapshot, run it, decode, revert.
 
   bindings.py    getting locals and `msg.data`/`msg.sig` into the injected function
diff --git a/src/sevm/evaluate/bindings.py b/src/chasm_debugger/evaluate/bindings.py
similarity index 97%
rename from src/sevm/evaluate/bindings.py
rename to src/chasm_debugger/evaluate/bindings.py
index e656e85..f54e075 100644
--- a/src/sevm/evaluate/bindings.py
+++ b/src/chasm_debugger/evaluate/bindings.py
@@ -21,15 +21,15 @@
 
 from ..locals import referenced_names
 
-EVAL_FUNCTION = "__sevm_eval"
+EVAL_FUNCTION = "__chasm_eval"
 EVAL_SELECTOR = function_signature_to_4byte_selector(f"{EVAL_FUNCTION}()")
 
 # msg field -> (parameter name, declared type, abi type). `bytes calldata` rather than
 # `bytes memory` so `msg.data[4:]` still slices, which is how anyone reads arguments out
 # of raw calldata.
 MSG_FIELDS: dict[str, tuple[str, str, str]] = {
-    "data": ("__sevm_msg_data", "bytes calldata", "bytes"),
-    "sig": ("__sevm_msg_sig", "bytes4", "bytes4"),
+    "data": ("__chasm_msg_data", "bytes calldata", "bytes"),
+    "sig": ("__chasm_msg_sig", "bytes4", "bytes4"),
 }
 
 _MSG_FIELD = re.compile(r"\bmsg\s*\.\s*(data|sig)\b")
diff --git a/src/sevm/evaluate/evaluator.py b/src/chasm_debugger/evaluate/evaluator.py
similarity index 99%
rename from src/sevm/evaluate/evaluator.py
rename to src/chasm_debugger/evaluate/evaluator.py
index c21ae70..960231f 100644
--- a/src/sevm/evaluate/evaluator.py
+++ b/src/chasm_debugger/evaluate/evaluator.py
@@ -2,7 +2,7 @@
 
 Borrow the real Solidity compiler instead of writing an interpreter. Splice
 
-    function __sevm_eval() public payable returns (T) { return (<expr>); }
+    function __chasm_eval() public payable returns (T) { return (<expr>); }
 
 into the paused contract's source, compile it, swap the runtime code at the target address
 on a state snapshot, run it, decode the output, revert. Operator precedence, checked
@@ -159,7 +159,7 @@ def _known_type(
 
         `p amount` and `p totalDeposits` are most of what gets typed at a prompt, and
         typing them costs a whole compile of its own. This is a lookup rather than a
-        second type checker: a bound local resolves to the parameter sevm itself
+        second type checker: a bound local resolves to the parameter chasm itself
         declares, and a state variable to solc's own `typeString`, so both are the
         string the probe's diagnostic would have reported. Anything else returns None
         and goes to solc.
diff --git a/src/sevm/evaluate/injection.py b/src/chasm_debugger/evaluate/injection.py
similarity index 97%
rename from src/sevm/evaluate/injection.py
rename to src/chasm_debugger/evaluate/injection.py
index 618d466..b543853 100644
--- a/src/sevm/evaluate/injection.py
+++ b/src/chasm_debugger/evaluate/injection.py
@@ -11,10 +11,10 @@
 from dataclasses import dataclass
 from typing import Any
 
-EVAL_FUNCTION = "__sevm_eval"
+EVAL_FUNCTION = "__chasm_eval"
 
-PROBE_STRUCT = "__SevmProbe"
-PROBE_DECL = f"struct {PROBE_STRUCT} {{ uint8 __sevm_x; }}"
+PROBE_STRUCT = "__ChasmProbe"
+PROBE_DECL = f"struct {PROBE_STRUCT} {{ uint8 __chasm_x; }}"
 PROBE_TYPE = f"{PROBE_STRUCT} memory"
 
 # solc phrases the mismatch two different ways depending on where it is caught.
diff --git a/src/sevm/foundry.py b/src/chasm_debugger/foundry.py
similarity index 97%
rename from src/sevm/foundry.py
rename to src/chasm_debugger/foundry.py
index 6f83e45..3c88adb 100644
--- a/src/sevm/foundry.py
+++ b/src/chasm_debugger/foundry.py
@@ -28,11 +28,11 @@ class TestTarget:
 
 @dataclass(frozen=True)
 class Prepared:
-    """What `sevm run` may do to the target directory, after asking."""
+    """What `chasm run` may do to the target directory, after asking."""
 
     root: str
     existing: bool  # a foundry.toml was already there
-    may_install: bool  # the user let sevm fetch missing libraries
+    may_install: bool  # the user let chasm fetch missing libraries
     declined: bool = False  # asked, and the answer was no (or there was no terminal)
     missing: tuple[str, ...] = ()  # libraries that would have been installed
 
@@ -113,7 +113,7 @@ def prepare_project(
 
     approved = assume_yes
     if not approved and sys.stdin.isatty():
-        prompt = "sevm will:\n" + "".join(f"  - {p}\n" for p in planned) + "[y/N] "
+        prompt = "chasm will:\n" + "".join(f"  - {p}\n" for p in planned) + "[y/N] "
         try:
             approved = input(prompt).strip().lower() in ("y", "yes")
         except EOFError:
@@ -220,7 +220,7 @@ def select_test(
 
 
 class TestFailed(RuntimeError):
-    """A test transaction reverted. forge would print a failure; sevm ends the run with one."""
+    """A test transaction reverted. forge would print a failure; chasm ends the run with one."""
 
 
 @dataclass(frozen=True)
diff --git a/src/sevm/frames.py b/src/chasm_debugger/frames.py
similarity index 100%
rename from src/sevm/frames.py
rename to src/chasm_debugger/frames.py
diff --git a/src/sevm/libs.py b/src/chasm_debugger/libs.py
similarity index 98%
rename from src/sevm/libs.py
rename to src/chasm_debugger/libs.py
index 91e664c..b5ea650 100644
--- a/src/sevm/libs.py
+++ b/src/chasm_debugger/libs.py
@@ -1,9 +1,9 @@
 """Solidity dependency resolution: read imports, find the repo, clone it, remap it.
 
-sevm no longer ships its own forge-std. A `.t.sol` (or any contract) gets the real library
+chasm no longer ships its own forge-std. A `.t.sol` (or any contract) gets the real library
 from the real source, installed the way `forge install` leaves it: a shallow clone under
 `lib/<name>`, pinned to the newest stable tag, with an explicit remapping so `forge` and
-sevm resolve the import identically.
+chasm resolve the import identically.
 
 Git is the only requirement: `git ls-remote --tags` lists releases unauthenticated (no
 GitHub API rate limit) and `git clone --depth 1 --branch <tag>` fetches one. The `forge`
@@ -187,7 +187,7 @@ def _run_git(args: Sequence[str], timeout: float = _GIT_TIMEOUT) -> str:
         )
     except FileNotFoundError as exc:
         raise LibError(
-            "git is not installed; sevm needs it to fetch dependencies"
+            "git is not installed; chasm needs it to fetch dependencies"
         ) from exc
     except subprocess.TimeoutExpired as exc:
         raise LibError(f"git {' '.join(args)} timed out") from exc
@@ -354,7 +354,7 @@ def install(
     if repo_url is None:
         raise LibError(
             f"cannot resolve import {sample_import!r}: no library named {prefix!r} in "
-            f"sevm's table or on npm.\n"
+            f"chasm's table or on npm.\n"
             f"Install it yourself and add the remapping:\n"
             f"  forge install <org>/<repo>\n"
             f"  echo '{prefix}/=lib/<repo>/src/' >> remappings.txt"
@@ -397,7 +397,7 @@ def missing_prefixes(unresolved: Iterable[str]) -> list[str]:
 
 
 def write_remappings(root: str, entries: Sequence[str]) -> list[str]:
-    """Append missing lines to `<root>/remappings.txt` so `forge` resolves as sevm does.
+    """Append missing lines to `<root>/remappings.txt` so `forge` resolves as chasm does.
 
     Returns the lines actually added; existing entries are never rewritten or reordered.
     """
diff --git a/src/sevm/locals/__init__.py b/src/chasm_debugger/locals/__init__.py
similarity index 100%
rename from src/sevm/locals/__init__.py
rename to src/chasm_debugger/locals/__init__.py
diff --git a/src/sevm/locals/index.py b/src/chasm_debugger/locals/index.py
similarity index 100%
rename from src/sevm/locals/index.py
rename to src/chasm_debugger/locals/index.py
diff --git a/src/sevm/locals/layout.py b/src/chasm_debugger/locals/layout.py
similarity index 100%
rename from src/sevm/locals/layout.py
rename to src/chasm_debugger/locals/layout.py
diff --git a/src/sevm/locals/values.py b/src/chasm_debugger/locals/values.py
similarity index 100%
rename from src/sevm/locals/values.py
rename to src/chasm_debugger/locals/values.py
diff --git a/src/sevm/mcp_server/__init__.py b/src/chasm_debugger/mcp_server/__init__.py
similarity index 86%
rename from src/sevm/mcp_server/__init__.py
rename to src/chasm_debugger/mcp_server/__init__.py
index a3b652a..6f6563f 100644
--- a/src/sevm/mcp_server/__init__.py
+++ b/src/chasm_debugger/mcp_server/__init__.py
@@ -3,11 +3,11 @@
 Where the console renders Rich markup and the TUI draws panes, this frontend
 returns structured JSON with explicit windows and truncation flags — an LLM
 cannot scroll a pane or watch colour, but it can narrow an offset. Launch with
-`sevm mcp` (stdio transport).
+`chasm mcp` (stdio transport).
 
 Where things live:
 
-  driver.py     `DebugDriver`: owns the one session, mirrors `sevm run`'s wiring,
+  driver.py     `DebugDriver`: owns the one session, mirrors `chasm run`'s wiring,
                 and remembers the previous stop for diffs
   serialize.py  value formatting: hex words, memory windows, the stop report
   tools.py      the tool registrations over the driver
diff --git a/src/sevm/mcp_server/driver.py b/src/chasm_debugger/mcp_server/driver.py
similarity index 98%
rename from src/sevm/mcp_server/driver.py
rename to src/chasm_debugger/mcp_server/driver.py
index 5faf529..7cd195e 100644
--- a/src/sevm/mcp_server/driver.py
+++ b/src/chasm_debugger/mcp_server/driver.py
@@ -3,7 +3,7 @@
 The console and the TUI are thin renderers over `CommandProcessor`; this is the
 third frontend, and the only thing it draws is JSON. `DebugDriver` owns one
 debug session (single active target, replaced by the next start), mirrors the
-wiring `sevm run` does for both target kinds, and remembers the previous stop so
+wiring `chasm run` does for both target kinds, and remembers the previous stop so
 it can answer "what changed?" — the question a human answers by watching panes.
 """
 
@@ -65,7 +65,7 @@ def _notice(self, message: str) -> None:
     def _require(self) -> tuple[DebugSession, CommandProcessor]:
         if self._session is None or self._processor is None:
             raise DriverError(
-                "no active debug session; call sevm_start_session first "
+                "no active debug session; call chasm_start_session first "
                 "(script_path for a web3.py driver or a .t.sol Foundry test)"
             )
         return self._session, self._processor
@@ -86,7 +86,7 @@ def start(
         """Compile and start a debug target; replaces any existing session.
 
         `provenance=true` records every executed opcode from the start, enabling
-        `sevm_why_stack` and `sevm_export_trace` without a second pass.
+        `chasm_why_stack` and `chasm_export_trace` without a second pass.
         `reference_runtime_hex` (the deployed runtime, as an explorer or
         `cast code` prints it) hard-fails the start when the compiled contract
         diverges beyond the metadata tail: pcs and gadget offsets silently
@@ -134,7 +134,7 @@ def _start_script(
         solc: str | None,
         optimize: bool,
     ) -> dict[str, Any]:
-        # Same wiring as `sevm run <script>`: the contracts dir becomes the compile
+        # Same wiring as `chasm run <script>`: the contracts dir becomes the compile
         # root unless it sits inside a Foundry project.
         from ..cli import _find_contracts_dir, _run_script
         from ..foundry import prepare_project
@@ -705,7 +705,7 @@ def why_stack(self, index_from_top: int) -> dict[str, Any]:
             prov = session.provenance
             if not prov.enabled and not prov.records:
                 raise DriverError(
-                    "provenance recording is off; call sevm_set_provenance(True) "
+                    "provenance recording is off; call chasm_set_provenance(True) "
                     "(or start the session with provenance=true) and navigate"
                 )
             from ..session.provenance import why_stack as slice_stack
@@ -848,7 +848,7 @@ def set_breakpoint(
             else:
                 raise DriverError(
                     "location must be '*0xPC', 'File.sol:LINE', or a function name; "
-                    "opcodes go through sevm_set_opcode_breakpoint"
+                    "opcodes go through chasm_set_opcode_breakpoint"
                 )
             bp = result[0] if isinstance(result, tuple) else result
             return self._breakpoint_row(bp)
diff --git a/src/sevm/mcp_server/serialize.py b/src/chasm_debugger/mcp_server/serialize.py
similarity index 100%
rename from src/sevm/mcp_server/serialize.py
rename to src/chasm_debugger/mcp_server/serialize.py
diff --git a/src/sevm/mcp_server/tools.py b/src/chasm_debugger/mcp_server/tools.py
similarity index 81%
rename from src/sevm/mcp_server/tools.py
rename to src/chasm_debugger/mcp_server/tools.py
index ae6eb6f..b19cb06 100644
--- a/src/sevm/mcp_server/tools.py
+++ b/src/chasm_debugger/mcp_server/tools.py
@@ -16,14 +16,14 @@
 
 from .driver import DebugDriver, DriverError
 
-INSTRUCTIONS = """sevm: a gdb-style Solidity/EVM debugger running on REVM.
+INSTRUCTIONS = """chasm: a gdb-style Solidity/EVM debugger running on REVM.
 
-Workflow: sevm_start_session (a web3.py driver script or a .t.sol Foundry test)
+Workflow: chasm_start_session (a web3.py driver script or a .t.sol Foundry test)
 loads and compiles the target and stops at the first contract instruction.
-Then navigate (sevm_continue / sevm_step_opcodes / sevm_run_to), inspect with
-windowed reads (sevm_read_memory, sevm_disassemble, sevm_read_source), evaluate
-Solidity against the paused frame (sevm_evaluate), and mutate live state
-(sevm_write_storage, sevm_set_stack_slot, sevm_set_gas).
+Then navigate (chasm_continue / chasm_step_opcodes / chasm_run_to), inspect with
+windowed reads (chasm_read_memory, chasm_disassemble, chasm_read_source), evaluate
+Solidity against the paused frame (chasm_evaluate), and mutate live state
+(chasm_write_storage, chasm_set_stack_slot, chasm_set_gas).
 
 Every navigation tool returns the same stop report (pc, opcode, gas, stack top,
 stack delta since the previous stop), so you always know where you are in one
@@ -31,7 +31,7 @@
 `truncated: true` — narrow the offset instead of asking for more.
 
 Unlike a human at a terminal you cannot scroll or watch panes: rely on
-sevm_diff_since_last_stop after each step to see what changed (stack pushes /
+chasm_diff_since_last_stop after each step to see what changed (stack pushes /
 pops with values, changed memory ranges, gas spent).
 """
 
@@ -53,12 +53,12 @@ async def _run(driver: DebugDriver, fn: str, *args: Any, **kwargs: Any) -> dict[
 
 def build_server(driver: DebugDriver | None = None) -> MCPServer:
     driver = driver or DebugDriver()
-    server = MCPServer("sevm", instructions=INSTRUCTIONS)
+    server = MCPServer("chasm", instructions=INSTRUCTIONS)
 
     # -- lifecycle ---------------------------------------------------------
 
     @server.tool()
-    async def sevm_start_session(
+    async def chasm_start_session(
         target: str,
         args: list[str] | None = None,
         contracts: str | None = None,
@@ -95,12 +95,12 @@ async def sevm_start_session(
         )
 
     @server.tool()
-    async def sevm_stop_session() -> dict:
+    async def chasm_stop_session() -> dict:
         """Stop and dispose the active debug session (chain state is discarded)."""
         return await _run(driver, "stop")
 
     @server.tool()
-    async def sevm_restart_session(args: list[str] | None = None) -> dict:
+    async def chasm_restart_session(args: list[str] | None = None) -> dict:
         """Re-run the target from scratch: fresh chain, breakpoints kept.
 
         Pass `args` to replace the script's arguments (e.g. new calldata for a
@@ -111,42 +111,42 @@ async def sevm_restart_session(args: list[str] | None = None) -> dict:
     # -- navigation (uniform stop report) ----------------------------------
 
     @server.tool()
-    async def sevm_continue() -> dict:
+    async def chasm_continue() -> dict:
         """Run until the next breakpoint, watchpoint, error/revert, or program end."""
         return await _run(driver, "continue_execution")
 
     @server.tool()
-    async def sevm_step_opcodes(count: int = 1) -> dict:
+    async def chasm_step_opcodes(count: int = 1) -> dict:
         """Execute `count` opcodes (max 1000), stepping into calls."""
         return await _run(driver, "step_opcodes", count)
 
     @server.tool()
-    async def sevm_step_lines(count: int = 1) -> dict:
+    async def chasm_step_lines(count: int = 1) -> dict:
         """Advance `count` Solidity source lines, stepping into internal calls."""
         return await _run(driver, "step_lines", count)
 
     @server.tool()
-    async def sevm_next_lines(count: int = 1) -> dict:
+    async def chasm_next_lines(count: int = 1) -> dict:
         """Advance `count` Solidity lines, stepping over internal calls."""
         return await _run(driver, "next_lines", count)
 
     @server.tool()
-    async def sevm_finish_frame() -> dict:
+    async def chasm_finish_frame() -> dict:
         """Run to the end of the current frame (function call or internal call)."""
         return await _run(driver, "finish_frame")
 
     @server.tool()
-    async def sevm_run_to(location: str | None = None, pc: int | None = None) -> dict:
+    async def chasm_run_to(location: str | None = None, pc: int | None = None) -> dict:
         """Run to a location: `pc` (int), or `location` like 'Bank.sol:46' / '*0x108'."""
         return await _run(driver, "run_to", location=location, pc=pc)
 
     @server.tool()
-    async def sevm_get_status(stack_top: int = 5) -> dict:
+    async def chasm_get_status(stack_top: int = 5) -> dict:
         """Where am I? Full stop report: pc, opcode, gas, sp, location, stack top."""
         return await _run(driver, "status")
 
     @server.tool()
-    async def sevm_diff_since_last_stop() -> dict:
+    async def chasm_diff_since_last_stop() -> dict:
         """What did the last navigation change? Stack pushes/pops with values,
         changed memory byte-ranges, gas spent, pc move. Your replacement for
         watching panes scroll."""
@@ -155,19 +155,19 @@ async def sevm_diff_since_last_stop() -> dict:
     # -- inspection --------------------------------------------------------
 
     @server.tool()
-    async def sevm_read_memory(offset: int = 0, words: int = 8) -> dict:
+    async def chasm_read_memory(offset: int = 0, words: int = 8) -> dict:
         """Read a window of EVM memory as 32-byte words (0x + 64 hex chars each),
         annotated with Solidity regions (scratch/free-memory-pointer/zero-slot);
         words past the allocation carry `beyond: true`."""
         return await _run(driver, "read_memory", offset, words)
 
     @server.tool()
-    async def sevm_read_stack(offset: int = 0, limit: int = 32) -> dict:
+    async def chasm_read_stack(offset: int = 0, limit: int = 32) -> dict:
         """Read the operand stack; index 0 is the top. Hex + decimal per slot."""
         return await _run(driver, "read_stack", offset, limit)
 
     @server.tool()
-    async def sevm_read_storage(
+    async def chasm_read_storage(
         slots: list[int] | None = None, decode: bool = True
     ) -> dict:
         """Read storage. By default decodes the running contract's whole layout
@@ -176,35 +176,35 @@ async def sevm_read_storage(
         return await _run(driver, "read_storage", slots, decode)
 
     @server.tool()
-    async def sevm_read_calldata(offset: int = 0, size: int = 256) -> dict:
+    async def chasm_read_calldata(offset: int = 0, size: int = 256) -> dict:
         """Read the transaction calldata (windowed; huge payloads stay bounded).
         The first window includes the 4-byte selector and its signature."""
         return await _run(driver, "read_calldata", offset, size)
 
     @server.tool()
-    async def sevm_get_backtrace() -> dict:
+    async def chasm_get_backtrace() -> dict:
         """The call stack: Solidity frames interleaved with EVM frames."""
         return await _run(driver, "get_backtrace")
 
     @server.tool()
-    async def sevm_get_locals() -> dict:
+    async def chasm_get_locals() -> dict:
         """Local variables of the selected Solidity frame, decoded."""
         return await _run(driver, "get_locals")
 
     @server.tool()
-    async def sevm_get_arguments() -> dict:
+    async def chasm_get_arguments() -> dict:
         """The current external frame's call arguments, ABI-decoded."""
         return await _run(driver, "get_arguments")
 
     @server.tool()
-    async def sevm_disassemble(
+    async def chasm_disassemble(
         around_pc: int | None = None, before: int = 6, after: int = 18
     ) -> dict:
         """Disassembly rows {pc, text, jumpdest, line} around a pc (default: current)."""
         return await _run(driver, "disassemble", around_pc, before, after)
 
     @server.tool()
-    async def sevm_read_source(
+    async def chasm_read_source(
         file: str | None = None, around_line: int | None = None, context: int = 10
     ) -> dict:
         """A window of Solidity source with line numbers; the current line is
@@ -212,28 +212,30 @@ async def sevm_read_source(
         return await _run(driver, "read_source", file, around_line, context)
 
     @server.tool()
-    async def sevm_get_gas_profile(limit: int = 20) -> dict:
+    async def chasm_get_gas_profile(limit: int = 20) -> dict:
         """Gas spent so far, profiled by opcode and by source line."""
         return await _run(driver, "get_gas_profile", limit)
 
     @server.tool()
-    async def sevm_get_logs() -> dict:
+    async def chasm_get_logs() -> dict:
         """Event logs emitted so far this transaction, with decoded event names."""
         return await _run(driver, "get_logs")
 
     @server.tool()
-    async def sevm_list_contracts() -> dict:
+    async def chasm_list_contracts() -> dict:
         """The compiled contracts in this session (name, runtime size)."""
         return await _run(driver, "list_contracts")
 
     @server.tool()
-    async def sevm_list_functions(contract: str | None = None) -> dict:
+    async def chasm_list_functions(contract: str | None = None) -> dict:
         """External functions of a contract: signature + 4-byte selector.
         Defaults to the running contract."""
         return await _run(driver, "list_functions", contract)
 
     @server.tool()
-    async def sevm_find_bytes(pattern: str, scope: str = "code", limit: int = 50) -> dict:
+    async def chasm_find_bytes(
+        pattern: str, scope: str = "code", limit: int = 50
+    ) -> dict:
         """Find a hex byte pattern (e.g. '60515255' or '0x5b50505050').
 
         scope=code searches the running contract's bytecode for gadget hunting:
@@ -245,33 +247,33 @@ async def sevm_find_bytes(pattern: str, scope: str = "code", limit: int = 50) ->
     # -- breakpoints -------------------------------------------------------
 
     @server.tool()
-    async def sevm_set_breakpoint(
+    async def chasm_set_breakpoint(
         location: str, condition: str | None = None, temporary: bool = False
     ) -> dict:
         """Break at 'File.sol:LINE', '*0xPC', a function name ('deposit' or
-        'Bank.deposit'), or use sevm_set_opcode_breakpoint for opcodes.
+        'Bank.deposit'), or use chasm_set_opcode_breakpoint for opcodes.
         `condition` is real Solidity evaluated at the location."""
         return await _run(driver, "set_breakpoint", location, condition, temporary)
 
     @server.tool()
-    async def sevm_set_opcode_breakpoint(
+    async def chasm_set_opcode_breakpoint(
         mnemonic: str, condition: str | None = None, temporary: bool = False
     ) -> dict:
         """Break on every occurrence of an opcode, e.g. SSTORE, DELEGATECALL, JUMP."""
         return await _run(driver, "set_opcode_breakpoint", mnemonic, condition, temporary)
 
     @server.tool()
-    async def sevm_list_breakpoints() -> dict:
+    async def chasm_list_breakpoints() -> dict:
         """All breakpoints and watchpoints with their hit counts."""
         return await _run(driver, "list_breakpoints")
 
     @server.tool()
-    async def sevm_delete_breakpoint(id: int) -> dict:
+    async def chasm_delete_breakpoint(id: int) -> dict:
         """Delete breakpoint or watchpoint number `id`."""
         return await _run(driver, "delete_breakpoint", id)
 
     @server.tool()
-    async def sevm_set_watchpoint(expression: str, mode: str = "write") -> dict:
+    async def chasm_set_watchpoint(expression: str, mode: str = "write") -> dict:
         """Break when a storage value is written ('write'), read ('read'), or
         either ('access'). Expression: a state variable, mapping element like
         'balances[0xabc...]', or '*0x40' for a memory word."""
@@ -280,7 +282,7 @@ async def sevm_set_watchpoint(expression: str, mode: str = "write") -> dict:
     # -- mutation & evaluation ---------------------------------------------
 
     @server.tool()
-    async def sevm_evaluate(expression: str, keep: bool = False) -> dict:
+    async def chasm_evaluate(expression: str, keep: bool = False) -> dict:
         """Evaluate real Solidity against the paused frame: state variables,
         mappings, locals, internal functions, keccak256, abi.encode, units
         ('1 ether'). Side effects are discarded unless keep=true (like gdb's
@@ -288,33 +290,33 @@ async def sevm_evaluate(expression: str, keep: bool = False) -> dict:
         return await _run(driver, "evaluate", expression, keep)
 
     @server.tool()
-    async def sevm_set_gas(value: int) -> dict:
+    async def chasm_set_gas(value: int) -> dict:
         """Overwrite the gas meter. If stopped on an out-of-gas error, continuing
         afterwards retries the failed instruction with this gas."""
         return await _run(driver, "set_gas", value)
 
     @server.tool()
-    async def sevm_set_stack_slot(index: int, value: int) -> dict:
+    async def chasm_set_stack_slot(index: int, value: int) -> dict:
         """Rewrite a stack operand (index 0 = top) before its opcode consumes it."""
         return await _run(driver, "set_stack_slot", index, value)
 
     @server.tool()
-    async def sevm_write_memory(offset: int, hex_data: str) -> dict:
+    async def chasm_write_memory(offset: int, hex_data: str) -> dict:
         """Write bytes (hex) into EVM memory at `offset`."""
         return await _run(driver, "write_memory", offset, hex_data)
 
     @server.tool()
-    async def sevm_write_storage(slot: int, value: int) -> dict:
+    async def chasm_write_storage(slot: int, value: int) -> dict:
         """Write a raw 32-byte value to a storage slot of the running contract."""
         return await _run(driver, "write_storage", slot, value)
 
     @server.tool()
-    async def sevm_set_pc(pc: int) -> dict:
+    async def chasm_set_pc(pc: int) -> dict:
         """Move the program counter; JUMPDEST targets only."""
         return await _run(driver, "set_pc", pc)
 
     @server.tool()
-    async def sevm_command(line: str) -> dict:
+    async def chasm_command(line: str) -> dict:
         """Raw gdb-verb passthrough for everything not first-class: `vm.deal(a, 1
         ether)` cheatcodes, Yul like `mstore(0x80, 1)`, `jump 0x108`, `reseat`,
         `watch`, `tbreak`, `x/32xb 0x40`... Returns plain-text lines."""
@@ -323,19 +325,19 @@ async def sevm_command(line: str) -> dict:
     # -- provenance & trace ---------------------------------------------------
 
     @server.tool()
-    async def sevm_set_provenance(enabled: bool) -> dict:
+    async def chasm_set_provenance(enabled: bool) -> dict:
         """Turn per-opcode recording on/off (feeds why_stack and export_trace)."""
         return await _run(driver, "set_provenance", enabled)
 
     @server.tool()
-    async def sevm_why_stack(index: int) -> dict:
+    async def chasm_why_stack(index: int) -> dict:
         """Why does $stack[index] hold this value? Traces it backward through the
         recording to constants, calldata windows, MSTORE/SSTORE chains, and the
         frame-entry slots — the question behind "which entry slot fed operand N"."""
         return await _run(driver, "why_stack", index)
 
     @server.tool()
-    async def sevm_export_trace(
+    async def chasm_export_trace(
         path: str | None = None, offset: int = 0, limit: int = 500
     ) -> dict:
         """Export the recording as anvil/geth structLog JSON (the
@@ -346,7 +348,7 @@ async def sevm_export_trace(
     # -- parity ----------------------------------------------------------------
 
     @server.tool()
-    async def sevm_check_parity(reference_hex: str, contract: str | None = None) -> dict:
+    async def chasm_check_parity(reference_hex: str, contract: str | None = None) -> dict:
         """Compare a compiled runtime against the deployed bytecode (explorer
         hex). Ignores the metadata tail and immutable values; reports the first
         divergence — past it, every pc and gadget offset describes a different
diff --git a/src/sevm/provider.py b/src/chasm_debugger/provider.py
similarity index 99%
rename from src/sevm/provider.py
rename to src/chasm_debugger/provider.py
index 5ca5d37..23480b8 100644
--- a/src/sevm/provider.py
+++ b/src/chasm_debugger/provider.py
@@ -53,7 +53,7 @@ def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
 
     def _dispatch(self, method: str, params: list[Any]) -> Any:
         if method == "web3_clientVersion":
-            return "sevm-revm/0.1.0"
+            return "chasm-revm/0.1.0"
         if method == "net_version":
             return str(self.session._chain.read_chain_id())
         if method == "eth_chainId":
@@ -263,4 +263,4 @@ def _hex_bytes(value: Any) -> str:
 
 
 def _block_hash() -> str:
-    return "0x" + keccak(b"sevm-revm-block").hex()
+    return "0x" + keccak(b"chasm-revm-block").hex()
diff --git a/src/sevm/revm_server.py b/src/chasm_debugger/revm_server.py
similarity index 100%
rename from src/sevm/revm_server.py
rename to src/chasm_debugger/revm_server.py
diff --git a/src/sevm/session/__init__.py b/src/chasm_debugger/session/__init__.py
similarity index 100%
rename from src/sevm/session/__init__.py
rename to src/chasm_debugger/session/__init__.py
diff --git a/src/sevm/session/code.py b/src/chasm_debugger/session/code.py
similarity index 100%
rename from src/sevm/session/code.py
rename to src/chasm_debugger/session/code.py
diff --git a/src/sevm/session/events.py b/src/chasm_debugger/session/events.py
similarity index 100%
rename from src/sevm/session/events.py
rename to src/chasm_debugger/session/events.py
diff --git a/src/sevm/session/framelocals.py b/src/chasm_debugger/session/framelocals.py
similarity index 100%
rename from src/sevm/session/framelocals.py
rename to src/chasm_debugger/session/framelocals.py
diff --git a/src/sevm/session/provenance.py b/src/chasm_debugger/session/provenance.py
similarity index 100%
rename from src/sevm/session/provenance.py
rename to src/chasm_debugger/session/provenance.py
diff --git a/src/sevm/session/revm.py b/src/chasm_debugger/session/revm.py
similarity index 99%
rename from src/sevm/session/revm.py
rename to src/chasm_debugger/session/revm.py
index ca5226e..4be46e1 100644
--- a/src/sevm/session/revm.py
+++ b/src/chasm_debugger/session/revm.py
@@ -339,7 +339,7 @@ def runner() -> None:
                 self.finished = True
                 self.armed = False
 
-        self._thread = threading.Thread(target=runner, name="sevm-revm", daemon=True)
+        self._thread = threading.Thread(target=runner, name="chasm-revm", daemon=True)
         self._thread.start()
 
     def wait(self, timeout: float | None = None) -> Any:
@@ -378,7 +378,7 @@ def detach(self, timeout: float = 10.0) -> None:
     def restart(self, argv: list[str] | None = None, timeout: float = 120.0) -> Any:
         if self._restart_factory is None:
             raise SessionError(
-                "no restart target; the session was not started by `sevm run`"
+                "no restart target; the session was not started by `chasm run`"
             )
         if self._thread is not None and not self.finished:
             self._cmd_q.put(Resume(mode=StepMode.RUN, detach=True))
diff --git a/src/sevm/session/snapshots.py b/src/chasm_debugger/session/snapshots.py
similarity index 100%
rename from src/sevm/session/snapshots.py
rename to src/chasm_debugger/session/snapshots.py
diff --git a/src/sevm/srcmap.py b/src/chasm_debugger/srcmap.py
similarity index 100%
rename from src/sevm/srcmap.py
rename to src/chasm_debugger/srcmap.py
diff --git a/src/sevm/tui/__init__.py b/src/chasm_debugger/tui/__init__.py
similarity index 86%
rename from src/sevm/tui/__init__.py
rename to src/chasm_debugger/tui/__init__.py
index 6002251..a263e47 100644
--- a/src/sevm/tui/__init__.py
+++ b/src/chasm_debugger/tui/__init__.py
@@ -5,5 +5,5 @@
 panes.py    the panes themselves (source, stack, memory, storage, ...)
 layout.py   cell/row/page construction shared by the panes
 opcodes.py  opcode hints and stack-operand labels
-theme.py    the colour palette, mirrored in sevm.tcss
+theme.py    the colour palette, mirrored in chasm.tcss
 """
diff --git a/src/sevm/tui/app.py b/src/chasm_debugger/tui/app.py
similarity index 98%
rename from src/sevm/tui/app.py
rename to src/chasm_debugger/tui/app.py
index c36b39d..9a263a0 100644
--- a/src/sevm/tui/app.py
+++ b/src/chasm_debugger/tui/app.py
@@ -39,9 +39,9 @@
     VariablesPane,
 )
 
-CSS_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "sevm.tcss")
+CSS_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "chasm.tcss")
 
-WELCOME = """[bold]sevm[/bold]  Solidity/EVM debugger on REVM"""
+WELCOME = """[bold]Chasm[/bold]  Solidity/EVM debugger on REVM"""
 
 
 class CommandDone(Message):
@@ -61,9 +61,9 @@ def __init__(self, payload: dict[str, Any]) -> None:
         self.payload = payload
 
 
-class SevmApp(App):
+class ChasmApp(App):
     CSS_PATH = CSS_PATH
-    TITLE = "sevm"
+    TITLE = "Chasm"
 
     BINDINGS = [
         Binding("f5", "cmd('continue')", "continue", show=True),
@@ -132,7 +132,7 @@ def compose(self) -> ComposeResult:
                 yield VariablesPane(id="variables")
                 yield StoragePane(id="storage")
         yield CommandLog(id="log")
-        yield Input(placeholder="(sevm) type a gdb command, or `help`", id="prompt")
+        yield Input(placeholder="(chasm) type a gdb command, or `help`", id="prompt")
 
     def on_mount(self) -> None:
         log = self.query_one("#log", CommandLog)
@@ -201,7 +201,7 @@ def _on_command_done(self, message: CommandDone) -> None:
         self.busy = False
         log = self.query_one("#log", CommandLog)
         if message.echo:
-            log.write(f"[bold green](sevm)[/bold green] {_escape(message.echo)}")
+            log.write(f"[bold green](chasm)[/bold green] {_escape(message.echo)}")
         for line in message.result.lines:
             log.write(line)
         if message.result.notice:
diff --git a/src/sevm/tui/sevm.tcss b/src/chasm_debugger/tui/chasm.tcss
similarity index 99%
rename from src/sevm/tui/sevm.tcss
rename to src/chasm_debugger/tui/chasm.tcss
index c33d01c..80fb47b 100644
--- a/src/sevm/tui/sevm.tcss
+++ b/src/chasm_debugger/tui/chasm.tcss
@@ -1,4 +1,4 @@
-/* sevm layout.
+/* chasm layout.
    One accent per data class, defined in theme.py and mirrored here in the borders,
    so a pane's colour always means the same thing no matter which pane you look at. */
 
diff --git a/src/sevm/tui/layout.py b/src/chasm_debugger/tui/layout.py
similarity index 100%
rename from src/sevm/tui/layout.py
rename to src/chasm_debugger/tui/layout.py
diff --git a/src/sevm/tui/opcodes.py b/src/chasm_debugger/tui/opcodes.py
similarity index 100%
rename from src/sevm/tui/opcodes.py
rename to src/chasm_debugger/tui/opcodes.py
diff --git a/src/sevm/tui/pane.py b/src/chasm_debugger/tui/pane.py
similarity index 99%
rename from src/sevm/tui/pane.py
rename to src/chasm_debugger/tui/pane.py
index 700037c..4563e3e 100644
--- a/src/sevm/tui/pane.py
+++ b/src/chasm_debugger/tui/pane.py
@@ -23,7 +23,7 @@ class PaneBody(Static):
     Selection is deliberately *not* implemented here. Mouse reporting is off, so the
     terminal/tmux handles dragging like any other program (system clipboard, tmux
     copy-mode, macOS Cmd+C). An in-app implementation could only copy via OSC 52, which
-    tmux swallows unless `set-clipboard` is on, and could only paste back into sevm.
+    tmux swallows unless `set-clipboard` is on, and could only paste back into Chasm.
     """
 
 
diff --git a/src/sevm/tui/panes.py b/src/chasm_debugger/tui/panes.py
similarity index 100%
rename from src/sevm/tui/panes.py
rename to src/chasm_debugger/tui/panes.py
diff --git a/src/sevm/tui/theme.py b/src/chasm_debugger/tui/theme.py
similarity index 96%
rename from src/sevm/tui/theme.py
rename to src/chasm_debugger/tui/theme.py
index c697ad9..4e86f65 100644
--- a/src/sevm/tui/theme.py
+++ b/src/chasm_debugger/tui/theme.py
@@ -7,7 +7,7 @@
 
 Textual parses these as CSS, not Rich's names ("bright_yellow", "grey23" are Rich
 spellings Textual rejects), and a rejected style is silently dropped rather than raised.
-`sevm.tcss` mirrors them in the pane borders.
+`chasm.tcss` mirrors them in the pane borders.
 """
 
 from __future__ import annotations
diff --git a/tests/conftest.py b/tests/conftest.py
index 8ab3124..ee95202 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -4,7 +4,7 @@
 one would make failures order-dependent. Compilation is cached process-wide (see
 `harness.project`) since solc is the slow part.
 
-The rest stands up the dependency-install path: sevm fetches forge-std from its real
+The rest stands up the dependency-install path: chasm fetches forge-std from its real
 repository, so the suite builds a local git repo from `fixtures/forge_std_fake/` and points
 the resolver at it over `file://`.
 
@@ -23,7 +23,7 @@
 from eth_utils import function_signature_to_4byte_selector
 from harness import Debugger, bank_fixture, deploy, make_web3, project
 
-from sevm import libs
+from chasm_debugger import libs
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 FIXTURES = os.path.join(HERE, "fixtures")
@@ -34,11 +34,11 @@
 
 
 def pytest_collection_modifyitems(config, items):
-    """Skip `network`-marked tests unless SEVM_NETWORK_TESTS=1 asks for the real thing."""
-    if os.environ.get("SEVM_NETWORK_TESTS") == "1":
+    """Skip `network`-marked tests unless CHASM_NETWORK_TESTS=1 asks for the real thing."""
+    if os.environ.get("CHASM_NETWORK_TESTS") == "1":
         return
     skip = pytest.mark.skip(
-        reason="set SEVM_NETWORK_TESTS=1 to run tests that hit the network"
+        reason="set CHASM_NETWORK_TESTS=1 to run tests that hit the network"
     )
     for item in items:
         if "network" in item.keywords:
@@ -49,7 +49,7 @@ def pytest_collection_modifyitems(config, items):
 def isolated_cache(tmp_path, monkeypatch):
     """Point the user-level cache at tmp for every test.
 
-    Without this a test would read the developer's real `~/.cache/sevm/solc-versions.json`
+    Without this a test would read the developer's real `~/.cache/chasm/solc-versions.json`
     and quietly ignore its own mocked release list, and the suite would leave entries
     behind on the machine that ran it.
     """
@@ -64,9 +64,9 @@ def _git(*args: str, cwd: str) -> None:
         capture_output=True,
         env={
             **os.environ,
-            "GIT_AUTHOR_NAME": "sevm tests",
+            "GIT_AUTHOR_NAME": "chasm tests",
             "GIT_AUTHOR_EMAIL": "tests@example.com",
-            "GIT_COMMITTER_NAME": "sevm tests",
+            "GIT_COMMITTER_NAME": "chasm tests",
             "GIT_COMMITTER_EMAIL": "tests@example.com",
         },
     )
@@ -114,7 +114,7 @@ def solo_root(tmp_path_factory, local_forge_std) -> str:
 
 @pytest.fixture(scope="session")
 def solo_project(solo_root):
-    from sevm.foundry import compile_test
+    from chasm_debugger.foundry import compile_test
 
     return compile_test(os.path.join(solo_root, "AllCheats.t.sol"), solo_root)
 
@@ -128,7 +128,7 @@ def token_root(tmp_path_factory) -> str:
 
 @pytest.fixture(scope="session")
 def token_project(token_root):
-    from sevm.compile import DEFAULT_SOLC_VERSION, compile_foundry_project
+    from chasm_debugger.compile import DEFAULT_SOLC_VERSION, compile_foundry_project
 
     return compile_foundry_project(
         token_root,
@@ -141,7 +141,7 @@ def token_project(token_root):
 @pytest.fixture(scope="session")
 def failing_project(tmp_path_factory, local_forge_std):
     """A standalone test whose assertion fails, to prove failures surface as reverts."""
-    from sevm.foundry import compile_test, prepare_project
+    from chasm_debugger.foundry import compile_test, prepare_project
 
     root = str(tmp_path_factory.mktemp("failing"))
     sol = os.path.join(root, "Demo.t.sol")
@@ -223,7 +223,7 @@ def locals_contract(proj):
 @pytest.fixture
 def fake_clipboard(monkeypatch):
     """Capture what would reach the system clipboard, without touching it."""
-    from sevm import clipboard
+    from chasm_debugger import clipboard
 
     captured: list = []
 
diff --git a/tests/fixtures/forge_std_fake/src/Test.sol b/tests/fixtures/forge_std_fake/src/Test.sol
index 47914d7..39d79c5 100644
--- a/tests/fixtures/forge_std_fake/src/Test.sol
+++ b/tests/fixtures/forge_std_fake/src/Test.sol
@@ -5,7 +5,7 @@ import {Vm} from "./Vm.sol";
 import {console} from "./console.sol";
 
 // Mirrors real forge-std: every assertion is a guard plus a `vm.assert*` cheatcode call,
-// so the suite exercises sevm's assertion engine rather than plain Solidity requires.
+// so the suite exercises chasm's assertion engine rather than plain Solidity requires.
 abstract contract Test {
     Vm internal constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
 
diff --git a/tests/fixtures/forge_std_fake/src/Vm.sol b/tests/fixtures/forge_std_fake/src/Vm.sol
index f27269b..74818c8 100644
--- a/tests/fixtures/forge_std_fake/src/Vm.sol
+++ b/tests/fixtures/forge_std_fake/src/Vm.sol
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.6.2 <0.9.0;
 
-// Stand-in for forge-std's Vm, shaped like the real one: the cheats sevm implements plus
+// Stand-in for forge-std's Vm, shaped like the real one: the cheats chasm implements plus
 // the assertion overloads Test.sol below delegates to. Only used by the test suite, so it
 // stays small; the real interface is fetched from foundry-rs/forge-std at run time.
 interface Vm {
diff --git a/tests/fixtures/forge_std_fake/src/console.sol b/tests/fixtures/forge_std_fake/src/console.sol
index c02dd64..58b7a12 100644
--- a/tests/fixtures/forge_std_fake/src/console.sol
+++ b/tests/fixtures/forge_std_fake/src/console.sol
@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.4.22 <0.9.0;
 
-// Minimal `console` bundled with sevm. Each `log` overload ABI-encodes a `log(...)` call
+// Minimal `console` bundled with chasm_debugger. Each `log` overload ABI-encodes a `log(...)` call
 // and forwards it via staticcall to the console address
-// (0x000000000000000000636F6e736F6c652e6c6f67, the ASCII of "console.log"). sevm's engine
+// (0x000000000000000000636F6e736F6c652e6c6f67, the ASCII of "console.log"). chasm's engine
 // intercepts that address, decodes the payload, and prints it. On a real EVM the call hits
 // empty code and is a no-op, exactly like forge-std's console.
 library console {
diff --git a/tests/fixtures/forge_std_fake/test/Unlinked.t.sol b/tests/fixtures/forge_std_fake/test/Unlinked.t.sol
index ff167fa..c0d13b1 100644
--- a/tests/fixtures/forge_std_fake/test/Unlinked.t.sol
+++ b/tests/fixtures/forge_std_fake/test/Unlinked.t.sol
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.6.2 <0.9.0;
 
-// A library's own tests must never reach solc through sevm: this one compiles to an
+// A library's own tests must never reach solc through chasm: this one compiles to an
 // unlinked `__$...$__` placeholder, which has no debuggable artifact. If the import
 // closure ever widens to a library's test/ tree, the suite notices here.
 library Unlinkable {
diff --git a/tests/foundry_project/lib/forge-std/src/Test.sol b/tests/foundry_project/lib/forge-std/src/Test.sol
index 78bfdc7..b535447 100644
--- a/tests/foundry_project/lib/forge-std/src/Test.sol
+++ b/tests/foundry_project/lib/forge-std/src/Test.sol
@@ -4,12 +4,12 @@ pragma solidity >=0.6.2 <0.9.0;
 import {Vm} from "./Vm.sol";
 import {console} from "./console.sol";
 
-// Minimal forge-std `Test` bundled with sevm. Enough to write and debug a standalone test:
+// Minimal forge-std `Test` bundled with chasm_debugger. Enough to write and debug a standalone test:
 // the `vm` cheatcode handle and revert-on-failure assertions.
 //
 // NOTE: unlike real forge-std, these assertions REVERT on failure rather than recording a
 // `failed` flag and continuing. That is deliberate for a debugger: a failed assertion stops
-// the transaction on the spot with a clear reason. Point sevm at a real Foundry project to
+// the transaction on the spot with a clear reason. Point chasm at a real Foundry project to
 // get real forge-std semantics.
 abstract contract Test {
     Vm internal constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
diff --git a/tests/foundry_project/lib/forge-std/src/Vm.sol b/tests/foundry_project/lib/forge-std/src/Vm.sol
index 84855dc..d73d46f 100644
--- a/tests/foundry_project/lib/forge-std/src/Vm.sol
+++ b/tests/foundry_project/lib/forge-std/src/Vm.sol
@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.6.2 <0.9.0;
 
-// Minimal forge-std `Vm` interface bundled with sevm.
+// Minimal forge-std `Vm` interface bundled with chasm_debugger.
 //
-// This is NOT the full forge-std interface. It declares the cheatcodes sevm's debugger
-// implements (see src/sevm/cheatcodes.py), plus a few common signatures so that a
+// This is NOT the full forge-std interface. It declares the cheatcodes chasm's debugger
+// implements (see src/chasm_debugger/cheatcodes.py), plus a few common signatures so that a
 // standalone `Test.sol` still compiles. Any cheatcode declared here but not implemented by
-// the engine reverts at runtime with "sevm: unimplemented cheatcode", which is a clearer
+// the engine reverts at runtime with "chasm: unimplemented cheatcode", which is a clearer
 // signal than a compile error.
 //
 // The cheatcode address is the last 20 bytes of keccak256("hevm cheat code").
diff --git a/tests/foundry_project/lib/forge-std/src/console.sol b/tests/foundry_project/lib/forge-std/src/console.sol
index c02dd64..58b7a12 100644
--- a/tests/foundry_project/lib/forge-std/src/console.sol
+++ b/tests/foundry_project/lib/forge-std/src/console.sol
@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.4.22 <0.9.0;
 
-// Minimal `console` bundled with sevm. Each `log` overload ABI-encodes a `log(...)` call
+// Minimal `console` bundled with chasm_debugger. Each `log` overload ABI-encodes a `log(...)` call
 // and forwards it via staticcall to the console address
-// (0x000000000000000000636F6e736F6c652e6c6f67, the ASCII of "console.log"). sevm's engine
+// (0x000000000000000000636F6e736F6c652e6c6f67, the ASCII of "console.log"). chasm's engine
 // intercepts that address, decodes the payload, and prints it. On a real EVM the call hits
 // empty code and is a no-op, exactly like forge-std's console.
 library console {
diff --git a/tests/foundry_solo/foundry.toml b/tests/foundry_solo/foundry.toml
index 774639a..7ea83ab 100644
--- a/tests/foundry_solo/foundry.toml
+++ b/tests/foundry_solo/foundry.toml
@@ -2,5 +2,5 @@
 src = "src"
 test = "test"
 libs = ["lib"]
-# sevm forces the optimizer OFF for debuggable builds regardless of this file.
+# chasm forces the optimizer OFF for debuggable builds regardless of this file.
 optimizer = false
diff --git a/tests/harness.py b/tests/harness.py
index 6426825..e42f9f1 100644
--- a/tests/harness.py
+++ b/tests/harness.py
@@ -12,12 +12,12 @@
 from eth_account import Account
 from web3 import Web3
 
-from sevm.commands import CommandProcessor
-from sevm.compile import DEFAULT_SOLC_VERSION, Project, compile_project
-from sevm.evaluate import Evaluator, make_eval_hook
-from sevm.provider import RevmProvider
-from sevm.session import DebugSession, StepMode
-from sevm.srcmap import build_line_indexes
+from chasm_debugger.commands import CommandProcessor
+from chasm_debugger.compile import DEFAULT_SOLC_VERSION, Project, compile_project
+from chasm_debugger.evaluate import Evaluator, make_eval_hook
+from chasm_debugger.provider import RevmProvider
+from chasm_debugger.session import DebugSession, StepMode
+from chasm_debugger.srcmap import build_line_indexes
 
 # Generous: a stuck VM thread should fail the test, not hang the suite.
 TIMEOUT = 30.0
@@ -78,7 +78,7 @@ def bank_fixture(value_ether: int = 1) -> tuple[Web3, Project, Any, Any, Any]:
     proj = project()
     w3 = make_web3(proj)
     bank = deploy(
-        w3, proj, "Bank", "sevm-bank", value_wei=w3.to_wei(value_ether, "ether")
+        w3, proj, "Bank", "chasm-bank", value_wei=w3.to_wei(value_ether, "ether")
     )
     callee = deploy(w3, proj, "Callee")
     alice = funded_account(w3)
@@ -95,7 +95,7 @@ def __init__(self, proj, txfn, **session_kwargs):
         self.evaluator = Evaluator(proj)
         self.session.set_eval_hook(make_eval_hook(self.evaluator))
         self.commands = CommandProcessor(self.session, self.evaluator)
-        # Bind a restart target so `reset` / `run` work under test as via `sevm run`.
+        # Bind a restart target so `reset` / `run` work under test as via `chasm run`.
         self.session.set_restart_factory(lambda argv: txfn, [])
         self.session.start(txfn)
         self.first = self.session.wait(timeout=TIMEOUT)
diff --git a/tests/test_artifacts.py b/tests/test_artifacts.py
index e006d12..fac38b8 100644
--- a/tests/test_artifacts.py
+++ b/tests/test_artifacts.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from sevm.compile.model import _strip_metadata
+from chasm_debugger.compile.model import _strip_metadata
 
 
 def test_project_compiles_both_contracts(proj):
diff --git a/tests/test_assembly.py b/tests/test_assembly.py
index 0e5ecc4..9e90971 100644
--- a/tests/test_assembly.py
+++ b/tests/test_assembly.py
@@ -6,8 +6,8 @@
 
 
 def test_assembly_parses_literals_and_nesting():
-    from sevm.assembly import parse
-    from sevm.assembly.parser import Call, Literal
+    from chasm_debugger.assembly import parse
+    from chasm_debugger.assembly.parser import Call, Literal
 
     (node,) = parse("sstore(3, add(sload(3), 1))")
     assert isinstance(node, Call) and node.name == "sstore"
@@ -18,7 +18,7 @@ def test_assembly_parses_literals_and_nesting():
 
 
 def test_assembly_parses_hex_units_bools_and_strings():
-    from sevm.assembly import parse
+    from chasm_debugger.assembly import parse
 
     assert parse("mstore(0x80, 0xdeadBEEF)")[0].args[1].value == 0xDEADBEEF
     assert parse("mstore(0x80, 1 ether)")[0].args[1].value == 10**18
@@ -31,7 +31,7 @@ def test_assembly_parses_hex_units_bools_and_strings():
 
 
 def test_assembly_parses_several_statements():
-    from sevm.assembly import parse
+    from chasm_debugger.assembly import parse
 
     nodes = parse("mstore(0x80, 1); mstore8(0xa0, 0x61); mload(0x80)")
     assert [n.name for n in nodes] == ["mstore", "mstore8", "mload"]
@@ -40,7 +40,7 @@ def test_assembly_parses_several_statements():
 
 
 def test_assembly_rejects_bad_input_with_a_reason():
-    from sevm.assembly import AsmError, parse
+    from chasm_debugger.assembly import AsmError, parse
 
     cases = {
         "mstore(1)": "takes 2 argument",
@@ -61,7 +61,7 @@ def test_assembly_rejects_bad_input_with_a_reason():
 
 
 def test_assembly_head_detection_leaves_solidity_alone():
-    from sevm.assembly import has_builtin_head, lexes
+    from chasm_debugger.assembly import has_builtin_head, lexes
 
     assert has_builtin_head("mstore(0x80, 1)")
     assert has_builtin_head("REVERT(0, 0)")  # blocked names claim the line too
@@ -162,7 +162,7 @@ def test_assembly_failure_does_not_disturb_the_frame(deposit_debugger):
 
 
 def test_assembly_help_is_generated_from_the_builtin_table(deposit_debugger):
-    from sevm.assembly import listing
+    from chasm_debugger.assembly import listing
 
     body = " ".join(deposit_debugger.run("help assembly").lines)
     for builtin in listing():
diff --git a/tests/test_breakpoints.py b/tests/test_breakpoints.py
index 0f359e1..e502c33 100644
--- a/tests/test_breakpoints.py
+++ b/tests/test_breakpoints.py
@@ -9,11 +9,11 @@
     line_of,
 )
 
-from sevm.breakpoints import BreakpointSet
-from sevm.decode import (
+from chasm_debugger.breakpoints import BreakpointSet
+from chasm_debugger.decode import (
     StorageDecoder,
 )
-from sevm.session import Finished, Paused, StepMode
+from chasm_debugger.session import Finished, Paused, StepMode
 
 
 def test_line_breakpoint_stops_there(deposit_debugger):
diff --git a/tests/test_cache.py b/tests/test_cache.py
index 6b3efe1..fb0a4a4 100644
--- a/tests/test_cache.py
+++ b/tests/test_cache.py
@@ -15,8 +15,8 @@
 import pytest
 from conftest import HERE
 
-from sevm import cache
-from sevm.compile import compile_foundry_project, solc
+from chasm_debugger import cache
+from chasm_debugger.compile import compile_foundry_project, solc
 
 
 @pytest.fixture
@@ -93,7 +93,7 @@ def test_second_build_never_reaches_solc(root, monkeypatch):
 
 def test_cache_lives_in_the_foundry_cache_dir(root):
     build(root)
-    entries = os.listdir(os.path.join(root, "cache", "sevm"))
+    entries = os.listdir(os.path.join(root, "cache", "chasm"))
     assert "index.json" in entries
     assert any(name.endswith(".json.gz") for name in entries)
 
@@ -117,7 +117,7 @@ def test_no_cache_neither_reads_nor_writes(root, monkeypatch):
 
 
 def test_env_switch_disables_the_cache(root, monkeypatch):
-    monkeypatch.setenv("SEVM_NO_CACHE", "1")
+    monkeypatch.setenv("CHASM_NO_CACHE", "1")
     build(root)
     assert not os.path.exists(os.path.join(root, "cache"))
     assert not os.path.exists(os.path.join(root, "out"))
@@ -141,12 +141,12 @@ def test_different_settings_are_a_different_unit(root, monkeypatch, changed):
 
 
 # ==================================================================
-# out/sevm artifacts
+# out/chasm artifacts
 # ==================================================================
 
 
 def read_artifact(root: str, source: str, name: str) -> dict:
-    path = os.path.join(root, "out", "sevm", source, f"{name}.json")
+    path = os.path.join(root, "out", "chasm", source, f"{name}.json")
     with open(path, encoding="utf-8") as fh:
         return json.load(fh)
 
@@ -205,7 +205,7 @@ def test_artifacts_follow_the_out_key_in_foundry_toml(root):
 
     build(root)
     assert os.path.isfile(
-        os.path.join(root, "artifacts", "sevm", "Token.sol", "Token.json")
+        os.path.join(root, "artifacts", "chasm", "Token.sol", "Token.json")
     )
 
 
@@ -213,7 +213,7 @@ def test_artifacts_are_rewritten_when_the_out_tree_is_deleted(root):
     build(root)
     shutil.rmtree(os.path.join(root, "out"))
     build(root)  # a cache hit still restores what was removed
-    assert os.path.isfile(os.path.join(root, "out", "sevm", "Token.sol", "Token.json"))
+    assert os.path.isfile(os.path.join(root, "out", "chasm", "Token.sol", "Token.json"))
 
 
 def test_an_edit_reaches_the_written_artifact(root):
@@ -288,7 +288,7 @@ def test_merge_refuses_a_shifted_source_id():
 
 def test_a_truncated_unit_only_costs_a_recompile(root, monkeypatch):
     build(root)
-    directory = os.path.join(root, "cache", "sevm")
+    directory = os.path.join(root, "cache", "chasm")
     unit = next(n for n in os.listdir(directory) if n.endswith(".json.gz"))
     with open(os.path.join(directory, unit), "wb") as fh:
         fh.write(gzip.compress(b'{"sources": {"trunc'))
@@ -301,7 +301,7 @@ def test_a_truncated_unit_only_costs_a_recompile(root, monkeypatch):
 
 def test_a_corrupt_index_only_costs_a_recompile(root, monkeypatch):
     build(root)
-    index = os.path.join(root, "cache", "sevm", "index.json")
+    index = os.path.join(root, "cache", "chasm", "index.json")
     with open(index, "w", encoding="utf-8") as fh:
         fh.write("{not json")
     edit_token(root)
diff --git a/tests/test_cheatcodes.py b/tests/test_cheatcodes.py
index 63e4d83..b55d800 100644
--- a/tests/test_cheatcodes.py
+++ b/tests/test_cheatcodes.py
@@ -1,7 +1,7 @@
 """Every registered cheatcode, exercised once.
 
 Expected values here are not invented: each was taken from a run of the same call under
-real `forge test` against forge-std, so this file is sevm's differential record of Foundry
+real `forge test` against forge-std, so this file is chasm's differential record of Foundry
 behaviour. `test_every_cheat_is_exercised` fails if a cheat is added without a case, which
 is what keeps that record complete.
 
@@ -19,7 +19,7 @@
 from eth_abi import encode as abi_encode
 from eth_utils import function_signature_to_4byte_selector
 
-from sevm.cheatcodes import (
+from chasm_debugger.cheatcodes import (
     CheatArg,
     CheatError,
     CheatState,
@@ -142,59 +142,59 @@ def test_pure_cheats(signature, args, expected):
 # ==================================================================
 
 ENV_VALUES = {
-    "SEVM_UINT": "42",
-    "SEVM_UINT_HEX": "0xff",
-    "SEVM_INT": "-5",
-    "SEVM_BOOL": "true",
-    "SEVM_BOOL_ONE": "1",
-    "SEVM_ADDR": ALICE,
-    "SEVM_B32": "0x" + "00" * 28 + "deadbeef",
-    "SEVM_BYTES": "0xdeadbeef",
-    "SEVM_STR": "hello",
-    "SEVM_UINTS": "1,2,3",
-    "SEVM_INTS": "-1,2",
-    "SEVM_BOOLS": "true,false",
-    "SEVM_ADDRS": f"{ALICE},{BOB}",
-    "SEVM_B32S": "0x" + "00" * 31 + "01,0x" + "00" * 31 + "02",
-    "SEVM_BYTESS": "0xdead,0xbeef",
-    "SEVM_STRS": "a,b",
+    "CHASM_UINT": "42",
+    "CHASM_UINT_HEX": "0xff",
+    "CHASM_INT": "-5",
+    "CHASM_BOOL": "true",
+    "CHASM_BOOL_ONE": "1",
+    "CHASM_ADDR": ALICE,
+    "CHASM_B32": "0x" + "00" * 28 + "deadbeef",
+    "CHASM_BYTES": "0xdeadbeef",
+    "CHASM_STR": "hello",
+    "CHASM_UINTS": "1,2,3",
+    "CHASM_INTS": "-1,2",
+    "CHASM_BOOLS": "true,false",
+    "CHASM_ADDRS": f"{ALICE},{BOB}",
+    "CHASM_B32S": "0x" + "00" * 31 + "01,0x" + "00" * 31 + "02",
+    "CHASM_BYTESS": "0xdead,0xbeef",
+    "CHASM_STRS": "a,b",
 }
 
 ENV_CASES: list[tuple[str, list, tuple | None]] = [
-    ("envUint(string)", ["SEVM_UINT"], (42,)),
-    ("envInt(string)", ["SEVM_INT"], (-5,)),
-    ("envBool(string)", ["SEVM_BOOL"], (True,)),
-    ("envAddress(string)", ["SEVM_ADDR"], (ALICE,)),
-    ("envBytes32(string)", ["SEVM_B32"], (bytes.fromhex("00" * 28 + "deadbeef"),)),
-    ("envBytes(string)", ["SEVM_BYTES"], (b"\xde\xad\xbe\xef",)),
-    ("envString(string)", ["SEVM_STR"], ("hello",)),
-    ("envExists(string)", ["SEVM_UINT"], (True,)),
-    ("envUint(string,string)", ["SEVM_UINTS", ","], ((1, 2, 3),)),
-    ("envInt(string,string)", ["SEVM_INTS", ","], ((-1, 2),)),
-    ("envBool(string,string)", ["SEVM_BOOLS", ","], ((True, False),)),
-    ("envAddress(string,string)", ["SEVM_ADDRS", ","], ((ALICE, BOB),)),
+    ("envUint(string)", ["CHASM_UINT"], (42,)),
+    ("envInt(string)", ["CHASM_INT"], (-5,)),
+    ("envBool(string)", ["CHASM_BOOL"], (True,)),
+    ("envAddress(string)", ["CHASM_ADDR"], (ALICE,)),
+    ("envBytes32(string)", ["CHASM_B32"], (bytes.fromhex("00" * 28 + "deadbeef"),)),
+    ("envBytes(string)", ["CHASM_BYTES"], (b"\xde\xad\xbe\xef",)),
+    ("envString(string)", ["CHASM_STR"], ("hello",)),
+    ("envExists(string)", ["CHASM_UINT"], (True,)),
+    ("envUint(string,string)", ["CHASM_UINTS", ","], ((1, 2, 3),)),
+    ("envInt(string,string)", ["CHASM_INTS", ","], ((-1, 2),)),
+    ("envBool(string,string)", ["CHASM_BOOLS", ","], ((True, False),)),
+    ("envAddress(string,string)", ["CHASM_ADDRS", ","], ((ALICE, BOB),)),
     (
         "envBytes32(string,string)",
-        ["SEVM_B32S", ","],
+        ["CHASM_B32S", ","],
         ((B32_ONE, (2).to_bytes(32, "big")),),
     ),
-    ("envBytes(string,string)", ["SEVM_BYTESS", ","], ((b"\xde\xad", b"\xbe\xef"),)),
-    ("envString(string,string)", ["SEVM_STRS", ","], (("a", "b"),)),
+    ("envBytes(string,string)", ["CHASM_BYTESS", ","], ((b"\xde\xad", b"\xbe\xef"),)),
+    ("envString(string,string)", ["CHASM_STRS", ","], (("a", "b"),)),
     # envOr, on a miss: the caller's default comes straight back
-    ("envOr(string,uint256)", ["SEVM_MISSING", 7], (7,)),
-    ("envOr(string,int256)", ["SEVM_MISSING", -7], (-7,)),
-    ("envOr(string,bool)", ["SEVM_MISSING", True], (True,)),
-    ("envOr(string,address)", ["SEVM_MISSING", ALICE], (ALICE,)),
-    ("envOr(string,bytes32)", ["SEVM_MISSING", B32_ONE], (B32_ONE,)),
-    ("envOr(string,bytes)", ["SEVM_MISSING", b"\x01"], (b"\x01",)),
-    ("envOr(string,string)", ["SEVM_MISSING", "fallback"], ("fallback",)),
-    ("envOr(string,string,uint256[])", ["SEVM_MISSING", ",", [4, 5]], ((4, 5),)),
-    ("envOr(string,string,int256[])", ["SEVM_MISSING", ",", [-4]], ((-4,),)),
-    ("envOr(string,string,bool[])", ["SEVM_MISSING", ",", [True]], ((True,),)),
-    ("envOr(string,string,address[])", ["SEVM_MISSING", ",", [ALICE]], ((ALICE,),)),
-    ("envOr(string,string,bytes32[])", ["SEVM_MISSING", ",", [B32_ONE]], ((B32_ONE,),)),
-    ("envOr(string,string,bytes[])", ["SEVM_MISSING", ",", [b"\xaa"]], ((b"\xaa",),)),
-    ("envOr(string,string,string[])", ["SEVM_MISSING", ",", ["z"]], (("z",),)),
+    ("envOr(string,uint256)", ["CHASM_MISSING", 7], (7,)),
+    ("envOr(string,int256)", ["CHASM_MISSING", -7], (-7,)),
+    ("envOr(string,bool)", ["CHASM_MISSING", True], (True,)),
+    ("envOr(string,address)", ["CHASM_MISSING", ALICE], (ALICE,)),
+    ("envOr(string,bytes32)", ["CHASM_MISSING", B32_ONE], (B32_ONE,)),
+    ("envOr(string,bytes)", ["CHASM_MISSING", b"\x01"], (b"\x01",)),
+    ("envOr(string,string)", ["CHASM_MISSING", "fallback"], ("fallback",)),
+    ("envOr(string,string,uint256[])", ["CHASM_MISSING", ",", [4, 5]], ((4, 5),)),
+    ("envOr(string,string,int256[])", ["CHASM_MISSING", ",", [-4]], ((-4,),)),
+    ("envOr(string,string,bool[])", ["CHASM_MISSING", ",", [True]], ((True,),)),
+    ("envOr(string,string,address[])", ["CHASM_MISSING", ",", [ALICE]], ((ALICE,),)),
+    ("envOr(string,string,bytes32[])", ["CHASM_MISSING", ",", [B32_ONE]], ((B32_ONE,),)),
+    ("envOr(string,string,bytes[])", ["CHASM_MISSING", ",", [b"\xaa"]], ((b"\xaa",),)),
+    ("envOr(string,string,string[])", ["CHASM_MISSING", ",", ["z"]], (("z",),)),
 ]
 
 
@@ -202,7 +202,7 @@ def test_pure_cheats(signature, args, expected):
 def env(monkeypatch):
     for name, value in ENV_VALUES.items():
         monkeypatch.setenv(name, value)
-    monkeypatch.delenv("SEVM_MISSING", raising=False)
+    monkeypatch.delenv("CHASM_MISSING", raising=False)
 
 
 @pytest.mark.parametrize(
@@ -213,51 +213,51 @@ def test_env_cheats(env, signature, args, expected):
 
 
 def test_env_or_prefers_the_variable_over_the_default(env):
-    assert call("envOr(string,uint256)", ["SEVM_UINT", 7]) == (42,)
-    assert call("envOr(string,string,uint256[])", ["SEVM_UINTS", ",", [4]]) == (
+    assert call("envOr(string,uint256)", ["CHASM_UINT", 7]) == (42,)
+    assert call("envOr(string,string,uint256[])", ["CHASM_UINTS", ",", [4]]) == (
         (1, 2, 3),
     )
 
 
 def test_env_exists_is_false_for_an_unset_variable(env):
-    assert call("envExists(string)", ["SEVM_MISSING"]) == (False,)
+    assert call("envExists(string)", ["CHASM_MISSING"]) == (False,)
 
 
 def test_env_missing_variable_reverts(env):
     with pytest.raises(CheatError, match="not found"):
-        call("envUint(string)", ["SEVM_MISSING"])
+        call("envUint(string)", ["CHASM_MISSING"])
 
 
 def test_set_env_writes_the_process_environment(monkeypatch):
-    monkeypatch.delenv("SEVM_SET_AT_RUNTIME", raising=False)
-    call("setEnv(string,string)", ["SEVM_SET_AT_RUNTIME", "123"])
+    monkeypatch.delenv("CHASM_SET_AT_RUNTIME", raising=False)
+    call("setEnv(string,string)", ["CHASM_SET_AT_RUNTIME", "123"])
     try:
-        assert os.environ["SEVM_SET_AT_RUNTIME"] == "123"
-        assert call("envUint(string)", ["SEVM_SET_AT_RUNTIME"]) == (123,)
+        assert os.environ["CHASM_SET_AT_RUNTIME"] == "123"
+        assert call("envUint(string)", ["CHASM_SET_AT_RUNTIME"]) == (123,)
     finally:
-        os.environ.pop("SEVM_SET_AT_RUNTIME", None)
+        os.environ.pop("CHASM_SET_AT_RUNTIME", None)
 
 
 def test_env_bool_accepts_one_and_zero(env):
     # forge's parser takes 1/0 as well as true/false.
-    assert call("envBool(string)", ["SEVM_BOOL_ONE"]) == (True,)
+    assert call("envBool(string)", ["CHASM_BOOL_ONE"]) == (True,)
 
 
 def test_env_uint_accepts_hex(env):
-    assert call("envUint(string)", ["SEVM_UINT_HEX"]) == (255,)
+    assert call("envUint(string)", ["CHASM_UINT_HEX"]) == (255,)
 
 
 @pytest.mark.parametrize(
     "signature,args",
     [
         ("parseBytes32(string)", ["0xdead"]),
-        ("envBytes32(string)", ["SEVM_SHORT"]),
+        ("envBytes32(string)", ["CHASM_SHORT"]),
     ],
 )
 def test_short_bytes32_is_refused_not_padded(monkeypatch, signature, args):
     # forge rejects it: a short literal pads left as an integer and right as a bytes32,
     # so guessing would be silently and plausibly wrong.
-    monkeypatch.setenv("SEVM_SHORT", "0xdead")
+    monkeypatch.setenv("CHASM_SHORT", "0xdead")
     with pytest.raises(CheatError, match="32 bytes"):
         call(signature, args)
 
@@ -426,7 +426,7 @@ def test_sign_compact_packs_the_parity_into_s():
 @pytest.fixture
 def state(proj):
     """The live REVM state adapter used by the cheatcode dispatcher."""
-    from sevm.session import DebugSession
+    from chasm_debugger.session import DebugSession
 
     return DebugSession(proj, stop_at_start=False)._state
 
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 50c18c9..99fb42d 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -1,4 +1,4 @@
-"""The `sevm` command line."""
+"""The `chasm` command line."""
 
 from __future__ import annotations
 
@@ -8,7 +8,7 @@
 
 
 def test_cli_compile_subcommand(capsys):
-    from sevm.cli import main
+    from chasm_debugger.cli import main
 
     contracts = os.path.join(os.path.dirname(os.path.abspath(__file__)), "contracts")
     assert main(["compile", contracts]) == 0
@@ -20,7 +20,7 @@ def test_cli_compile_subcommand(capsys):
 
 
 def test_cli_rejects_a_missing_script(capsys):
-    from sevm.cli import main
+    from chasm_debugger.cli import main
 
     assert main(["run", "/nonexistent/script.py"]) == 1
     assert "no such script" in capsys.readouterr().out
diff --git a/tests/test_clipboard.py b/tests/test_clipboard.py
index 4108f19..362be21 100644
--- a/tests/test_clipboard.py
+++ b/tests/test_clipboard.py
@@ -71,7 +71,7 @@ def test_copy_with_nothing_to_copy_says_so(deposit_debugger, fake_clipboard):
 
 
 def test_copy_surfaces_a_missing_clipboard_tool(deposit_debugger, monkeypatch):
-    from sevm import clipboard
+    from chasm_debugger import clipboard
 
     def boom(text: str) -> str:
         raise clipboard.ClipboardError("no system clipboard command found")
@@ -85,7 +85,7 @@ def boom(text: str) -> str:
 
 
 def test_clipboard_module_picks_a_tool_or_says_none(monkeypatch):
-    from sevm import clipboard
+    from chasm_debugger import clipboard
 
     monkeypatch.setattr(clipboard.shutil, "which", lambda name: None)
     assert clipboard.available_tool() is None
@@ -108,7 +108,7 @@ def test_every_pane_renders_content_so_textual_can_select_it(bank):
 
     async def body(pilot):
         await stop_at_credit(app, pilot, proj_)
-        from sevm.tui.pane import Pane
+        from chasm_debugger.tui.pane import Pane
 
         out = {}
         for pane in app.query(Pane):
@@ -128,7 +128,7 @@ def test_dragging_a_pane_selects_characters_and_ctrl_c_copies(bank):
     copied: list = []
 
     async def body(pilot):
-        from sevm import clipboard
+        from chasm_debugger import clipboard
 
         monkey = clipboard.copy
         clipboard.copy = lambda text: (copied.append(text), "pbcopy")[1]
@@ -195,7 +195,7 @@ def test_clipboard_falls_back_to_osc52_when_no_tool_exists(bank):
     session, proj_, app, size = tui_app(bank)
 
     async def body(pilot):
-        from sevm import clipboard
+        from chasm_debugger import clipboard
 
         monkey = clipboard.copy
 
@@ -235,7 +235,7 @@ def test_every_colour_constant_parses_as_a_textual_style():
     """
     from textual.style import Style
 
-    from sevm.tui import theme
+    from chasm_debugger.tui import theme
 
     bad = []
     for name in dir(theme):
@@ -286,7 +286,7 @@ async def body(pilot):
     seen = run_tui(session, app, size, body)
     from textual.style import Style
 
-    from sevm.tui.theme import C_MEMORY_TEXT, C_MEMORY_ZERO
+    from chasm_debugger.tui.theme import C_MEMORY_TEXT, C_MEMORY_ZERO
 
     def rendered(style: str) -> str:
         # ANSI names resolve to palette indices by render time, so compare like for like.
@@ -304,7 +304,7 @@ def test_copying_raises_a_toast_and_leaves_the_log_alone(bank):
     session, proj_, app, size = tui_app(bank)
 
     async def body(pilot):
-        from sevm import clipboard
+        from chasm_debugger import clipboard
 
         monkey = clipboard.copy
         clipboard.copy = lambda text: "pbcopy"
@@ -344,7 +344,7 @@ def test_cmd_c_copies_on_macos_and_ctrl_c_still_quits(bank):
     copied: list = []
 
     async def body(pilot):
-        from sevm import clipboard
+        from chasm_debugger import clipboard
 
         monkey = clipboard.copy
         clipboard.copy = lambda text: (copied.append(text), "pbcopy")[1]
@@ -444,9 +444,9 @@ async def body(pilot):
 
 def test_super_key_bindings_exist_for_mac(bank):
     """Cmd is `super` in Textual; the mac chords are bound alongside the ctrl ones."""
-    from sevm.tui.app import SevmApp
+    from chasm_debugger.tui.app import ChasmApp
 
-    keys = {b.key: b.action for b in SevmApp.BINDINGS}
+    keys = {b.key: b.action for b in ChasmApp.BINDINGS}
     assert keys.get("super+c") == "copy_selection"
     assert keys.get("super+p") == "command_palette"
     assert keys.get("super+q") == "quit"
@@ -475,7 +475,7 @@ async def body(pilot):
 
 
 def test_pane_colours_are_ansi_so_they_match_the_terminal():
-    from sevm.tui import theme
+    from chasm_debugger.tui import theme
 
     accents = {
         name: getattr(theme, name)
diff --git a/tests/test_commands.py b/tests/test_commands.py
index 01bb380..7c52334 100644
--- a/tests/test_commands.py
+++ b/tests/test_commands.py
@@ -8,8 +8,8 @@
     line_of,
 )
 
-from sevm.commands.render import _calldata
-from sevm.session import Finished, Paused, StepMode
+from chasm_debugger.commands.render import _calldata
+from chasm_debugger.session import Finished, Paused, StepMode
 
 
 def test_command_break_and_continue(deposit_debugger):
@@ -120,7 +120,7 @@ def test_info_locals_names_and_values_the_frames_locals(deposit_debugger):
 
 def test_info_storage_decodes_names(deposit_debugger):
     lines = " ".join(deposit_debugger.run("info storage").lines)
-    assert "totalDeposits" in lines and "sevm-bank" in lines
+    assert "totalDeposits" in lines and "chasm-bank" in lines
 
 
 def test_info_gas_profiles_by_line(deposit_debugger):
@@ -234,7 +234,7 @@ def test_markup_in_source_is_escaped(deposit_debugger):
 
 
 def test_cheatcode_help_is_generated_from_the_registry(deposit_debugger):
-    from sevm.cheatcodes import listing
+    from chasm_debugger.cheatcodes import listing
 
     specs = listing()
     assert specs
diff --git a/tests/test_compile_version.py b/tests/test_compile_version.py
index 9b15455..a35209b 100644
--- a/tests/test_compile_version.py
+++ b/tests/test_compile_version.py
@@ -10,14 +10,14 @@
 import pytest
 from packaging.version import Version
 
-from sevm.compile import (
+from chasm_debugger.compile import (
     DEFAULT_SOLC_VERSION,
     CompileError,
     SourceFile,
     resolve_solc_version,
     solcbin,
 )
-from sevm.compile.versions import _extract_pragmas, _pragma_matches
+from chasm_debugger.compile.versions import _extract_pragmas, _pragma_matches
 
 # A stand-in for what this platform's release index would offer, spanning the versions the
 # tests care about (a pinned 0.8.21, a caret range, and a couple of neighbours to pick
diff --git a/tests/test_decode.py b/tests/test_decode.py
index 8daf6af..13fefb2 100644
--- a/tests/test_decode.py
+++ b/tests/test_decode.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from sevm.decode import (
+from chasm_debugger.decode import (
     StorageDecoder,
     decode_calldata,
     decode_revert,
@@ -20,7 +20,7 @@ def test_storage_decoder_reads_every_shape(deposit_debugger):
     assert values["owner"].value.startswith("0x")
     assert values["feeBps"].value == 25  # packed after owner in slot 0
     assert values["totalDeposits"].value == 10**18
-    assert values["name"].display == '"sevm-bank"'
+    assert values["name"].display == '"chasm-bank"'
     assert "mapping" in values["balances"].display
     assert values["history"].display.startswith("[0 items]")
 
diff --git a/tests/test_dispatch.py b/tests/test_dispatch.py
index 8fcbe41..cb3b380 100644
--- a/tests/test_dispatch.py
+++ b/tests/test_dispatch.py
@@ -10,9 +10,9 @@
 from eth_utils import keccak
 from harness import line_of
 
-from sevm.disasm import Disassembly
-from sevm.dispatch import entries, find_selector
-from sevm.srcmap import PcMap, build_line_indexes
+from chasm_debugger.disasm import Disassembly
+from chasm_debugger.dispatch import entries, find_selector
+from chasm_debugger.srcmap import PcMap, build_line_indexes
 
 DEPOSIT = 0xD0E30DB0
 
diff --git a/tests/test_doctor.py b/tests/test_doctor.py
index 5f7dff3..d7eab16 100644
--- a/tests/test_doctor.py
+++ b/tests/test_doctor.py
@@ -1,6 +1,6 @@
-"""What `sevm doctor` reports.
+"""What `chasm doctor` reports.
 
-The point of the command is to answer, on a machine sevm has never worked on, which
+The point of the command is to answer, on a machine chasm has never worked on, which
 compiler it would use and what is missing — so the tests are about which facts get
 marked as problems, since that is what the exit status is built from.
 """
@@ -9,8 +9,8 @@
 
 import pytest
 
-from sevm import doctor
-from sevm.compile import solcbin, wasm
+from chasm_debugger import doctor
+from chasm_debugger.compile import solcbin, wasm
 
 
 @pytest.fixture
@@ -90,7 +90,7 @@ def test_missing_git_fails_even_with_a_compiler(machine):
 
 
 def test_the_command_exits_with_the_verdict(machine, capsys):
-    from sevm.cli import main
+    from chasm_debugger.cli import main
 
     assert main(["doctor"]) == 0
     assert "platform" in capsys.readouterr().out
diff --git a/tests/test_evaluate.py b/tests/test_evaluate.py
index af98fe4..bcba2e6 100644
--- a/tests/test_evaluate.py
+++ b/tests/test_evaluate.py
@@ -9,11 +9,11 @@
     line_of,
 )
 
-from sevm.compile import compile_standard
-from sevm.evaluate import Evaluator, rewrite_msg
-from sevm.evaluate.bindings import Binding
-from sevm.evaluate.injection import EvalError
-from sevm.session import SessionError, StepMode
+from chasm_debugger.compile import compile_standard
+from chasm_debugger.evaluate import Evaluator, rewrite_msg
+from chasm_debugger.evaluate.bindings import Binding
+from chasm_debugger.evaluate.injection import EvalError
+from chasm_debugger.session import SessionError, StepMode
 
 
 @pytest.mark.parametrize(
@@ -53,7 +53,7 @@ def test_evaluate_values_and_units(deposit_debugger):
         dbg.session.inspect("evaluate", "balances[owner] + 100 ether").value
         == 101 * 10**18
     )
-    assert dbg.session.inspect("evaluate", "name").value == "sevm-bank"
+    assert dbg.session.inspect("evaluate", "name").value == "chasm-bank"
     assert dbg.session.inspect("evaluate", "1 ether / 4").value == 25 * 10**16
 
 
@@ -95,8 +95,8 @@ def test_evaluate_leaves_msg_data_in_a_string_literal_alone(deposit_debugger):
 
 
 def test_rewrite_msg_rewrites_code_and_reports_what_it_bound():
-    assert rewrite_msg("msg.data.length") == ("__sevm_msg_data.length", ["data"])
-    assert rewrite_msg("msg . sig") == ("__sevm_msg_sig", ["sig"])
+    assert rewrite_msg("msg.data.length") == ("__chasm_msg_data.length", ["data"])
+    assert rewrite_msg("msg . sig") == ("__chasm_msg_sig", ["sig"])
     # Order is the order of first appearance, which is the order they are encoded in.
     assert rewrite_msg("msg.sig == bytes4(msg.data)")[1] == ["sig", "data"]
     assert rewrite_msg("msg.sender") == ("msg.sender", [])
diff --git a/tests/test_foundry.py b/tests/test_foundry.py
index 0ed557d..32f2729 100644
--- a/tests/test_foundry.py
+++ b/tests/test_foundry.py
@@ -11,7 +11,7 @@
 
 import pytest
 
-from sevm.cheatcodes import (
+from chasm_debugger.cheatcodes import (
     CheatError,
     CheatState,
     all_specs,
@@ -22,14 +22,14 @@
     parse_cheat_arg,
     spec_by_name,
 )
-from sevm.evaluate import Evaluator, make_eval_hook
-from sevm.foundry import (
+from chasm_debugger.evaluate import Evaluator, make_eval_hook
+from chasm_debugger.foundry import (
     discover_tests,
     make_test_driver,
     prepare_project,
     select_test,
 )
-from sevm.session import DebugSession, Finished, Paused, StepMode
+from chasm_debugger.session import DebugSession, Finished, Paused, StepMode
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 PROJECT = os.path.join(HERE, "foundry_project")
@@ -123,7 +123,7 @@ def test_cheats_take_effect(fn, solo_project):
 
 def test_failed_assertion_reverts_with_its_message(failing_project):
     # forge-std routes a failed assertEq through vm.assertEq, so the revert reason has to
-    # come out of sevm's cheat engine, not out of a plain Solidity require.
+    # come out of chasm's cheat engine, not out of a plain Solidity require.
     session, event = run_to_finish(failing_project, "DemoTest", "testFails")
     assert isinstance(event, Finished) and not event.ok
     assert "DemoTest.testFails reverted" in str(session.exit_error)
@@ -145,7 +145,7 @@ def test_project_prank_reverts_non_owner(token_project):
 
 
 def test_multi_test_stops_at_each_test(solo_project):
-    from sevm.foundry import make_tests_driver
+    from chasm_debugger.foundry import make_tests_driver
 
     project = solo_project
     targets = discover_tests(project)
@@ -336,8 +336,8 @@ def _cheat(sig, arg_types, args, ret_types, state=None, caller=None):
     ],
 )
 def test_env_scalar_reads_the_process_environment(monkeypatch, value, sol, abi, expected):
-    monkeypatch.setenv("SEVM_T", value)
-    got = _cheat(f"env{sol}(string)", ["string"], ["SEVM_T"], [abi])[0]
+    monkeypatch.setenv("CHASM_T", value)
+    got = _cheat(f"env{sol}(string)", ["string"], ["CHASM_T"], [abi])[0]
     if isinstance(got, str):
         assert got.lower() == expected.lower()
     else:
@@ -345,16 +345,16 @@ def test_env_scalar_reads_the_process_environment(monkeypatch, value, sol, abi,
 
 
 def test_env_array_splits_on_the_delimiter(monkeypatch):
-    monkeypatch.setenv("SEVM_NUMS", "1,2,3")
+    monkeypatch.setenv("CHASM_NUMS", "1,2,3")
     got = _cheat(
-        "envUint(string,string)", ["string", "string"], ["SEVM_NUMS", ","], ["uint256[]"]
+        "envUint(string,string)", ["string", "string"], ["CHASM_NUMS", ","], ["uint256[]"]
     )
     assert got[0] == (1, 2, 3)
 
 
 def test_env_missing_variable_reverts():
     with pytest.raises(CheatError, match="not found"):
-        _cheat("envUint(string)", ["string"], ["SEVM_DOES_NOT_EXIST"], ["uint256"])
+        _cheat("envUint(string)", ["string"], ["CHASM_DOES_NOT_EXIST"], ["uint256"])
 
 
 def test_env_or_returns_default_on_miss_and_value_on_hit(monkeypatch):
@@ -362,17 +362,17 @@ def test_env_or_returns_default_on_miss_and_value_on_hit(monkeypatch):
         _cheat(
             "envOr(string,uint256)",
             ["string", "uint256"],
-            ["SEVM_ABSENT", 7],
+            ["CHASM_ABSENT", 7],
             ["uint256"],
         )[0]
         == 7
     )
-    monkeypatch.setenv("SEVM_PRESENT", "99")
+    monkeypatch.setenv("CHASM_PRESENT", "99")
     assert (
         _cheat(
             "envOr(string,uint256)",
             ["string", "uint256"],
-            ["SEVM_PRESENT", 7],
+            ["CHASM_PRESENT", 7],
             ["uint256"],
         )[0]
         == 99
@@ -383,16 +383,18 @@ def test_env_or_array_default(monkeypatch):
     got = _cheat(
         "envOr(string,string,uint256[])",
         ["string", "string", "uint256[]"],
-        ["SEVM_ABSENT_ARR", ",", [4, 5]],
+        ["CHASM_ABSENT_ARR", ",", [4, 5]],
         ["uint256[]"],
     )
     assert got[0] == (4, 5)
 
 
 def test_env_exists(monkeypatch):
-    monkeypatch.setenv("SEVM_EXISTS", "x")
-    assert _cheat("envExists(string)", ["string"], ["SEVM_EXISTS"], ["bool"])[0] is True
-    assert _cheat("envExists(string)", ["string"], ["SEVM_MISSING"], ["bool"])[0] is False
+    monkeypatch.setenv("CHASM_EXISTS", "x")
+    assert _cheat("envExists(string)", ["string"], ["CHASM_EXISTS"], ["bool"])[0] is True
+    assert (
+        _cheat("envExists(string)", ["string"], ["CHASM_MISSING"], ["bool"])[0] is False
+    )
 
 
 @pytest.mark.parametrize(
diff --git a/tests/test_inspect_ops.py b/tests/test_inspect_ops.py
index 8fe5a0e..658cfb3 100644
--- a/tests/test_inspect_ops.py
+++ b/tests/test_inspect_ops.py
@@ -7,7 +7,7 @@
     Debugger,
 )
 
-from sevm.session import Paused, SessionError, StepMode
+from chasm_debugger.session import Paused, SessionError, StepMode
 
 
 def test_write_storage_takes_effect(deposit_debugger):
diff --git a/tests/test_layout.py b/tests/test_layout.py
index 6d49a87..b41c7e1 100644
--- a/tests/test_layout.py
+++ b/tests/test_layout.py
@@ -1,6 +1,6 @@
 """The package layout holds together.
 
-sevm is a tree of small packages, and splitting a module a level deeper silently breaks any
+chasm is a tree of small packages, and splitting a module a level deeper silently breaks any
 `from .x import y` written inside a function body: the name still resolves at import time
 because it is never executed, and only fails when that code path runs. That cost three
 debugging rounds during the split, so it is a test now.
@@ -17,13 +17,13 @@
 
 import pytest
 
-import sevm
+import chasm_debugger
 
-SRC = os.path.dirname(os.path.abspath(sevm.__file__))
+SRC = os.path.dirname(os.path.abspath(chasm_debugger.__file__))
 # __main__ runs the CLI on import, by design.
 MODULES = sorted(
     m.name
-    for m in pkgutil.walk_packages([SRC], prefix="sevm.")
+    for m in pkgutil.walk_packages([SRC], prefix="chasm_debugger.")
     if not m.name.endswith("__main__")
 )
 
diff --git a/tests/test_libs.py b/tests/test_libs.py
index 4041fa5..5298da8 100644
--- a/tests/test_libs.py
+++ b/tests/test_libs.py
@@ -14,7 +14,7 @@
 import pytest
 from conftest import FAKE_NEWEST, FIXTURES, make_repo
 
-from sevm import libs
+from chasm_debugger import libs
 
 
 def remove_tree(path: str) -> None:
@@ -40,7 +40,7 @@ def read_text(path: str) -> str:
 
 
 # Marked tests reach the real repositories; conftest skips them without
-# SEVM_NETWORK_TESTS=1.
+# CHASM_NETWORK_TESTS=1.
 NETWORK = pytest.mark.network
 
 
diff --git a/tests/test_libs_network.py b/tests/test_libs_network.py
index e659a05..45b9d9b 100644
--- a/tests/test_libs_network.py
+++ b/tests/test_libs_network.py
@@ -1,6 +1,6 @@
-"""The live-network equivalents, skipped unless SEVM_NETWORK_TESTS=1.
+"""The live-network equivalents, skipped unless CHASM_NETWORK_TESTS=1.
 
-These reach the real forge-std, npm and openzeppelin repositories. One asserts sevm
+These reach the real forge-std, npm and openzeppelin repositories. One asserts chasm
 implements every `assert*` the current forge-std declares, so a new overload upstream fails
 the suite rather than surfacing as "unimplemented cheatcode" at run time.
 """
@@ -14,9 +14,9 @@
 import pytest
 from conftest import FIXTURES
 
-from sevm import libs
-from sevm.compile import compile_foundry_project
-from sevm.foundry import discover_tests
+from chasm_debugger import libs
+from chasm_debugger.compile import compile_foundry_project
+from chasm_debugger.foundry import discover_tests
 
 
 def read_text(path: str) -> str:
@@ -25,7 +25,7 @@ def read_text(path: str) -> str:
 
 
 # Marked tests reach the real repositories; conftest skips them without
-# SEVM_NETWORK_TESTS=1.
+# CHASM_NETWORK_TESTS=1.
 NETWORK = pytest.mark.network
 
 
@@ -34,9 +34,9 @@ def read_text(path: str) -> str:
 
 @NETWORK
 def test_real_forge_std_installs_and_runs(tmp_path):
-    from sevm.evaluate import Evaluator, make_eval_hook
-    from sevm.foundry import compile_test, make_test_driver, select_test
-    from sevm.session import DebugSession, Finished, StepMode
+    from chasm_debugger.evaluate import Evaluator, make_eval_hook
+    from chasm_debugger.foundry import compile_test, make_test_driver, select_test
+    from chasm_debugger.session import DebugSession, Finished, StepMode
 
     root = str(tmp_path / "solo")
     shutil.copytree(os.path.join(os.path.dirname(FIXTURES), "foundry_solo"), root)
@@ -60,7 +60,7 @@ def test_real_forge_std_installs_and_runs(tmp_path):
 def test_real_forge_std_declares_every_assert_we_implement(tmp_path):
     from eth_utils import function_signature_to_4byte_selector
 
-    from sevm.cheatcodes.registry import _REGISTRY
+    from chasm_debugger.cheatcodes.registry import _REGISTRY
 
     root = str(tmp_path / "std")
     libs.clone(
@@ -77,7 +77,7 @@ def test_real_forge_std_declares_every_assert_we_implement(tmp_path):
         if function_signature_to_4byte_selector(sig) not in _REGISTRY
     ]
     assert not missing, (
-        f"forge-std asserts sevm does not implement: {sorted(set(missing))}"
+        f"forge-std asserts chasm does not implement: {sorted(set(missing))}"
     )
 
 
diff --git a/tests/test_libs_pipeline.py b/tests/test_libs_pipeline.py
index 6612691..670997a 100644
--- a/tests/test_libs_pipeline.py
+++ b/tests/test_libs_pipeline.py
@@ -11,9 +11,13 @@
 
 import pytest
 
-from sevm.compile import CompileError, compile_foundry_project, read_foundry_config
-from sevm.compile.build import _build_project
-from sevm.foundry import discover_tests, prepare_project
+from chasm_debugger.compile import (
+    CompileError,
+    compile_foundry_project,
+    read_foundry_config,
+)
+from chasm_debugger.compile.build import _build_project
+from chasm_debugger.foundry import discover_tests, prepare_project
 
 
 def read_text(path: str) -> str:
@@ -22,7 +26,7 @@ def read_text(path: str) -> str:
 
 
 # Marked tests reach the real repositories; conftest skips them without
-# SEVM_NETWORK_TESTS=1.
+# CHASM_NETWORK_TESTS=1.
 NETWORK = pytest.mark.network
 
 
@@ -176,7 +180,7 @@ def test_standalone_end_to_end_install_and_compile(tmp_path, local_forge_std):
     )
     assert project.artifact("DemoTest") is not None
     assert "forge-std/=lib/forge-std/src/" in project.remappings
-    # What sevm resolved is written down, so `forge` resolves the project the same way.
+    # What chasm resolved is written down, so `forge` resolves the project the same way.
     written = read_text(os.path.join(root, "remappings.txt")).splitlines()
     assert "forge-std/=lib/forge-std/src/" in written
     assert any("installing forge-std" in n for n in notices)
@@ -226,7 +230,7 @@ def test_unlinked_bytecode_does_not_break_the_project():
 def test_python_run_resolves_libraries_and_enables_cheatcodes(
     tmp_path, local_forge_std, monkeypatch
 ):
-    import sevm.cli as cli
+    import chasm_debugger.cli as cli
 
     contracts = tmp_path / "contracts"
     contracts.mkdir()
diff --git a/tests/test_locals.py b/tests/test_locals.py
index 1509316..30e6ea6 100644
--- a/tests/test_locals.py
+++ b/tests/test_locals.py
@@ -9,15 +9,15 @@
     stop_at,
 )
 
-from sevm.session import Finished, StepMode
-from sevm.srcmap import (
+from chasm_debugger.session import Finished, StepMode
+from chasm_debugger.srcmap import (
     PcMap,
     build_line_indexes,
 )
 
 
 def test_locals_index_finds_every_declaration(proj):
-    from sevm.locals import LocalsIndex
+    from chasm_debugger.locals import LocalsIndex
 
     index = LocalsIndex(proj.asts)
     credit = [
@@ -31,7 +31,7 @@ def test_locals_index_finds_every_declaration(proj):
 
 def test_locals_index_orders_params_before_body(proj):
     """Allocation order, not AST visit order: the frame layout depends on it."""
-    from sevm.locals import LocalsIndex
+    from chasm_debugger.locals import LocalsIndex
 
     index = LocalsIndex(proj.asts)
     for layout in index.by_function.values():
@@ -41,7 +41,7 @@ def test_locals_index_orders_params_before_body(proj):
 
 
 def test_locals_scope_excludes_declarations_from_closed_blocks(proj):
-    from sevm.locals import LocalsIndex
+    from chasm_debugger.locals import LocalsIndex
 
     index = LocalsIndex(proj.asts)
     scoping = next(
@@ -57,7 +57,7 @@ def test_locals_scope_excludes_declarations_from_closed_blocks(proj):
 
 
 def test_stack_slots_counts_calldata_and_function_types():
-    from sevm.locals import stack_slots
+    from chasm_debugger.locals import stack_slots
 
     assert stack_slots("uint256", "default") == 1
     assert stack_slots("string", "memory") == 1
@@ -70,7 +70,12 @@ def test_stack_slots_counts_calldata_and_function_types():
 
 def test_declaration_pcs_skips_parameters(proj):
     """Parameters are pushed by the caller; recording them here would be wrong."""
-    from sevm.locals import KIND_LOCAL, KIND_RETURN, LocalsIndex, declaration_pcs
+    from chasm_debugger.locals import (
+        KIND_LOCAL,
+        KIND_RETURN,
+        LocalsIndex,
+        declaration_pcs,
+    )
 
     art = proj.artifact("Bank")
     index = LocalsIndex(proj.asts)
@@ -274,8 +279,8 @@ def test_expression_compiles_once_across_many_stops(deposit_debugger):
 
 
 def test_bindings_only_inject_referenced_names(proj):
-    from sevm.evaluate import bindings_for
-    from sevm.locals import LocalValue
+    from chasm_debugger.evaluate import bindings_for
+    from chasm_debugger.locals import LocalValue
 
     available = [
         LocalValue(
@@ -296,8 +301,8 @@ def test_bindings_only_inject_referenced_names(proj):
 
 
 def test_unbindable_local_is_reported_not_ignored(proj):
-    from sevm.evaluate import unbindable_reference
-    from sevm.locals import LocalValue
+    from chasm_debugger.evaluate import unbindable_reference
+    from chasm_debugger.locals import LocalValue
 
     blocked = [
         LocalValue(
@@ -313,7 +318,7 @@ def test_unbindable_local_is_reported_not_ignored(proj):
 
 
 def test_breakpoint_condition_reads_a_local(deposit_debugger):
-    """The limitation SEVM.md called out: `b LOC if amount > 1 ether` now works."""
+    """The limitation CHASM.md called out: `b LOC if amount > 1 ether` now works."""
     dbg = deposit_debugger
     dbg.run("b Bank.sol:46 if amount > 1 ether")
     assert dbg.run("c").ok
diff --git a/tests/test_mcp_server.py b/tests/test_mcp_server.py
index 9b5d873..668cf8a 100644
--- a/tests/test_mcp_server.py
+++ b/tests/test_mcp_server.py
@@ -15,7 +15,7 @@
 
 import pytest
 
-from sevm.mcp_server import DebugDriver, build_server
+from chasm_debugger.mcp_server import DebugDriver, build_server
 
 COUNTER = """\
 // SPDX-License-Identifier: MIT
@@ -40,7 +40,7 @@
 
 from web3 import EthereumTesterProvider, Web3
 
-from sevm.compile import compile_project
+from chasm_debugger.compile import compile_project
 
 CONTRACTS = os.path.join(os.path.dirname(os.path.abspath(__file__)), "contracts")
 
@@ -209,7 +209,7 @@ def test_run_to_line_and_source_window(lab):
 def test_errors_are_structured_not_exceptions(lab):
     """Driver methods raise; the tools layer is what converts to error dicts."""
     driver, _script = lab
-    with pytest.raises(Exception, match="sevm_start_session"):
+    with pytest.raises(Exception, match="chasm_start_session"):
         driver.status()
     with pytest.raises(Exception, match="no such file"):
         driver.start("C:/definitely/not/here.py")
@@ -263,10 +263,10 @@ async def serve() -> None:
                         await client.initialize()
                         tools = await client.list_tools()
                         names = {t.name for t in tools.tools}
-                        assert "sevm_start_session" in names
-                        assert "sevm_find_bytes" in names
+                        assert "chasm_start_session" in names
+                        assert "chasm_find_bytes" in names
                         started = await client.call_tool(
-                            "sevm_start_session",
+                            "chasm_start_session",
                             {
                                 "target": "example.py",
                                 "reference_runtime_hex": "0x6000",
@@ -280,11 +280,11 @@ async def serve() -> None:
                             "reference_runtime_hex": "0x6000",
                             "provenance": True,
                         }
-                        res = await client.call_tool("sevm_get_status", {})
+                        res = await client.call_tool("chasm_get_status", {})
                         # dict returns serialise as JSON text content (no output
                         # schema is declared, so there is no structuredContent).
                         payload = json.loads(res.content[0].text)
-                        assert "sevm_start_session" in payload.get("error", "")
+                        assert "chasm_start_session" in payload.get("error", "")
             finally:
                 task.cancel()
                 with contextlib.suppress(asyncio.CancelledError):
@@ -334,7 +334,7 @@ def test_export_trace_structlog_shape(lab):
 
 
 def test_structlog_stack_is_pre_opcode_and_bottom_first():
-    from sevm.session.provenance import Provenance
+    from chasm_debugger.session.provenance import Provenance
 
     trace = Provenance()
     trace.enabled = True
@@ -357,7 +357,7 @@ def test_structlog_stack_is_pre_opcode_and_bottom_first():
 
 
 def test_parity_verdicts(lab):
-    from sevm.compile import compare_runtime
+    from chasm_debugger.compile import compare_runtime
 
     driver, script = lab
     driver.start(script)
@@ -367,7 +367,7 @@ def test_parity_verdicts(lab):
     assert exact["match"] is True and exact["difference"] == "none"
     # A different metadata tail is not a divergence: strip the real one and
     # append another valid `<cbor> <uint16 be length>` tail.
-    from sevm.compile.model import _strip_metadata
+    from chasm_debugger.compile.model import _strip_metadata
 
     body = _strip_metadata(art.deployed_bytecode)
     alt_meta = bytes([0xA2, 0x64, 0x69, 0x70, 0x66, 0x73])
diff --git a/tests/test_packaging.py b/tests/test_packaging.py
index b8a176d..10398aa 100644
--- a/tests/test_packaging.py
+++ b/tests/test_packaging.py
@@ -11,9 +11,9 @@
 import pytest
 from packaging.requirements import Requirement
 
-import sevm
+import chasm_debugger
 
-try:  # 3.11+; sevm supports 3.10
+try:  # 3.11+; chasm supports 3.10
     import tomllib
 except ModuleNotFoundError:  # pragma: no cover - 3.10 only
     tomllib = None
@@ -65,8 +65,8 @@ def test_keccak_runs_on_the_pycryptodome_backend():
 
 
 def _third_party_imports() -> dict[str, set[str]]:
-    """Top-level module imported by `src/sevm` -> the files importing it."""
-    src = os.path.dirname(os.path.abspath(sevm.__file__))
+    """Top-level module imported by `src/chasm_debugger` -> the files importing it."""
+    src = os.path.dirname(os.path.abspath(chasm_debugger.__file__))
     found: dict[str, set[str]] = {}
     for root, _dirs, files in os.walk(src):
         for name in files:
@@ -82,7 +82,7 @@ def _third_party_imports() -> dict[str, set[str]]:
                 elif isinstance(node, ast.ImportFrom) and node.level == 0 and node.module:
                     modules = [node.module.split(".")[0]]
                 for module in modules:
-                    if module != "sevm" and module not in sys.stdlib_module_names:
+                    if module != "chasm" and module not in sys.stdlib_module_names:
                         found.setdefault(module, set()).add(path)
     return found
 
diff --git a/tests/test_provider.py b/tests/test_provider.py
index a6f8712..b3f3a5f 100644
--- a/tests/test_provider.py
+++ b/tests/test_provider.py
@@ -4,8 +4,8 @@
 
 from web3 import Web3
 
-from sevm.provider import RevmWeb3Driver
-from sevm.session import Finished, Paused, RevmDebugSession, StepMode
+from chasm_debugger.provider import RevmWeb3Driver
+from chasm_debugger.session import Finished, Paused, RevmDebugSession, StepMode
 
 TIMEOUT = 30.0
 
diff --git a/tests/test_revm_bridge.py b/tests/test_revm_bridge.py
index 44e6f45..ed6632e 100644
--- a/tests/test_revm_bridge.py
+++ b/tests/test_revm_bridge.py
@@ -8,10 +8,10 @@
 import threading
 import time
 
+from chasm_debugger._revm import RevmChain, RevmSession, opcode_names, revm_version
 from eth_utils import function_signature_to_4byte_selector
-from sevm._revm import RevmChain, RevmSession, opcode_names, revm_version
 
-from sevm.cheatcodes import VM_ADDRESS, CheatState, apply_cheat
+from chasm_debugger.cheatcodes import VM_ADDRESS, CheatState, apply_cheat
 
 
 def test_bridge_exports_revm_opcode_names():
@@ -94,7 +94,7 @@ def test_installed_headless_launcher_uses_json_rpc():
         {"jsonrpc": "2.0", "id": 2, "method": "shutdown", "params": {}},
     ]
     result = subprocess.run(
-        [sys.executable, "-m", "sevm.revm_server"],
+        [sys.executable, "-m", "chasm_debugger.revm_server"],
         input="".join(json.dumps(request) + "\n" for request in requests),
         capture_output=True,
         text=True,
@@ -102,7 +102,7 @@ def test_installed_headless_launcher_uses_json_rpc():
     )
     responses = [json.loads(line) for line in result.stdout.splitlines()]
     assert result.stderr == ""
-    assert responses[0]["result"]["protocol"] == "sevm-debugger/1"
+    assert responses[0]["result"]["protocol"] == "chasm-debugger/1"
     assert responses[1]["result"] is None
 
 
diff --git a/tests/test_revm_session.py b/tests/test_revm_session.py
index 1e5d35f..675bd85 100644
--- a/tests/test_revm_session.py
+++ b/tests/test_revm_session.py
@@ -5,10 +5,10 @@
 import pytest
 from eth_utils import keccak
 
-from sevm.breakpoints import WATCH_ACCESS, WATCH_READ, WATCH_WRITE
-from sevm.evaluate import Evaluator, make_eval_hook
-from sevm.foundry import RevmTestsDriver, discover_tests, select_test
-from sevm.session import Finished, Paused, RevmDebugSession, StepMode
+from chasm_debugger.breakpoints import WATCH_ACCESS, WATCH_READ, WATCH_WRITE
+from chasm_debugger.evaluate import Evaluator, make_eval_hook
+from chasm_debugger.foundry import RevmTestsDriver, discover_tests, select_test
+from chasm_debugger.session import Finished, Paused, RevmDebugSession, StepMode
 
 TIMEOUT = 30.0
 
diff --git a/tests/test_session.py b/tests/test_session.py
index 1a87af5..9eb4c23 100644
--- a/tests/test_session.py
+++ b/tests/test_session.py
@@ -10,7 +10,7 @@
     make_web3,
 )
 
-from sevm.session import DebugSession, Finished, Paused, SessionError, StepMode
+from chasm_debugger.session import DebugSession, Finished, Paused, SessionError, StepMode
 
 
 def test_gas_estimation_is_not_debugged(bank):
@@ -71,8 +71,8 @@ def test_debugs_inline_assembly_in_the_original_vault():
 
     from eth_account import Account
 
-    from sevm.compile import DEFAULT_SOLC_VERSION
-    from sevm.compile import compile_project as _compile
+    from chasm_debugger.compile import DEFAULT_SOLC_VERSION
+    from chasm_debugger.compile import compile_project as _compile
 
     here = _os.path.dirname(_os.path.abspath(__file__))
     vault_project = _compile(
diff --git a/tests/test_solcbin.py b/tests/test_solcbin.py
index 0d6ff61..da17c20 100644
--- a/tests/test_solcbin.py
+++ b/tests/test_solcbin.py
@@ -14,7 +14,7 @@
 
 import pytest
 
-from sevm.compile import CompileError, solcbin
+from chasm_debugger.compile import CompileError, solcbin
 
 # Shaped like binaries.soliditylang.org: filenames live on the build entries, and the
 # digest is 0x-prefixed. The versions are the ones the platform boundaries turn on.
@@ -47,7 +47,7 @@ def install_root(tmp_path, monkeypatch):
     root = tmp_path / "solcx"
     root.mkdir()
     monkeypatch.setenv("SOLCX_BINARY_PATH", str(root))
-    monkeypatch.delenv("SEVM_SOLC", raising=False)
+    monkeypatch.delenv("CHASM_SOLC", raising=False)
     monkeypatch.setattr(solcbin, "install_dir", lambda: str(root))
     solcbin.ensure.cache_clear()
     yield str(root)
@@ -168,7 +168,7 @@ def test_a_version_this_platform_cannot_download_says_where_to_look(
     install_root, lists, monkeypatch
 ):
     monkeypatch.setattr(solcbin, "platform_key", lambda: "linux-arm64")
-    with pytest.raises(CompileError, match="SEVM_SOLC"):
+    with pytest.raises(CompileError, match="CHASM_SOLC"):
         solcbin.ensure("0.4.24")
 
 
@@ -235,9 +235,9 @@ def test_a_binary_reporting_another_version_is_not_used(install_root, monkeypatc
 
 
 @pytest.mark.skipif(os.name != "posix", reason="writes a shell script")
-def test_sevm_solc_overrides_everything(install_root, tmp_path, monkeypatch):
+def test_chasm_solc_overrides_everything(install_root, tmp_path, monkeypatch):
     path = _fake_solc(str(tmp_path / "own-solc"), "0.8.28")
-    monkeypatch.setenv("SEVM_SOLC", path)
+    monkeypatch.setenv("CHASM_SOLC", path)
     # Even a version this platform has no build for at all.
     assert solcbin.find("0.4.24") == path
     assert solcbin.ensure("0.4.24") == path
diff --git a/tests/test_srcmap.py b/tests/test_srcmap.py
index 6ea5b92..d81255b 100644
--- a/tests/test_srcmap.py
+++ b/tests/test_srcmap.py
@@ -7,9 +7,9 @@
     line_of,
 )
 
-from sevm.disasm import CALL_OPCODES, OPCODES, Disassembly, disassemble
-from sevm.frames import FunctionIndex
-from sevm.srcmap import (
+from chasm_debugger.disasm import CALL_OPCODES, OPCODES, Disassembly, disassemble
+from chasm_debugger.frames import FunctionIndex
+from chasm_debugger.srcmap import (
     LineIndex,
     PcMap,
     instruction_pcs,
diff --git a/tests/test_stepping.py b/tests/test_stepping.py
index 3b4b864..30d84aa 100644
--- a/tests/test_stepping.py
+++ b/tests/test_stepping.py
@@ -8,7 +8,7 @@
     locals_debugger,
 )
 
-from sevm.session import Finished, Paused, StepMode
+from chasm_debugger.session import Finished, Paused, StepMode
 
 
 def test_session_opens_on_the_called_function(deposit_debugger):
diff --git a/tests/test_tui.py b/tests/test_tui.py
index 71bd9b8..a5dd9f3 100644
--- a/tests/test_tui.py
+++ b/tests/test_tui.py
@@ -14,8 +14,8 @@
 )
 from tui_harness import run_tui, screen_text, stop_at_credit, tui_app
 
-from sevm.commands import CommandResult
-from sevm.evaluate import Evaluator, make_eval_hook
+from chasm_debugger.commands import CommandResult
+from chasm_debugger.evaluate import Evaluator, make_eval_hook
 
 
 def test_tui_renders_every_pane(bank):
@@ -27,7 +27,7 @@ def txfn():
         )
         w3.eth.wait_for_transaction_receipt(tx)
 
-    from sevm.tui.app import SevmApp
+    from chasm_debugger.tui.app import ChasmApp
 
     session = w3.provider.session
     session.stop_at_start = True
@@ -36,7 +36,7 @@ def txfn():
     session.set_eval_hook(make_eval_hook(evaluator))
     session.start(txfn)
     first = session.wait(timeout=TIMEOUT)
-    app = SevmApp(session, evaluator, first_event=first)
+    app = ChasmApp(session, evaluator, first_event=first)
 
     async def drive():
         async with app.run_test(size=(150, 46)) as pilot:
@@ -93,7 +93,7 @@ def txfn():
         )
         w3.eth.wait_for_transaction_receipt(tx)
 
-    from sevm.tui.app import SevmApp
+    from chasm_debugger.tui.app import ChasmApp
 
     session = w3.provider.session
     session.stop_at_start = True
@@ -102,7 +102,7 @@ def txfn():
     session.set_eval_hook(make_eval_hook(evaluator))
     session.start(txfn)
     first = session.wait(timeout=TIMEOUT)
-    app = SevmApp(
+    app = ChasmApp(
         session,
         evaluator,
         first_event=first,
@@ -141,8 +141,8 @@ async def drive():
 
 
 def test_tui_pane_helpers():
-    from sevm.tui.layout import _hex_compact, memory_region
-    from sevm.tui.opcodes import operand_count, operand_name
+    from chasm_debugger.tui.layout import _hex_compact, memory_region
+    from chasm_debugger.tui.opcodes import operand_count, operand_name
 
     assert _hex_compact(0xFF) == "0xff"
     assert ".." in _hex_compact(2**255, budget=12)
@@ -156,7 +156,7 @@ def test_tui_pane_helpers():
 
 
 def test_stack_labels_name_the_frames_locals(deposit_debugger):
-    from sevm.tui.layout import local_stack_labels
+    from chasm_debugger.tui.layout import local_stack_labels
 
     dbg = deposit_debugger
     stop_at(dbg, 46, "Bank.sol")
@@ -170,7 +170,7 @@ def test_stack_labels_name_the_frames_locals(deposit_debugger):
 
 
 def test_stack_labels_carry_the_declaration_kind(locals_contract):
-    from sevm.tui.layout import local_stack_labels
+    from chasm_debugger.tui.layout import local_stack_labels
 
     dbg = locals_debugger(*locals_contract, "loop", 3)
     try:
@@ -185,7 +185,7 @@ def test_stack_labels_carry_the_declaration_kind(locals_contract):
 
 def test_stack_labels_span_a_multi_word_local(locals_contract):
     """A calldata reference is offset plus length; neither word is anonymous."""
-    from sevm.tui.layout import local_stack_labels
+    from chasm_debugger.tui.layout import local_stack_labels
 
     dbg = locals_debugger(*locals_contract, "calldataTypes", b"\xaa\xbb\xcc")
     try:
@@ -197,7 +197,7 @@ def test_stack_labels_span_a_multi_word_local(locals_contract):
 
 
 def test_stack_labels_are_empty_without_locals(deposit_debugger):
-    from sevm.tui.layout import local_stack_labels
+    from chasm_debugger.tui.layout import local_stack_labels
 
     assert local_stack_labels(None) == {}
 
@@ -208,7 +208,7 @@ def test_panes_do_not_overflow_their_border(bank):
 
     async def body(pilot):
         await stop_at_credit(app, pilot, proj_)
-        from sevm.tui.pane import Pane
+        from chasm_debugger.tui.pane import Pane
 
         return {
             pane.id: (
@@ -441,7 +441,7 @@ async def body(pilot):
 
 def test_mouse_is_on_by_default_and_can_be_turned_off():
     """Panes render Content, which Textual can select, so the mouse is worth having."""
-    from sevm.cli import build_parser
+    from chasm_debugger.cli import build_parser
 
     args = build_parser().parse_args(["run", "--contracts", "x", "script.py"])
     assert args.no_mouse is False
@@ -502,7 +502,7 @@ def test_console_escapes_error_text_before_rendering(deposit_debugger):
     """
     from rich.console import Console
 
-    from sevm.console import ConsoleFrontend
+    from chasm_debugger.console import ConsoleFrontend
 
     frontend = ConsoleFrontend(deposit_debugger.session, deposit_debugger.evaluator)
     frontend.console = Console(file=io.StringIO(), width=200, highlight=False)
@@ -517,7 +517,7 @@ def test_console_survives_a_bad_command_end_to_end(deposit_debugger):
     """The whole path a typo takes: execute -> CommandResult -> console render."""
     from rich.console import Console
 
-    from sevm.console import ConsoleFrontend
+    from chasm_debugger.console import ConsoleFrontend
 
     frontend = ConsoleFrontend(deposit_debugger.session, deposit_debugger.evaluator)
     frontend.console = Console(file=io.StringIO(), width=200, highlight=False)
diff --git a/tests/test_wasm.py b/tests/test_wasm.py
index c7a4874..bea6e92 100644
--- a/tests/test_wasm.py
+++ b/tests/test_wasm.py
@@ -4,7 +4,7 @@
 publish for. These tests drive the JS runtime with a stub script instead of node, so the
 plumbing (arguments, stdin, exit codes, error severity) is exercised offline; the
 end-to-end test that a real soljson.js agrees with the native compiler is marked
-`network` and skipped unless SEVM_NETWORK_TESTS=1.
+`network` and skipped unless CHASM_NETWORK_TESTS=1.
 """
 
 from __future__ import annotations
@@ -15,8 +15,8 @@
 
 import pytest
 
-from sevm.compile import CompileError, solcbin, wasm
-from sevm.compile.solc import _OUTPUT_SELECTION
+from chasm_debugger.compile import CompileError, solcbin, wasm
+from chasm_debugger.compile.solc import _OUTPUT_SELECTION
 
 pytestmark = pytest.mark.skipif(os.name != "posix", reason="stubs a runtime with sh")
 
@@ -37,24 +37,24 @@ def choosing_afresh():
 
 
 def _stub_runtime(tmp_path, monkeypatch, body: str) -> str:
-    """A stand-in for node: `SEVM_NODE` points at it, and it prints `body` on stdout."""
+    """A stand-in for node: `CHASM_NODE` points at it, and it prints `body` on stdout."""
     path = tmp_path / "fake-node"
     path.write_text(f"#!/bin/sh\ncat > /dev/null\n{body}\n")
     path.chmod(0o755)
-    monkeypatch.setenv("SEVM_NODE", str(path))
+    monkeypatch.setenv("CHASM_NODE", str(path))
     return str(path)
 
 
 # -- the runtime -------------------------------------------------------------
 
 
-def test_sevm_node_names_the_runtime(tmp_path, monkeypatch):
+def test_chasm_node_names_the_runtime(tmp_path, monkeypatch):
     path = _stub_runtime(tmp_path, monkeypatch, "true")
     assert wasm.runtime() == path
 
 
 def test_no_runtime_says_what_to_install(monkeypatch):
-    monkeypatch.delenv("SEVM_NODE", raising=False)
+    monkeypatch.delenv("CHASM_NODE", raising=False)
     monkeypatch.setattr(wasm.shutil, "which", lambda name: None)
     assert wasm.runtime() is None
     with pytest.raises(CompileError, match="Install node"):
@@ -151,7 +151,7 @@ def no_native(version):
 
     with pytest.raises(CompileError) as caught:
         solcbin.compiler("0.8.28")
-    assert "riscv64" in str(caught.value) and "SEVM_NODE" in str(caught.value)
+    assert "riscv64" in str(caught.value) and "CHASM_NODE" in str(caught.value)
 
 
 # -- against the real thing --------------------------------------------------
diff --git a/tests/tui_harness.py b/tests/tui_harness.py
index ba89afc..2e97e6a 100644
--- a/tests/tui_harness.py
+++ b/tests/tui_harness.py
@@ -12,7 +12,7 @@
 
 from harness import TIMEOUT, line_of
 
-from sevm.evaluate import Evaluator, make_eval_hook
+from chasm_debugger.evaluate import Evaluator, make_eval_hook
 
 _ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
 
@@ -39,7 +39,7 @@ def txfn():
         )
         w3.eth.wait_for_transaction_receipt(tx)
 
-    from sevm.tui.app import SevmApp
+    from chasm_debugger.tui.app import ChasmApp
 
     session = w3.provider.session
     session.stop_at_start = True
@@ -48,7 +48,7 @@ def txfn():
     session.set_eval_hook(make_eval_hook(evaluator))
     session.start(txfn)
     first = session.wait(timeout=TIMEOUT)
-    return session, proj_, SevmApp(session, evaluator, first_event=first), size
+    return session, proj_, ChasmApp(session, evaluator, first_event=first), size
 
 
 def run_tui(session, app, size, body):
diff --git a/uv.lock b/uv.lock
index 7585bca..e830ae7 100644
--- a/uv.lock
+++ b/uv.lock
@@ -664,6 +664,65 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" },
 ]
 
+[[package]]
+name = "chasm-debugger"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "anyio" },
+    { name = "eth-abi" },
+    { name = "eth-account" },
+    { name = "eth-hash", extra = ["pycryptodome"] },
+    { name = "eth-keys" },
+    { name = "eth-utils" },
+    { name = "mcp" },
+    { name = "packaging" },
+    { name = "py-solc-x" },
+    { name = "pygments" },
+    { name = "requests" },
+    { name = "rich" },
+    { name = "rlp" },
+    { name = "textual" },
+    { name = "web3" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "maturin" },
+    { name = "mypy" },
+    { name = "pytest" },
+    { name = "ruff" },
+    { name = "textual-dev" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "anyio", specifier = ">=4.15.1" },
+    { name = "eth-abi", specifier = ">=5.2" },
+    { name = "eth-account", specifier = ">=0.13" },
+    { name = "eth-hash", extras = ["pycryptodome"], specifier = ">=0.5.1" },
+    { name = "eth-keys", specifier = ">=0.6" },
+    { name = "eth-utils", specifier = ">=5.0" },
+    { name = "mcp", specifier = ">=2.2.0" },
+    { name = "packaging", specifier = ">=23.0" },
+    { name = "py-solc-x", specifier = ">=2.0" },
+    { name = "pygments", specifier = ">=2.20" },
+    { name = "requests", specifier = ">=2.31" },
+    { name = "rich", specifier = ">=15.0" },
+    { name = "rlp", specifier = ">=4.0" },
+    { name = "textual", specifier = ">=8.0" },
+    { name = "web3", specifier = ">=7.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "maturin", specifier = ">=1.10,<2.0" },
+    { name = "mypy", specifier = ">=1.13" },
+    { name = "pytest", specifier = ">=8.0" },
+    { name = "ruff", specifier = ">=0.9" },
+    { name = "textual-dev", specifier = ">=1.8" },
+]
+
 [[package]]
 name = "ckzg"
 version = "2.1.8"
@@ -803,7 +862,7 @@ name = "cytoolz"
 version = "1.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "toolz" },
+    { name = "toolz", marker = "implementation_name == 'cpython'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/bd/d4/16916f3dc20a3f5455b63c35dcb260b3716f59ce27a93586804e70e431d5/cytoolz-1.1.0.tar.gz", hash = "sha256:13a7bf254c3c0d28b12e2290b82aed0f0977a4c2a2bf84854fcdc7796a29f3b0", size = 642510, upload-time = "2025-10-19T00:44:56.174Z" }
 wheels = [
@@ -1086,7 +1145,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
@@ -1237,8 +1296,8 @@ name = "httpcore2"
 version = "2.13.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "h11" },
-    { name = "truststore" },
+    { name = "h11", marker = "python_full_version < '3.12' or python_full_version >= '3.14' or sys_platform != 'emscripten'" },
+    { name = "truststore", marker = "python_full_version < '3.12' or python_full_version >= '3.14' or sys_platform != 'emscripten'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/cb/f3/1db7aa2bc2524062192bb0e0323969492d1883152a232fe36eea65f4e35c/httpcore2-2.13.1.tar.gz", hash = "sha256:e0aa977abe17e69a3b820a24542a6fa88702676d83880b8d194dcd18408e5103", size = 68071, upload-time = "2026-09-23T07:47:22.372Z" }
 wheels = [
@@ -2884,65 +2943,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0e/fe/da8b9e1347696bb22120b77280ec5ce25d500ca5cb39d5ad6e5c18de19c1/ruff-0.16.4-py3-none-win_arm64.whl", hash = "sha256:a3a61621c9b6f6a89573e938a080e648f1695baa3f58570a3a707bc51ff65a21", size = 10451579, upload-time = "2026-08-20T17:43:57.135Z" },
 ]
 
-[[package]]
-name = "sevm"
-version = "0.1.0"
-source = { editable = "." }
-dependencies = [
-    { name = "anyio" },
-    { name = "eth-abi" },
-    { name = "eth-account" },
-    { name = "eth-hash", extra = ["pycryptodome"] },
-    { name = "eth-keys" },
-    { name = "eth-utils" },
-    { name = "mcp" },
-    { name = "packaging" },
-    { name = "py-solc-x" },
-    { name = "pygments" },
-    { name = "requests" },
-    { name = "rich" },
-    { name = "rlp" },
-    { name = "textual" },
-    { name = "web3" },
-]
-
-[package.dev-dependencies]
-dev = [
-    { name = "maturin" },
-    { name = "mypy" },
-    { name = "pytest" },
-    { name = "ruff" },
-    { name = "textual-dev" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "anyio", specifier = ">=4.15.1" },
-    { name = "eth-abi", specifier = ">=5.2" },
-    { name = "eth-account", specifier = ">=0.13" },
-    { name = "eth-hash", extras = ["pycryptodome"], specifier = ">=0.5.1" },
-    { name = "eth-keys", specifier = ">=0.6" },
-    { name = "eth-utils", specifier = ">=5.0" },
-    { name = "mcp", specifier = ">=2.2.0" },
-    { name = "packaging", specifier = ">=23.0" },
-    { name = "py-solc-x", specifier = ">=2.0" },
-    { name = "pygments", specifier = ">=2.20" },
-    { name = "requests", specifier = ">=2.31" },
-    { name = "rich", specifier = ">=15.0" },
-    { name = "rlp", specifier = ">=4.0" },
-    { name = "textual", specifier = ">=8.0" },
-    { name = "web3", specifier = ">=7.0" },
-]
-
-[package.metadata.requires-dev]
-dev = [
-    { name = "maturin", specifier = ">=1.10,<2.0" },
-    { name = "mypy", specifier = ">=1.13" },
-    { name = "pytest", specifier = ">=8.0" },
-    { name = "ruff", specifier = ">=0.9" },
-    { name = "textual-dev", specifier = ">=1.8" },
-]
-
 [[package]]
 name = "sse-starlette"
 version = "3.4.11"
@@ -3147,8 +3147,8 @@ name = "uvicorn"
 version = "0.53.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "click" },
-    { name = "h11" },
+    { name = "click", marker = "python_full_version < '3.12' or python_full_version >= '3.14' or sys_platform != 'emscripten'" },
+    { name = "h11", marker = "python_full_version < '3.12' or python_full_version >= '3.14' or sys_platform != 'emscripten'" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5d/ad/04bbb797c84fc1f26cb171f7394716f4865ffb8d8c5e1eef42565c2dfa6b/uvicorn-0.53.0.tar.gz", hash = "sha256:a9356f0cb89b3b8621529c5d5eebd69bfe154f4c3f68b4cf2de47e45fa855c2e", size = 110881, upload-time = "2026-09-14T07:44:23.815Z" }