diff --git a/crates/nexum-macros/src/world.rs b/crates/nexum-macros/src/world.rs
index 3fcf3818..acae4eb1 100644
--- a/crates/nexum-macros/src/world.rs
+++ b/crates/nexum-macros/src/world.rs
@@ -36,37 +36,37 @@ struct Capability {
 const KNOWN: &[Capability] = &[
     Capability {
         name: "chain",
-        import: Some("nexum:host/chain@0.2.0"),
+        import: Some("nexum:host/chain@0.1.0"),
         packages: &[],
         adapter: Some("chain"),
     },
     Capability {
         name: "identity",
-        import: Some("nexum:host/identity@0.2.0"),
+        import: Some("nexum:host/identity@0.1.0"),
         packages: &[],
         adapter: None,
     },
     Capability {
         name: "local-store",
-        import: Some("nexum:host/local-store@0.2.0"),
+        import: Some("nexum:host/local-store@0.1.0"),
         packages: &[],
         adapter: Some("local_store"),
     },
     Capability {
         name: "remote-store",
-        import: Some("nexum:host/remote-store@0.2.0"),
+        import: Some("nexum:host/remote-store@0.1.0"),
         packages: &[],
         adapter: None,
     },
     Capability {
         name: "messaging",
-        import: Some("nexum:host/messaging@0.2.0"),
+        import: Some("nexum:host/messaging@0.1.0"),
         packages: &[],
         adapter: None,
     },
     Capability {
         name: "logging",
-        import: Some("nexum:host/logging@0.2.0"),
+        import: Some("nexum:host/logging@0.1.0"),
         packages: &[],
         adapter: Some("logging"),
     },
@@ -78,7 +78,7 @@ const KNOWN: &[Capability] = &[
     },
     Capability {
         name: "cow-api",
-        import: Some("shepherd:cow/cow-api@0.2.0"),
+        import: Some("shepherd:cow/cow-api@0.1.0"),
         packages: &["shepherd-cow"],
         adapter: None,
     },
@@ -198,7 +198,7 @@ pub fn synthesize_venue(declared: &[String]) -> Result<ModuleWorld, String> {
 
     let mut wit = String::from(
         "package nexum:venue-world;\n\nworld venue-adapter {\n    \
-         use nexum:host/types@0.2.0.{config, fault};\n\n",
+         use nexum:host/types@0.1.0.{config, fault};\n\n",
     );
     wit.push_str(&imports);
     wit.push_str(
@@ -259,7 +259,7 @@ pub fn synthesize(declared: &[String]) -> Result<ModuleWorld, String> {
 
     let mut wit = String::from(
         "package nexum:module-world;\n\nworld module {\n    \
-         use nexum:host/types@0.2.0.{config, event, fault};\n\n",
+         use nexum:host/types@0.1.0.{config, event, fault};\n\n",
     );
     wit.push_str(&imports);
     wit.push_str(
@@ -294,7 +294,7 @@ mod tests {
     #[test]
     fn logging_only_world_imports_logging_alone() {
         let world = synthesize(&["logging".to_string()]).unwrap();
-        assert!(world.wit.contains("import nexum:host/logging@0.2.0;"));
+        assert!(world.wit.contains("import nexum:host/logging@0.1.0;"));
         assert!(!world.wit.contains("import nexum:host/chain"));
         assert!(!world.wit.contains("shepherd:cow"));
         assert_eq!(world.packages, MODULE_PACKAGES);
@@ -304,7 +304,7 @@ mod tests {
     #[test]
     fn cow_api_pulls_the_shepherd_cow_package() {
         let world = synthesize(&["logging".to_string(), "cow-api".to_string()]).unwrap();
-        assert!(world.wit.contains("import shepherd:cow/cow-api@0.2.0;"));
+        assert!(world.wit.contains("import shepherd:cow/cow-api@0.1.0;"));
         assert_eq!(world.packages, vec!["nexum-host", "shepherd-cow"]);
     }
 
@@ -363,12 +363,12 @@ mod tests {
     #[test]
     fn venue_world_imports_only_declared_transport() {
         let world = synthesize_venue(&["chain".to_string()]).unwrap();
-        assert!(world.wit.contains("import nexum:host/chain@0.2.0;"));
+        assert!(world.wit.contains("import nexum:host/chain@0.1.0;"));
         assert!(!world.wit.contains("import nexum:host/messaging"));
 
         let both = synthesize_venue(&["chain".to_string(), "messaging".to_string()]).unwrap();
-        assert!(both.wit.contains("import nexum:host/chain@0.2.0;"));
-        assert!(both.wit.contains("import nexum:host/messaging@0.2.0;"));
+        assert!(both.wit.contains("import nexum:host/chain@0.1.0;"));
+        assert!(both.wit.contains("import nexum:host/messaging@0.1.0;"));
     }
 
     #[test]
diff --git a/crates/nexum-runtime/src/manifest/capabilities.rs b/crates/nexum-runtime/src/manifest/capabilities.rs
index ef00fcef..4264c6e6 100644
--- a/crates/nexum-runtime/src/manifest/capabilities.rs
+++ b/crates/nexum-runtime/src/manifest/capabilities.rs
@@ -180,11 +180,11 @@ impl CapabilityRegistry {
     /// manifest declaration.
     ///
     /// Examples:
-    /// - `"nexum:host/chain@0.2.0"`     -> `Some("chain")`
-    /// - `"shepherd:cow/cow-api@0.2.0"` -> `Some("cow-api")` once the cow
+    /// - `"nexum:host/chain@0.1.0"`     -> `Some("chain")`
+    /// - `"shepherd:cow/cow-api@0.1.0"` -> `Some("cow-api")` once the cow
     ///   namespace is registered
     /// - `"wasi:http/outgoing-handler@0.2.12"` -> `Some("http")`
-    /// - `"nexum:host/types@0.2.0"`     -> `None` (type-only, not a capability)
+    /// - `"nexum:host/types@0.1.0"`     -> `None` (type-only, not a capability)
     /// - `"wasi:io/streams@0.2.0"`      -> `None`
     pub fn wit_import_to_cap<'a>(&self, import_name: &'a str) -> Option<&'a str> {
         let without_version = import_name.split('@').next().unwrap_or(import_name);
@@ -284,9 +284,9 @@ mod tests {
     #[test]
     fn wit_import_to_cap_nexum_host() {
         let r = CapabilityRegistry::core();
-        assert_eq!(r.wit_import_to_cap("nexum:host/chain@0.2.0"), Some("chain"));
+        assert_eq!(r.wit_import_to_cap("nexum:host/chain@0.1.0"), Some("chain"));
         assert_eq!(
-            r.wit_import_to_cap("nexum:host/local-store@0.2.0"),
+            r.wit_import_to_cap("nexum:host/local-store@0.1.0"),
             Some("local-store")
         );
     }
@@ -318,11 +318,11 @@ mod tests {
     fn wit_import_to_cap_shepherd_cow_needs_registration() {
         // Core registry does not recognise the cow namespace.
         let core = CapabilityRegistry::core();
-        assert_eq!(core.wit_import_to_cap("shepherd:cow/cow-api@0.2.0"), None);
+        assert_eq!(core.wit_import_to_cap("shepherd:cow/cow-api@0.1.0"), None);
         // Once registered, it resolves.
         let r = registry_with_cow();
         assert_eq!(
-            r.wit_import_to_cap("shepherd:cow/cow-api@0.2.0"),
+            r.wit_import_to_cap("shepherd:cow/cow-api@0.1.0"),
             Some("cow-api")
         );
     }
@@ -376,7 +376,7 @@ mod tests {
     fn enforce_passes_when_caps_absent() {
         // 0.1-fallback: no capabilities section -> all imports allowed
         let loaded = manifest_no_caps();
-        let imports = ["nexum:host/chain@0.2.0", "nexum:host/remote-store@0.2.0"];
+        let imports = ["nexum:host/chain@0.1.0", "nexum:host/remote-store@0.1.0"];
         let r = registry_with_cow();
         assert!(enforce_capabilities(&loaded, imports.into_iter(), &r).is_ok());
     }
@@ -385,8 +385,8 @@ mod tests {
     fn enforce_passes_when_all_imports_declared() {
         let loaded = manifest_with_caps(&["chain", "cow-api"], &["http"]);
         let imports = [
-            "nexum:host/chain@0.2.0",
-            "shepherd:cow/cow-api@0.2.0",
+            "nexum:host/chain@0.1.0",
+            "shepherd:cow/cow-api@0.1.0",
             "wasi:http/outgoing-handler@0.2.12",
             "wasi:io/streams@0.2.0", // non-http wasi is always skipped
         ];
@@ -398,7 +398,7 @@ mod tests {
     fn enforce_rejects_wasi_http_import_without_declaration() {
         let loaded = manifest_with_caps(&["chain"], &[]);
         let imports = [
-            "nexum:host/chain@0.2.0",
+            "nexum:host/chain@0.1.0",
             "wasi:http/outgoing-handler@0.2.12",
         ];
         let r = registry_with_cow();
@@ -428,7 +428,7 @@ mod tests {
     fn enforce_rejects_undeclared_import() {
         let loaded = manifest_with_caps(&["chain"], &[]);
         // module imports remote-store but didn't declare it
-        let imports = ["nexum:host/chain@0.2.0", "nexum:host/remote-store@0.2.0"];
+        let imports = ["nexum:host/chain@0.1.0", "nexum:host/remote-store@0.1.0"];
         let r = registry_with_cow();
         let err = enforce_capabilities(&loaded, imports.into_iter(), &r).unwrap_err();
         let CapabilityError::Undeclared(v) = err else {
@@ -440,7 +440,7 @@ mod tests {
     #[test]
     fn enforce_optional_caps_are_also_allowed() {
         let loaded = manifest_with_caps(&["chain"], &["remote-store"]);
-        let imports = ["nexum:host/chain@0.2.0", "nexum:host/remote-store@0.2.0"];
+        let imports = ["nexum:host/chain@0.1.0", "nexum:host/remote-store@0.1.0"];
         let r = registry_with_cow();
         assert!(enforce_capabilities(&loaded, imports.into_iter(), &r).is_ok());
     }
@@ -463,9 +463,9 @@ mod tests {
     #[test]
     fn adapter_registry_maps_transport_imports_but_not_core_only() {
         let r = CapabilityRegistry::adapter();
-        assert_eq!(r.wit_import_to_cap("nexum:host/chain@0.2.0"), Some("chain"));
+        assert_eq!(r.wit_import_to_cap("nexum:host/chain@0.1.0"), Some("chain"));
         assert_eq!(
-            r.wit_import_to_cap("nexum:host/messaging@0.2.0"),
+            r.wit_import_to_cap("nexum:host/messaging@0.1.0"),
             Some("messaging")
         );
         assert_eq!(
@@ -473,7 +473,7 @@ mod tests {
             Some("http")
         );
         // A core-only interface is not a recognised adapter capability.
-        assert_eq!(r.wit_import_to_cap("nexum:host/local-store@0.2.0"), None);
+        assert_eq!(r.wit_import_to_cap("nexum:host/local-store@0.1.0"), None);
     }
 
     #[test]
@@ -575,7 +575,7 @@ mod tests {
         let loaded = manifest_no_caps();
         let r = registry_with_cow();
         assert!(
-            enforce_capabilities(&loaded, ["nexum:host/remote-store@0.2.0"].into_iter(), &r)
+            enforce_capabilities(&loaded, ["nexum:host/remote-store@0.1.0"].into_iter(), &r)
                 .is_ok()
         );
         assert!(enforce_capabilities(&loaded, ["wasi:io/streams@0.2.6"].into_iter(), &r).is_ok());
diff --git a/crates/nexum-runtime/src/manifest/error.rs b/crates/nexum-runtime/src/manifest/error.rs
index 73e1ac4f..470cc0bb 100644
--- a/crates/nexum-runtime/src/manifest/error.rs
+++ b/crates/nexum-runtime/src/manifest/error.rs
@@ -44,7 +44,7 @@ pub struct CapabilityViolation {
     /// Capability name (e.g. `"remote-store"`).
     pub capability: String,
     /// Full WIT import name as it appeared in the component (e.g.
-    /// `"nexum:host/remote-store@0.2.0"`).
+    /// `"nexum:host/remote-store@0.1.0"`).
     pub wit_import: String,
 }
 
diff --git a/docs/00-overview.md b/docs/00-overview.md
index ee99796e..4deeecd5 100755
--- a/docs/00-overview.md
+++ b/docs/00-overview.md
@@ -11,14 +11,12 @@ Two project names look similar but mean different things - keeping them straight
 | Term | What it is | Where you find it |
 |---|---|---|
 | **engine** (`nexum`) | A concrete *implementation* that loads and runs WASM components. The 0.2 reference engine is a wasmtime-based server daemon. Mobile / browser / embedded engines could exist later - each is a separate engine. | `crates/nexum-runtime/`, the `nexum` binary, `cargo run -p nexum-cli` |
-| **host** (`nexum:host`) | The WIT *contract* - the set of host-imported interfaces (chain, identity, local-store, etc.), types, and worlds that every engine must implement and every module imports. The contract is one; engines are many. | `wit/nexum-host/`, `package nexum:host@0.2.0`, Rust path `nexum::host::*` |
+| **host** (`nexum:host`) | The WIT *contract* - the set of host-imported interfaces (chain, identity, local-store, etc.), types, and worlds that every engine must implement and every module imports. The contract is one; engines are many. | `wit/nexum-host/`, `package nexum:host@0.1.0`, Rust path `nexum::host::*` |
 
 The relationship: an engine *implements* `nexum:host` so that modules *built against* `nexum:host` can run on it. The `nexum:host` package itself does not run anything - it's a specification. When this doc says "the host", it means whichever engine the module currently runs on, as seen through the `nexum:host` contract.
 
 The reference engine ships as two crates: the `nexum-runtime` library (embeddable, no CLI surface) and the `nexum` binary in `crates/nexum-cli`, a thin consumer of it. A Rust embedder skips the binary entirely, constructs an `EngineConfig` in code, and calls `nexum_runtime::bootstrap::run_from_config`. See `crates/nexum-runtime/examples/embed.rs` for a minimal end-to-end example.
 
-> **Upgrading from 0.1?** See the [Migration Guide](migration/0.1-to-0.2.md) for the full rename table (`web3:runtime` → `nexum:host`, `csn` → `chain`, `msg` → `messaging`, `headless-module` → `event-module`, etc.), the per-interface typed error model over the shared `fault` vocabulary, and the manifest-driven capability negotiation introduced in 0.2.
-
 ## Architecture
 
 ```mermaid
@@ -96,7 +94,7 @@ In addition to the six core primitives, 0.2 introduces one optional capability t
 
 Time and secure randomness are WASI concerns rather than Nexum capabilities: `wasi:clocks` and `wasi:random` are linked into every module store ambiently.
 
-0.2 also publishes (but does not yet host) the experimental **`query-module`** world for request/response modules (wallet rule evaluators, signature validators, pricing oracles). The WIT is stable enough to target with `MockHost` tests; production host support lands in 0.3. See the migration guide for the full WIT.
+0.2 also publishes (but does not yet host) the experimental **`query-module`** world for request/response modules (wallet rule evaluators, signature validators, pricing oracles). The WIT is stable enough to target with `MockHost` tests; production host support lands in 0.3.
 
 ## WIT Worlds
 
@@ -121,7 +119,7 @@ graph TB
 
 ```
 // Universal layer - any platform, any blockchain app
-package nexum:host@0.2.0
+package nexum:host@0.1.0
 
 world event-module {
     import chain          - consensus access (JSON-RPC passthrough)
@@ -136,7 +134,7 @@ world event-module {
 }
 
 // CoW Protocol extension
-package shepherd:cow@0.2.0
+package shepherd:cow@0.1.0
 
 world shepherd {
     include event-module
@@ -158,7 +156,7 @@ The world imports no WASI interfaces. `wasi:clocks` and `wasi:random` are linked
 |---------|--------|---------|
 | Language | Rust | 1.90+ |
 | WASM runtime | wasmtime (Component Model) | 45.x |
-| API contract | WIT (`nexum:host@0.2.0`, `shepherd:cow@0.2.0`) | - |
+| API contract | WIT (`nexum:host@0.1.0`, `shepherd:cow@0.1.0`) | - |
 | Guest bindings | wit-bindgen | 0.57.x |
 | Async | Tokio | - |
 | Ethereum RPC | alloy | 1.5.x |
@@ -311,7 +309,7 @@ Tower layer stack per chain: timeout -> retry (exponential + jitter) -> rate lim
 
 ### Error Model
 
-In 0.2 each interface declares its own typed error and they share one payload-bearing `fault` vocabulary for the cross-domain cases. `fault` has seven cases: `unsupported(string)`, `unavailable(string)`, `denied(string)`, `rate-limited(rate-limit)`, `timeout`, `invalid-input(string)`, and `internal(string)`. Interfaces with nothing to add report `fault` directly (identity, local-store, remote-store, messaging, and the module exports); a richer interface embeds `fault` as one case of its own variant and adds the cases only it needs (`chain-error` adds an `rpc` case carrying the node code and decoded revert bytes). Modules match on the typed variant for retry/backoff decisions; the per-protocol error types from 0.1 (`json-rpc-error`, `msg-error`, `store-error`, `api-error`) are gone. See [ADR-0011](adr/0011-per-interface-typed-errors.md) for the model and the [migration guide](migration/0.1-to-0.2.md#2-error-model-unification-both) for the embedder mapping.
+In 0.2 each interface declares its own typed error and they share one payload-bearing `fault` vocabulary for the cross-domain cases. `fault` has seven cases: `unsupported(string)`, `unavailable(string)`, `denied(string)`, `rate-limited(rate-limit)`, `timeout`, `invalid-input(string)`, and `internal(string)`. Interfaces with nothing to add report `fault` directly (identity, local-store, remote-store, messaging, and the module exports); a richer interface embeds `fault` as one case of its own variant and adds the cases only it needs (`chain-error` adds an `rpc` case carrying the node code and decoded revert bytes). Modules match on the typed variant for retry/backoff decisions; the per-protocol error types from 0.1 (`json-rpc-error`, `msg-error`, `store-error`, `api-error`) are gone. See [ADR-0011](adr/0011-per-interface-typed-errors.md) for the model.
 
 ### Observability
 
@@ -379,8 +377,7 @@ shepherd/
     ├── operations/         Runbooks, E2E reports, load reports, baselines
     ├── production.md       Operator handbook
     ├── sdk.md              Module-author entry point (shipped SDK reference)
-    ├── tutorial-first-module.md
-    └── migration/0.1-to-0.2.md
+    └── tutorial-first-module.md
 ```
 
 The SDK split is in place: `nexum-sdk` carries the universal surface and `shepherd-sdk` layers the CoW domain on top, with no re-export between them. Shipping a `cargo-nexum` subcommand for module authors remains future direction.
diff --git a/docs/01-runtime-environment.md b/docs/01-runtime-environment.md
index 572e2898..8ad5f84f 100755
--- a/docs/01-runtime-environment.md
+++ b/docs/01-runtime-environment.md
@@ -101,12 +101,12 @@ let bindings = EventModule::instantiate_pre(&mut store, &pre)?;
 
 Nexum uses a two-layer WIT architecture. The **universal** package `nexum:host` defines platform-agnostic interfaces and the `event-module` world. The **CoW-specific** package `shepherd:cow` extends it with CoW Protocol interfaces and the `shepherd` world.
 
-### Universal Package: `nexum:host@0.2.0`
+### Universal Package: `nexum:host@0.1.0`
 
 The `nexum:host` package is the single source of truth for the universal host-guest contract. It defines a custom world with **no WASI imports**:
 
 ```wit
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 interface types {
     type chain-id = u64;
@@ -301,14 +301,14 @@ world event-module {
 }
 ```
 
-In addition to the six core imports, 0.2 publishes one additive optional capability - `http` (allowlisted outbound HTTP) - which modules declare in their `module.toml` `[capabilities]` section. The declaration is a manifest concern only: the capability is serviced by the standard `wasi:http/outgoing-handler` interface, not a `nexum:host` one. The migration guide carries the details. 0.2 also publishes the experimental **`query-module`** world for request/response modules; the WIT is stable but no host implementation ships in 0.2, so it's a target for `MockHost` testing only.
+In addition to the six core imports, 0.2 publishes one additive optional capability - `http` (allowlisted outbound HTTP) - which modules declare in their `module.toml` `[capabilities]` section. The declaration is a manifest concern only: the capability is serviced by the standard `wasi:http/outgoing-handler` interface, not a `nexum:host` one. 0.2 also publishes the experimental **`query-module`** world for request/response modules; the WIT is stable but no host implementation ships in 0.2, so it's a target for `MockHost` testing only.
 
-### CoW-Specific Package: `shepherd:cow@0.2.0`
+### CoW-Specific Package: `shepherd:cow@0.1.0`
 
 The `shepherd:cow` package extends the universal world with CoW Protocol interfaces. In 0.2 the two 0.1 interfaces (`cow` + `order`) merge into a single `cow-api` interface to eliminate the `cow::cow::request` triple-stutter:
 
 ```wit
-package shepherd:cow@0.2.0;
+package shepherd:cow@0.1.0;
 
 interface cow-api {
     use nexum:host/types.{chain-id, fault};
diff --git a/docs/02-modules-events-packaging.md b/docs/02-modules-events-packaging.md
index 2a946860..15c1e0c4 100755
--- a/docs/02-modules-events-packaging.md
+++ b/docs/02-modules-events-packaging.md
@@ -54,9 +54,9 @@ enable_alerts = true             # boolean stays boolean
 
 Key design points:
 
-- **`component` is a content hash**, not a filename. The runtime resolves it via the content store (see below). (Was `wasm = ...` in 0.1 - see the migration guide.)
+- **`component` is a content hash**, not a filename. The runtime resolves it via the content store (see below).
 - **`[[subscription]]` blocks are declarative.** The module doesn't set up its own subscriptions imperatively - the runtime reads the manifest and wires up event sources before calling `init`. The 0.1 spelling was `[[subscribe]]` with `type = ...`; 0.2 uses `[[subscription]]` with `kind = ...` because `type` is a reserved word in several binding languages.
-- **`[capabilities]`** is new in 0.2 and now drives what the runtime links into the module's import space. See the migration guide for the full schema (including `[capabilities.http]` allowlists). A module that declares `http` imports the standard `wasi:http/outgoing-handler` interface - the SDK's `http::fetch` helper wraps it - and the host checks every outgoing request against the `[capabilities.http].allow` list; see `modules/examples/http-probe` for a complete example.
+- **`[capabilities]`** is new in 0.2 and now drives what the runtime links into the module's import space. A module that declares `http` imports the standard `wasi:http/outgoing-handler` interface - the SDK's `http::fetch` helper wraps it - and the host checks every outgoing request against the `[capabilities.http].allow` list; see `modules/examples/http-probe` for a complete example.
 - **Chain ids are declared per-subscription**, not in a top-level `[chains]` table - each `[[subscription]]` names its own `chain_id`. If `engine.toml` has no `[chains.<id>]` entry for a chain a subscription names, the engine bails at boot, before any events dispatch (fast, clear error).
 - **`config`** is opaque to the runtime. 0.2 keeps 0.1's stringly-typed shape (`list<tuple<string, string>>`); the host flattens TOML scalars (numbers, booleans) to their string form on the way through. A typed `config-value` variant is on the 0.3 roadmap, bundled with the manifest-parser work.
 
@@ -277,10 +277,10 @@ The runtime serialises event data via the canonical ABI (handled automatically b
 
 The initial WIT in `01-runtime-environment.md` is extended to support the lifecycle and config. The architecture uses two packages: `nexum:host` for universal interfaces and `shepherd:cow` for CoW Protocol extensions.
 
-### Universal Package: `nexum:host@0.2.0`
+### Universal Package: `nexum:host@0.1.0`
 
 ```wit
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 interface types {
     type chain-id = u64;
@@ -409,10 +409,10 @@ world event-module {
 }
 ```
 
-### CoW-Specific Package: `shepherd:cow@0.2.0`
+### CoW-Specific Package: `shepherd:cow@0.1.0`
 
 ```wit
-package shepherd:cow@0.2.0;
+package shepherd:cow@0.1.0;
 
 interface cow-api {
     use nexum:host/types.{chain-id, fault};
diff --git a/docs/04-state-store.md b/docs/04-state-store.md
index 59de103a..96d5434b 100755
--- a/docs/04-state-store.md
+++ b/docs/04-state-store.md
@@ -55,8 +55,7 @@ interface local-store {
 
     /// Set a key-value pair. Overwrites existing value.
     /// Returns fault.invalid-input or fault.internal on failure.
-    /// Quota exhaustion surfaces as fault.invalid-input (or a future
-    /// dedicated case) - see the migration guide.
+    /// Quota exhaustion surfaces as fault.invalid-input.
     set: func(key: string, value: list<u8>) -> result<_, fault>;
 
     /// Delete a key. No-op if key doesn't exist.
@@ -67,7 +66,7 @@ interface local-store {
 }
 ```
 
-In 0.1 `local-store` errors were bare `string` values. 0.2 replaces them with the shared `fault` vocabulary (see [migration guide §2](migration/0.1-to-0.2.md#2-error-model-unification-both)) so modules can match on the `fault` case rather than parsing error strings. The interface is the failure domain, so it reports `fault` directly with no subsystem tag.
+In 0.1 `local-store` errors were bare `string` values. 0.2 replaces them with the shared `fault` vocabulary so modules can match on the `fault` case rather than parsing error strings. The interface is the failure domain, so it reports `fault` directly with no subsystem tag.
 
 Keys are UTF-8 strings. Values are opaque bytes - the SDK provides typed wrappers (see doc 05).
 
diff --git a/docs/05-sdk-design.md b/docs/05-sdk-design.md
index 8b62896f..60594ad3 100755
--- a/docs/05-sdk-design.md
+++ b/docs/05-sdk-design.md
@@ -304,8 +304,6 @@ of it, not a requirement.
 - [ADR-0011](adr/0011-per-interface-typed-errors.md) - the typed
   error model (`Fault`, `ChainError`, `CowApiError`) the host traits
   return.
-- [Migration guide §7](migration/0.1-to-0.2.md#7-sdk-changes-author) -
-  what changed in the SDK surface between 0.1 and 0.2.
 - [doc 07](07-rpc-namespace-design.md) - the `chain` RPC passthrough
   design and why module authors call `host.request` directly rather
   than through an injected provider.
diff --git a/docs/07-rpc-namespace-design.md b/docs/07-rpc-namespace-design.md
index f7e8f542..25246aac 100755
--- a/docs/07-rpc-namespace-design.md
+++ b/docs/07-rpc-namespace-design.md
@@ -75,7 +75,7 @@ flowchart TD
 Replace the `blockchain` interface with `chain`:
 
 ```wit
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 interface chain {
     use types.{chain-id, fault};
@@ -107,7 +107,7 @@ interface chain {
 }
 ```
 
-Errors are reported via `chain-error`: either a shared `fault` (see doc 00, ADR-0011, and the [migration guide §2](migration/0.1-to-0.2.md#2-error-model-unification-both)) or a structured `rpc` case carrying the node code and decoded revert bytes - the 0.1 `json-rpc-error` shape is gone. Modules match on the `fault` case (`unavailable`, `rate-limited`, `timeout`, `denied`, `invalid-input`, ...) for retry/backoff, and on the `rpc` case to decode a revert without parsing numeric JSON-RPC codes by hand.
+Errors are reported via `chain-error`: either a shared `fault` (see doc 00 and ADR-0011) or a structured `rpc` case carrying the node code and decoded revert bytes - the 0.1 `json-rpc-error` shape is gone. Modules match on the `fault` case (`unavailable`, `rate-limited`, `timeout`, `denied`, `invalid-input`, ...) for retry/backoff, and on the `rpc` case to decode a revert without parsing numeric JSON-RPC codes by hand.
 
 The `types` interface now exposes the shared `fault` / `rate-limit`. The `local-store`, `remote-store`, `messaging`, and `logging` interfaces are unchanged in shape (the first three report `fault` directly).
 
@@ -1231,10 +1231,6 @@ The primary trade-off is **type safety at the WIT boundary**: JSON strings vs. s
 
 The compile-time guarantee that a module can only call methods in the WIT is traded for a runtime allowlist. Given that the Component Model already provides structural sandboxing (the module can only call `chain::request`, not arbitrary network I/O), and the allowlist is enforced at the host boundary before any RPC call is made, this is a sound trade-off.
 
-## Migration Path
-
-For modules and embedders moving from 0.1 to 0.2, follow the [Migration Guide](migration/0.1-to-0.2.md). In summary: the early 0.1 `blockchain` sketch was replaced by `csn` later in 0.1 and is now `chain` in 0.2; the SDK's `block_on` is now hidden behind the `#[nexum::module]` macro; and each interface returns its own typed error over the shared `fault` vocabulary rather than a per-protocol error type.
-
 ## Summary
 
 | Component | What 0.2 ships |
diff --git a/docs/08-platform-generalisation.md b/docs/08-platform-generalisation.md
index 30c1f8b7..110bf3c0 100755
--- a/docs/08-platform-generalisation.md
+++ b/docs/08-platform-generalisation.md
@@ -374,7 +374,7 @@ Every platform implements this trivially. On server: `tracing` crate. On mobile:
 ### Universal World Definition
 
 ```wit
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 interface types {
     type chain-id = u64;
@@ -581,7 +581,7 @@ The host loads `index.html` into a WebView and injects the bridge JavaScript tha
 Domain-specific interfaces extend the universal layer for particular use cases. The pattern:
 
 ```wit
-package shepherd:cow@0.2.0;
+package shepherd:cow@0.1.0;
 
 interface cow-api {
     use nexum:host/types.{chain-id, fault};
@@ -880,7 +880,7 @@ Any platform that wants to run modules must implement the **Host Adapter** - the
 
 ### Required Behaviours
 
-In 0.2 each interface returns its own typed error over the shared `fault` vocabulary (`unsupported`, `unavailable`, `denied`, `rate-limited`, `timeout`, `invalid-input`, `internal`). The fault case is normative - embedders MUST pick the most specific case for each backend failure. See ADR-0011 and the [migration guide §2](migration/0.1-to-0.2.md#2-error-model-unification-both) for the embedder-side mapping table.
+Each interface returns its own typed error over the shared `fault` vocabulary (`unsupported`, `unavailable`, `denied`, `rate-limited`, `timeout`, `invalid-input`, `internal`). The fault case is normative - embedders MUST pick the most specific case for each backend failure. See ADR-0011 for the embedder-side mapping table.
 
 **`chain::request` / `chain::request-batch`** (Chain)
 - MUST forward the JSON-RPC request to a provider for the given chain.
@@ -993,17 +993,6 @@ A module author building a generic blockchain automation module depends only on
 
 For **non-Rust** module authors (JavaScript, Python, Go, C++), the SDK is unnecessary - they use `wit-bindgen` directly against the WIT package for their target world. The WIT is the universal contract; the SDK is a Rust ergonomics layer on top.
 
-## Migration from 0.1
-
-For the full 0.1 → 0.2 rename and behaviour change list, see the [Migration Guide](migration/0.1-to-0.2.md). The main themes:
-
-- WIT package `web3:runtime` → `nexum:host`; interfaces `csn` → `chain` and `msg` → `messaging`; worlds `headless-module` → `event-module` and `shepherd-module` → `shepherd`.
-- CoW `cow` + `order` interfaces merged into `cow-api`.
-- Each interface returns its own typed error over the shared `fault` vocabulary instead of five per-protocol error types.
-- The `event-module` world imports the six primitives the docs always claimed (0.1's WIT was missing `identity` from the world definition).
-- Manifest: `wasm = ...` → `component = ...`; `[[subscribe]]` → `[[subscription]]` with `kind` instead of `type`; new `[capabilities]` section drives optional/required imports; `[config]` values are now typed.
-- Additive: the `http` capability (serviced by wasi:http, no new `nexum:host` WIT), `chain::request-batch`, and the experimental `query-module` world.
-
 ## Summary
 
 ### Primitive Taxonomy
diff --git a/docs/adr/0001-engine-toml-separate-from-nexum-toml.md b/docs/adr/0001-engine-toml-separate-from-nexum-toml.md
index 2c294279..5dee12b9 100644
--- a/docs/adr/0001-engine-toml-separate-from-nexum-toml.md
+++ b/docs/adr/0001-engine-toml-separate-from-nexum-toml.md
@@ -30,7 +30,7 @@ The engine config carries the path to each module's manifest; the two never coll
 ## Consequences
 
 - A deployment needs both files. A missing `engine.toml` falls back to "no chains, default state_dir" - the example logging module still runs; cow-api / chain backends report `unsupported`.
-- A missing `module.toml` triggers the 0.1-compat deprecation warning in `manifest::fallback_manifest()` (defined in `crates/nexum-engine/src/manifest.rs`) and treats every linked capability as required. This fallback is scheduled for removal in 0.3 per `docs/migration/0.1-to-0.2.md`.
+- A missing `module.toml` triggers the 0.1-compat deprecation warning in `manifest::fallback_manifest()` (defined in `crates/nexum-engine/src/manifest.rs`) and treats every linked capability as required. This fallback is scheduled for removal in 0.3.
 - Module-bundle redistribution carries `module.toml` with the artifact; engines do not need to ship templates.
 - Future content-addressed module distribution (0.3) embeds `module.toml` in the bundle hash; `engine.toml` references modules by content address rather than filesystem path. The split survives that migration unchanged.
 - Implementation impact: `crates/nexum-engine/src/manifest.rs` and `engine_config.rs` need to update the filename lookup from `nexum.toml` to `module.toml`. The 0.1-compat fallback in `manifest::fallback_manifest()` should accept both names during the transition; after 0.3 only `module.toml` is recognised.
diff --git a/docs/adr/0006-cow-twap-ethflow-host-helpers.md b/docs/adr/0006-cow-twap-ethflow-host-helpers.md
index 96f8d02b..a76a9faa 100644
--- a/docs/adr/0006-cow-twap-ethflow-host-helpers.md
+++ b/docs/adr/0006-cow-twap-ethflow-host-helpers.md
@@ -39,7 +39,7 @@ An EthFlow module's `on_event(log)` handler decodes the `OrderPlacement` event w
 
 ## Consequences
 
-- `shepherd:cow@0.2.0` keeps `cow-api` as its only interface. No new WIT files in this ADR.
+- `shepherd:cow@0.1.0` keeps `cow-api` as its only interface. No new WIT files in this ADR.
 - `KNOWN_CAPABILITIES` in `crates/nexum-engine/src/manifest.rs` does **not** gain `"twap"` or `"ethflow"` entries. Modules declare the universal capabilities they actually use: `chain`, `local-store`, `logging`, `cow-api`.
 - Modules ship larger (~150 LOC each estimated, up from the ~30 LOC the host-helper design implied), because event decoding, eth_call orchestration, OrderCreation construction, and error-hint interpretation now live in guest code. This is the explicit trade-off: more code per module, less coupling, more freedom for different strategies to coexist.
 - Different TWAP polling strategies can coexist as different modules. Operators choose which to load via `engine.toml`'s `[[modules]]` array.
diff --git a/docs/diagrams/diagrams.md b/docs/diagrams/diagrams.md
index a9d6c21a..8e67ba53 100644
--- a/docs/diagrams/diagrams.md
+++ b/docs/diagrams/diagrams.md
@@ -15,7 +15,7 @@ graph TD
     ET["engine.toml  ·  module.toml\n(operator config + module manifest)"]
     SUP["Supervisor::boot"]
     POOLS["ProviderPool  ·  OrderBookPool  ·  LocalStore"]
-    HS["HostState  (per module)\nnexum:host@0.2.0  +  shepherd:cow@0.2.0"]
+    HS["HostState  (per module)\nnexum:host@0.1.0  +  shepherd:cow@0.1.0"]
     EL["EventLoop  -  futures::stream::select_all\nfan-out block/chain-log streams to subscribers"]
     MODS["WASM Modules\ntwap.wasm  ·  eth-flow.wasm\n(self-contained protocol logic in guest)"]
     BC["Blockchain  (Sepolia / Mainnet / …)\nComposableCoW  ·  CowEthFlow  ·  RPC Node"]
@@ -161,8 +161,8 @@ Two WIT packages: the universal `nexum:host` and the CoW-specific `shepherd:cow`
 
 ```mermaid
 graph TD
-    NH["nexum:host@0.2.0\n(universal - no CoW knowledge)"]
-    SC["shepherd:cow@0.2.0\n(CoW Protocol extensions)"]
+    NH["nexum:host@0.1.0\n(universal - no CoW knowledge)"]
+    SC["shepherd:cow@0.1.0\n(CoW Protocol extensions)"]
 
     NH --> n1["chain  ✅ implemented\nrequest(chain-id, method, params)\nrequest-batch(chain-id, requests)\n - \nsubscribe-blocks · subscribe-logs →\n  engine-managed via module.toml subscriptions\nregister-address · unregister-address →\n  🕓 deferred to 0.3 (ADR-0008)"]
     NH --> n2["local-store  ✅ implemented\nget(key) · set(key, value)\ndelete(key) · list-keys(prefix)\nnamespacing: 32-byte hash prefix (ADR-0003)"]
@@ -182,13 +182,13 @@ graph TD
 
 | Interface | What it does |
 |---|---|
-| **nexum:host@0.2.0** | The base WIT package. Any module running in the engine - CoW-aware or not - imports from here. Defines shared types (`chain-id`, `chain-log`, `fault`) used by both packages. |
+| **nexum:host@0.1.0** | The base WIT package. Any module running in the engine - CoW-aware or not - imports from here. Defines shared types (`chain-id`, `chain-log`, `fault`) used by both packages. |
 | **chain** | Reads from the blockchain via JSON-RPC. `request` sends a single call; `request-batch` sends several in one round-trip. **Subscriptions are not callable WIT functions** - they are declared in `module.toml` and opened by the engine at boot. Dynamic `register-address` for factory patterns is deferred to 0.3 (ADR-0008). |
 | **local-store** | Persistent key-value storage that survives restarts. Operations: `get(key)`, `set(key, value)`, `delete(key)`, `list-keys(prefix)`. The host prefixes every key with a 32-byte deterministic namespace (`keccak256(module_name)` locally, or `ens_namehash(name)` when ENS-loaded) so modules are fully isolated and the namespace cannot be spoofed (ADR-0003). |
 | **identity · messaging · remote-store** | Capabilities stubbed at 0.2 - they return `Unsupported`. `identity` will provide keystore-backed signing. `messaging` will send Waku messages. `remote-store` will read/write Swarm/IPFS. |
 | **logging** | Lightweight utility. `logging` emits to the engine's `tracing` subscriber (inherits `RUST_LOG` filters). Time and secure randomness are available ambiently via `wasi:clocks` and `wasi:random`. |
 | **(outbound HTTP)** | Not a `nexum:host` interface: a module that declares the `http` capability imports the standard `wasi:http/outgoing-handler`, and the host checks every outgoing request against the manifest's `[capabilities.http].allow` list before any connection is made. |
-| **shepherd:cow@0.2.0** | The CoW Protocol extension package. Imports `nexum:host/types` for shared types so modules don't re-define `chain-id` or `chain-log`. Only CoW-aware modules need to import this package. Contains exactly **one** interface in 0.2: `cow-api`. |
+| **shepherd:cow@0.1.0** | The CoW Protocol extension package. Imports `nexum:host/types` for shared types so modules don't re-define `chain-id` or `chain-log`. Only CoW-aware modules need to import this package. Contains exactly **one** interface in 0.2: `cow-api`. |
 | **cow-api** | Generic orderbook access. `request` is a raw REST passthrough (returns JSON string). `submit-order` takes raw order bytes and returns a `result<string, cow-api-error>` where the string is the order UID. Routes through the engine's `OrderBookPool`. This is the only protocol-level CoW interface in 0.2 - the boundary between "what CoW Protocol *is*" (orderbook submission, order types) and "what's implemented *on top* of CoW" (TWAP polling, EthFlow event handling). |
 | **(no twap interface)** | Per ADR-0006, no specialised TWAP host interface exists. The TWAP module implements polling, decoding, and submission entirely in guest code, using `chain.request` for `eth_call`, `local-store` for state, `alloy_sol_types` (in-module) for ABI decoding, `cowprotocol` types for `OrderCreation`, and `cow-api.submit-order` for orderbook submission. Multiple TWAP strategies can coexist as separate modules with different polling policies and error tolerances. |
 | **(no ethflow interface)** | Per ADR-0006, no specialised EthFlow host interface exists. The EthFlow module decodes `OrderPlacement` directly in guest code via `alloy_sol_types`, constructs the `OrderCreation` with the EIP-1271 signing scheme via `cowprotocol` types, and submits via `cow-api`. |
diff --git a/docs/migration/0.1-to-0.2.md b/docs/migration/0.1-to-0.2.md
deleted file mode 100644
index 3b5889ef..00000000
--- a/docs/migration/0.1-to-0.2.md
+++ /dev/null
@@ -1,526 +0,0 @@
-# Migrating from Nexum 0.1 to 0.2
-
-Nexum 0.2 is a single coordinated breaking-change release. It does the renames, the error-model unification, the missing primitives, and the capability-negotiation work in one window so module authors only pay the migration tax once. There will not be another breaking release of comparable scope before 1.0.
-
-This guide is written for two audiences:
-
-- **Module authors** - you write WASM components that import the Nexum WIT.
-- **Host embedders** - you build the runtime that loads modules (the server daemon, a mobile wallet, a browser host).
-
-Each section is tagged `[author]`, `[embedder]`, or `[both]`.
-
----
-
-## TL;DR - what changed [both]
-
-| Area | 0.1 | 0.2 |
-|---|---|---|
-| WIT package | `web3:runtime` | `nexum:host` |
-| Consensus interface | `csn` | `chain` |
-| Messaging interface | `msg` | `messaging` |
-| Default world | `headless-module` | `event-module` |
-| CoW world | `shepherd:cow/shepherd-module` | `shepherd:cow/shepherd` |
-| CoW interfaces | `cow` + `order` | `cow-api` (merged) |
-| Feed methods | `feed-get` / `feed-set` | `read-feed` / `write-feed` |
-| Event variants | `block-data` / `log-entry` / `message-data` / `timer(u64)` | `block` / `log` / `message` / `tick { fired-at }` |
-| Errors | 5 different shapes + bare `string` | per-interface typed errors over a shared `fault` vocabulary |
-| Capabilities | All six imports mandatory | Manifest-negotiated, optional imports trap on call |
-| Engine crate | `nxm-engine` | `nexum-engine` |
-| Manifest file | `nexum.toml` (some docs said `shepherd.toml`) | `nexum.toml` (canonical) |
-| Manifest field | `wasm = "sha256:..."` | `component = "sha256:..."` |
-| Manifest section | `[[subscribe]]` | `[[subscription]]` |
-| Config type | `list<tuple<string, string>>` (stringified) | unchanged in 0.2; typed variant on the 0.3 roadmap |
-| New capabilities | - | `http` (wasi:http, allowlisted); time and randomness are ambient via wasi:clocks / wasi:random |
-| New RPC method | - | `chain::request-batch` (additive) |
-| New world | - | `query-module` (experimental, no host impl shipped) |
-
-If you only do four things: update your `nexum.toml`, run the sed cheat-sheet at the bottom, replace your error handling with the new `fault` vocabulary, and declare your capabilities explicitly. Everything else is mechanical.
-
----
-
-## 1. WIT renames [author]
-
-### Package rename
-
-```diff
-- use web3:runtime/types.{config, event};
-- use web3:runtime/chain.{chain-id};
-+ use nexum:host/types.{config, event};
-+ use nexum:host/chain.{chain-id};
-```
-
-Why: `web3:` precommitted the engine to crypto-only branding. The package is now named after the engine; web3-specific capabilities live inside it as interfaces.
-
-### Interface renames
-
-| 0.1 | 0.2 | Rationale |
-|---|---|---|
-| `csn` | `chain` | `csn` was unreadable; `chain.request(chainId, method, params)` reads itself. |
-| `msg` | `messaging` | `msg` collided with its own `message` record; ambiguous in non-Rust bindings. |
-| `cow` + `order` | `cow-api` (one interface) | `cow::cow::request` triple-stutter eliminated; `order::submit` merged as `cow-api::submit-order`. |
-
-### World renames
-
-```diff
-- world headless-module {
-+ world event-module {
-      import chain;
-      import identity;          // NOTE: was missing from 0.1 WIT; now present
-      import local-store;
-      import remote-store;
-      import messaging;
-      import logging;
-      export init: func(config: config) -> result<_, string>;
-      export on-event: func(event: event) -> result<_, string>;
-  }
-```
-
-```diff
-- world shepherd-module {
--     include headless-module;
--     import cow;
--     import order;
-+ world shepherd {
-+     include event-module;
-+     import cow-api;
-  }
-```
-
-### Function renames (verb-first, fully spelled)
-
-```diff
-  interface remote-store {
--     feed-get: func(owner: list<u8>, topic: list<u8>) -> result<option<list<u8>>, store-error>;
--     feed-set: func(topic: list<u8>, data: list<u8>) -> result<list<u8>, store-error>;
-+     read-feed: func(owner: list<u8>, topic: list<u8>) -> result<option<list<u8>>, fault>;
-+     write-feed: func(topic: list<u8>, data: list<u8>) -> result<list<u8>, fault>;
-  }
-```
-
-### Type and field renames
-
-```diff
-  interface types {
--     record block-data { ... }
--     record log-entry  { ..., tx-hash: list<u8>, ... }
--     record message-data { ... }
--     variant event {
--         block(block-data),
--         logs(list<log-entry>),
--         timer(u64),
--         message(message-data),
--     }
-+     record block { ... }
-+     record log   { ..., transaction-hash: list<u8>, ... }
-+     record message { ... }
-+     record tick { fired-at: u64 }            // milliseconds since Unix epoch, UTC
-+     variant event {
-+         block(block),
-+         logs(list<log>),
-+         tick(tick),
-+         message(message),
-+     }
-  }
-```
-
-Two semantic notes:
-
-- All `u64` timestamps in 0.2 are **milliseconds since Unix epoch, UTC**. The 0.1 WIT did not specify a unit and several sources used seconds. Audit any timestamp arithmetic you do.
-- `tick` (formerly `timer`) is now a record, not a bare `u64`. In bindings it reads `event.tick.firedAt` instead of `event.timer === 1700000000`.
-
-> **Breaking: the chain-event log is now `chain-log`.** The `log` record and the `logs(list<log>)` event arm shown above have been renamed to `chain-log` and `chain-logs(chain-logs)` so the on-chain event vocabulary no longer collides with the diagnostics logging pipeline (`nexum:host/logging`, `[limits.logs]`), which is untouched. Three consequences: a manifest with `kind = "log"` fails load with an unknown-kind error naming the valid set (`block`, `chain-log`, `cron`); a component built against the old world's `log` record or `logs` arm no longer links against the current world (rebuild against the renamed WIT); and guest strategy handlers rename `on_logs` to `on_chain_logs`. The `block`, `tick`, and `message` arms are unchanged.
-
-> **Breaking: the chain-log record now carries the full RPC log shape.** The record was reshaped to mirror `alloy_rpc_types_eth::Log` field for field so a guest reconstructs the native alloy log without loss: `block-hash`, `block-timestamp`, `transaction-index`, and `removed` are added; `log-index` and `transaction-index` widen to `u64`; and the block-scoped fields become `option<>` (absent on a pending log). The chain id moves off the per-log record onto a new `chain-logs { chain-id, logs }` batch that the `chain-logs` event arm now wraps, since a delivery always shares one chain and the alloy log type carries no chain id of its own. Guests receive `nexum_sdk::events::Log` (alloy's RPC log) directly and decode `sol!` events against `log.inner`; the SDK bind macro emits the WIT-record-to-alloy conversion, so module glue maps a batch straight to `Vec<Log>`.
-
----
-
-## 2. Error model unification [both]
-
-The five 0.1 error shapes (`json-rpc-error`, `identity-error`, `msg-error`, `store-error`, `api-error`) plus bare `string` errors give way to the WASI idiom: each interface declares its own typed error, and the errors share one payload-bearing `fault` vocabulary for the cross-domain cases (see [ADR-0011](../adr/0011-per-interface-typed-errors.md)).
-
-```wit
-interface types {
-    // The shared cross-domain vocabulary. Each payload-bearing case
-    // carries a human-readable detail; rate-limited carries backoff.
-    variant fault {
-        unsupported(string),      // capability declared but not provisioned
-        unavailable(string),      // capability exists, backend is down/offline
-        denied(string),           // user or policy rejected
-        rate-limited(rate-limit),
-        timeout,
-        invalid-input(string),
-        internal(string),         // host bug
-    }
-
-    record rate-limit {
-        retry-after-ms: option<u64>,
-    }
-}
-```
-
-Interfaces with nothing to add report `fault` directly (identity, local-store, remote-store, messaging, and the module exports). A richer interface embeds `fault` as one case of its own variant and adds the cases only it needs: `chain-error` adds an `rpc` case carrying the node code and decoded revert bytes; `cow-api-error` adds `http` and `rejected`.
-
-```wit
-interface chain {
-    record rpc-error { code: s32, message: string, data: option<list<u8>> }
-    variant chain-error { fault(fault), rpc(rpc-error) }
-}
-```
-
-### Author migration
-
-The stringly `domain`/`code` cross-check is gone; dispatch on the typed variant instead.
-
-```diff
-- match chain::request(1, "eth_call", params) {
--     Ok(s) => parse(s),
--     Err(JsonRpcError { code, message, .. }) if code == -32000 => retry(),
--     Err(e) => bail!("rpc failed: {}", e.message),
-- }
-+ use nexum_sdk::host::{ChainError, Fault};
-+ match host.request(1, "eth_call", params) {
-+     Ok(s) => parse(s),
-+     Err(ChainError::Fault(Fault::Unavailable(_) | Fault::Timeout)) => retry(),
-+     Err(ChainError::Fault(Fault::RateLimited(rl))) => backoff(rl.retry_after_ms),
-+     Err(ChainError::Fault(Fault::Denied(_))) => abort("denied"),
-+     Err(ChainError::Rpc(rpc)) => decode_revert(rpc.data),  // node code + revert bytes
-+     Err(e) => bail!("{e}"),
-+ }
-```
-
-`local-store` errors are no longer bare `string`s: they are a plain `fault`. The interface is the failure domain, so the fault omits any subsystem tag; the case tells you whether you hit a quota (`invalid-input`), the backend is down (`unavailable`), etc.
-
-Module export signatures also change:
-
-```diff
-- export init: func(config: config) -> result<_, string>;
-- export on-event: func(event: event) -> result<_, string>;
-+ export init: func(config: config) -> result<_, fault>;
-+ export on-event: func(event: event) -> result<_, fault>;
-```
-
-Module identity is the supervisor's business, so module errors are plain `fault` cases; you no longer restate your module name or prefix your messages. A strategy that aggregates store and chain calls into one `fault` relies on the SDK's `From<ChainError> for Fault` fold for `?`.
-
-### Embedder migration
-
-Hosts implementing capability traits now return the interface's typed error. Chain calls return `chain-error` (use the `rpc` case for a structured JSON-RPC error; otherwise a `fault`); the rest return `fault` directly. Map each backend failure to the right case:
-
-| Backend signal | `fault` case |
-|---|---|
-| Connection refused / DNS fail / offline | `unavailable` |
-| Provider HTTP 4xx (other than 401/403/429) | `invalid-input` |
-| Provider HTTP 401/403 | `denied` |
-| Provider HTTP 429 | `rate-limited` |
-| Provider HTTP 5xx / timeout | `unavailable` or `timeout` (prefer the more specific) |
-| Structured JSON-RPC error (node `code`, revert `data`) | `chain-error.rpc` (not a fault) |
-| User rejected signing in wallet UI | `denied` |
-| Module asked for a capability the host doesn't provide | `unsupported` |
-| Bug / panic / internal invariant violated | `internal` |
-
----
-
-## 3. Manifest changes [both]
-
-### File rename
-
-If any code, docs, or scripts reference `shepherd.toml`, change to `nexum.toml`. This was a doc/code inconsistency in 0.1; canonical is `nexum.toml`.
-
-### Field and section renames
-
-```diff
-  [module]
-  name = "twap-monitor"
-  version = "0.3.0"
-- wasm = "sha256:9f86d081..."
-+ component = "sha256:9f86d081..."
-
-- [[subscribe]]
-- type = "block"
-- chain_id = 42161
-+ [[subscription]]
-+ kind = "block"
-+ chain_id = 42161
-```
-
-`type` → `kind` because `type` is reserved in several binding languages.
-
-`[module.resources]` (per-module resource caps) and a top-level `[chains]` table were dropped from this example rather than renamed: neither exists in 0.2's manifest schema - resource limits are global engine defaults today (`docs/02-modules-events-packaging.md`'s "Future direction" note), and chain ids are declared per-`[[subscription]]` (`chain_id`) rather than in a manifest-wide table.
-
-### Capability declaration (new, required)
-
-In 0.1 the world declared which interfaces a module imported, and instantiation failed if any were unsatisfied. In 0.2, imports declared `optional` in the manifest install a trap stub on the host side - calling them returns `fault.unsupported` rather than failing instantiation.
-
-```toml
-[capabilities]
-required = ["chain", "local-store", "logging"]
-optional = ["messaging", "remote-store"]  # module continues if host doesn't provide
-
-[capabilities.http]
-allow = ["api.coingecko.com", "discord.com"]
-```
-
-If you omit `[capabilities]` entirely, 0.2 falls back to "all imports required" - same as 0.1 behaviour - and prints a deprecation warning at load. Add the section in your next module update; the implicit-all fallback will be removed in 0.3.
-
-### Config: unchanged in 0.2
-
-`[config]` values continue to flow through to the guest as `list<tuple<string, string>>` - the host flattens TOML scalars (numbers, booleans) to their string form on the way through, same as 0.1. If you currently parse `"50"` into `u64`, that code continues to work unchanged:
-
-```rust
-let bps: u64 = config.iter()
-    .find(|(k, _)| k == "slippage_bps")
-    .map(|(_, v)| v.parse())
-    .transpose()?
-    .unwrap_or(50);
-```
-
-**Deferred to 0.3.** A typed `config-value` variant (string / integer / boolean / list) and a `#[derive(NexumConfig)]` helper are on the 0.3 roadmap, bundled with the manifest-parser work (see §3) so the typing story lands as one coherent feature.
-
----
-
-## 4. New capabilities (additive) [author]
-
-These didn't exist in 0.1 and don't break anything. Adopt them to remove workarounds.
-
-> **Breaking if you tracked the 0.2 drafts.** Earlier 0.2 drafts published `nexum:host/clock` and `nexum:host/http` WIT interfaces. Both are gone from the package: a component importing either no longer links against the 0.2 world, and a manifest declaring `clock` under `[capabilities]` fails load with an unknown-capability error. Time is ambient `wasi:clocks` with no declaration, and outbound HTTP is a `wasi:http` import (the SDK's `http::fetch` wraps it) plus the `http` capability declaration with a `[capabilities.http].allow` list, as described below. Components built against the final 0.1 surface are unaffected beyond the renames in this guide.
-
-### Time (ambient wasi:clocks)
-
-Wall-clock and monotonic time are WASI concerns, not `nexum:host` interfaces: the host links `wasi:clocks` into every module store, so a module reads time through any wasi:clocks binding with no capability declaration.
-
-Replaces the 0.1 workaround of "only know the time inside `on_block` via `block.timestamp`."
-
-### Randomness (ambient wasi:random)
-
-Secure randomness is a WASI concern, not a `nexum:host` interface: the host links `wasi:random` into every module store, so a module draws CSPRNG bytes through any wasi:random binding with no capability declaration.
-
-Replaces the 0.1 workaround of "you can't, period."
-
-### `http` (allowlisted)
-
-Outbound HTTP is the standard `wasi:http/outgoing-handler` interface, not a `nexum:host` one. The host links `wasi:http/{outgoing-handler, types}` into every module store; a module imports it with any wasi:http client binding and declares the `http` capability in its manifest.
-
-Requires a domain allowlist in `nexum.toml`:
-
-```toml
-[capabilities]
-optional = ["http"]
-
-[capabilities.http]
-allow = ["api.coingecko.com", "*.discord.com"]
-```
-
-Hosts MUST enforce the allowlist on every outgoing request (exact host match or `*.domain` suffix, case-insensitive, ports ignored); off-list hosts fail with the wasi:http `HTTP-request-denied` error code. The host does not follow redirects, so each hop is a fresh request checked against the same list. The operator sees the union of granted domains at module load. This replaces the 0.1 anti-pattern of tunnelling alerts through Waku.
-
-The host also bounds every request: guest-set request-options timeouts are clamped to the engine's `[limits.http]` maxima (unset ones inherit them), the whole exchange runs under a total deadline, and a response body beyond the configured cap fails with `HTTP-response-body-size`. The knobs and defaults live in `engine.example.toml`.
-
-### `chain::request-batch`
-
-```wit
-interface chain {
-    use types.{chain-id, fault};
-
-    record rpc-error { code: s32, message: string, data: option<list<u8>> }
-    variant chain-error { fault(fault), rpc(rpc-error) }
-
-    /// A single JSON-RPC request to be executed as part of a batch.
-    record rpc-request {
-        method: string,
-        params: string,
-    }
-
-    /// Result of a single request inside a batch. Each entry is independent;
-    /// one failing call does not abort the others.
-    variant rpc-result {
-        ok(string),
-        err(chain-error),
-    }
-
-    request: func(chain-id: chain-id, method: string, params: string)
-        -> result<string, chain-error>;
-
-    /// Hosts that cannot batch natively MUST fall back to sequential
-    /// `request` calls; the returned list is the same length as `requests`
-    /// and in the same order.
-    request-batch: func(chain-id: chain-id, requests: list<rpc-request>)
-        -> result<list<rpc-result>, chain-error>;
-}
-```
-
-Additive. The alloy-backed `HostTransport` now routes `RequestPacket::Batch` through `request-batch` - your existing `provider.multicall(...).await` actually batches on the wire in 0.2 (it didn't in 0.1, despite the docs).
-
----
-
-## 5. New world: `query-module` (experimental) [author]
-
-A request/response world for modules that aren't event-driven (wallet rule evaluators, signature validators, pricing oracles).
-
-```wit
-world query-module {
-    import local-store;
-    import logging;
-    // chain, identity, http, etc. are optional via manifest
-
-    export init: func(config: config) -> result<_, fault>;
-    export evaluate: func(input: list<u8>) -> result<list<u8>, fault>;
-}
-```
-
-**Status: WIT is published, no host implementation ships in 0.2.** The 0.2 server runtime only supports `event-module` and `shepherd`. The world is published so module authors can target it experimentally and so embedders building mobile/wallet hosts have a stable contract to implement against. Production support lands in 0.3.
-
-If you're writing a module that fits this shape, target it now and stub the host with `MockHost` for testing.
-
----
-
-## 6. Engine crate rename [embedder]
-
-```diff
-  [dependencies]
-- nxm-engine = "0.1"
-+ nexum-engine = "0.2"
-```
-
-The 0.1 release renamed `nexum-host` → `nxm-engine`. 0.2 reverses that to `nexum-engine` for consistency with `shepherd-sdk` / `shepherd-sdk-test` (and the future `nexum-sdk` / `cargo-nexum` direction described in doc 05).
-
-```diff
-- use nxm_engine::{Engine, Module};
-+ use nexum_engine::{Engine, Module};
-```
-
-The Rust API surface is otherwise unchanged in 0.2. The C ABI and `nexum-host` embedder facade (for non-Rust hosts) are explicitly **deferred to a later release** pending mobile validation; do not assume they exist in 0.2.
-
----
-
-## 7. SDK changes [author]
-
-### Rust SDK
-
-0.1 had no Rust SDK crate: modules called the wit-bindgen-generated
-imports directly and hand-wrote the per-cdylib `Guest` / `export!`
-glue. 0.2 ships `nexum-sdk` (host-neutral helpers) with
-`shepherd-sdk` layering the CoW Protocol surface on top. What that
-means for a module you are porting:
-
-- **Host traits.** Strategy code is written against the
-  `ChainHost` / `LocalStoreHost` / `LoggingHost` traits (plus
-  `CowApiHost` in `shepherd-sdk`) instead of the raw wit-bindgen
-  import shims; the `bind_host_via_wit_bindgen!` /
-  `bind_cow_host_via_wit_bindgen!` macros generate the adapter at
-  the cdylib boundary, and the `nexum-sdk-test` /
-  `shepherd-sdk-test` mocks slot in for native unit tests.
-- **Typed errors.** Handlers and host traits use the `Fault` /
-  `ChainError` / `CowApiError` vocabulary from §2 in place of 0.1's
-  bare strings.
-- **One attribute macro.** `#[nexum_sdk::module]` (a re-export of
-  `nexum_macros::module`) replaces the hand-written glue: applied to
-  an inherent `impl` block of named handlers (`init`, `on_block`,
-  `on_chain_logs`, `on_tick`, `on_message`), it emits the
-  `wit_bindgen::generate!` call, the host adapter, the `Guest` impl
-  dispatching to the handlers present, and `export!`. Handlers are
-  synchronous `fn`s; there is no `async` support, no `block_on`, and
-  no separate `#[shepherd::module]`.
-
-Earlier drafts of this section described a richer 0.2 surface
-(`provider()`, `Signer`, `Messaging`, `RemoteStore`, a hidden
-`HostTransport`); none of that shipped. See
-[doc 05](../05-sdk-design.md) for the SDK that exists.
-
-### Non-Rust SDKs
-
-The WIT renames propagate mechanically through `wit-bindgen`. Regenerate your bindings against the 0.2 WIT and your existing call sites - adjusted for the renames in §1 - will type-check.
-
----
-
-## 8. Mechanical rename cheat sheet [both]
-
-For mechanical search/replace in your codebase. Apply in order; some replacements depend on earlier ones.
-
-```bash
-# WIT package
-rg -l 'web3:runtime' | xargs sed -i 's/web3:runtime/nexum:host/g'
-
-# Interface names (do these before function names - some functions reference the old interface in paths)
-rg -l '\bcsn\b' | xargs sed -i 's/\bcsn\b/chain/g'
-rg -l '\bmsg\b' | xargs sed -i 's/\bmsg\b/messaging/g'
-
-# Worlds
-rg -l 'headless-module' | xargs sed -i 's/headless-module/event-module/g'
-rg -l 'headless_module' | xargs sed -i 's/headless_module/event_module/g'
-
-# CoW interface stutter
-rg -l '\bcow::cow::' | xargs sed -i 's/\bcow::cow::/cow_api::/g'
-# (manual: merge `order` imports into `cow-api`; rename `order::submit` to `cow-api::submit-order`)
-
-# Feed methods
-rg -l '\bfeed-get\b' | xargs sed -i 's/\bfeed-get\b/read-feed/g'
-rg -l '\bfeed-set\b' | xargs sed -i 's/\bfeed-set\b/write-feed/g'
-rg -l '\bfeed_get\b' | xargs sed -i 's/\bfeed_get\b/read_feed/g'
-rg -l '\bfeed_set\b' | xargs sed -i 's/\bfeed_set\b/write_feed/g'
-
-# Type renames
-rg -l '\bblock-data\b'   | xargs sed -i 's/\bblock-data\b/block/g'
-rg -l '\blog-entry\b'    | xargs sed -i 's/\blog-entry\b/log/g'
-rg -l '\bmessage-data\b' | xargs sed -i 's/\bmessage-data\b/message/g'
-rg -l '\btx-hash\b'      | xargs sed -i 's/\btx-hash\b/transaction-hash/g'
-rg -l '\btx_hash\b'      | xargs sed -i 's/\btx_hash\b/transaction_hash/g'
-
-# Crate rename (Cargo.toml + use statements)
-rg -l '\bnxm-engine\b' | xargs sed -i 's/\bnxm-engine\b/nexum-engine/g'
-rg -l '\bnxm_engine\b' | xargs sed -i 's/\bnxm_engine\b/nexum_engine/g'
-
-# Manifest section
-rg -l '\[\[subscribe\]\]' | xargs sed -i 's/\[\[subscribe\]\]/[[subscription]]/g'
-
-# Manifest field
-rg -l '^wasm = ' | xargs sed -i 's/^wasm = /component = /'
-```
-
-Things that **cannot** be sedded - do these by hand:
-
-- `timer(u64)` → `tick(tick)` with the new `tick { fired-at: u64 }` record. Call sites that pattern-match `Event::Timer(ts)` become `Event::Tick(tick) => tick.fired_at`.
-- Error handling. The five old error types are gone; you can't mechanically rewrite a `match` against `JsonRpcError { code, .. }` into the new typed variants (`ChainError::Rpc`, the `fault` cases). Do these per-call-site.
-- Splitting `cow` + `order` into a single `cow-api`. Rewrite the imports and adjust function paths.
-- Adding `[capabilities]` to `nexum.toml`. Declare what your module actually uses; this is a meaningful audit.
-
----
-
-## 9. Verification checklist [both]
-
-After running the renames:
-
-- [ ] `cargo check --workspace --all-targets` is clean (Rust + bindings).
-- [ ] `cargo check --target wasm32-wasip2 -p <your-module>` is clean.
-- [ ] `cargo test --workspace --no-fail-fast` passes.
-- [ ] Your bindgen invocations point at the package's own WIT dir (`wit/nexum-host/`) - or, when consuming both `nexum:host` and a domain-extension package, list both paths explicitly. The 0.1 vendored `deps/` pattern is no longer used in the reference repo.
-- [ ] `nexum.toml` has a `[capabilities]` section listing what the module uses.
-- [ ] `nexum.toml` references `component = "sha256:..."` not `wasm = ...`.
-- [ ] All `[[subscribe]]` sections renamed to `[[subscription]]` with `kind` (not `type`).
-- [ ] No remaining references to `web3:runtime`, `csn`, `msg`, `headless-module`, `nxm-engine`, `shepherd.toml`, `feed-get`/`feed-set`, `block-data`/`log-entry`/`message-data`, `tx-hash`.
-- [ ] All `Result<_, String>` from module exports replaced with `Result<_, fault>`.
-- [ ] Error matching code dispatches on the typed variant (`fault` cases, `ChainError::Rpc`), not protocol-specific error codes.
-- [ ] If you used `chrono`/timestamp arithmetic, audited for the seconds-vs-ms change (0.2 is always ms UTC).
-- [ ] If you used `provider.multicall(...).await`, confirmed it now actually batches on the wire (`chain::request-batch` shows in tracing).
-
-> **No `cargo nexum` toolchain in 0.2.** A `cargo-nexum` cargo subcommand (with `new`, `check`, `package`, `run --mock`, `migrate`) is on the 0.3 roadmap. Until then, use `cargo` directly and the `just` recipes in the reference repo.
-
----
-
-## 10. Deprecation policy going forward [both]
-
-0.2 is the breaking-change window. The contracts below are stable starting at 0.2.0:
-
-- WIT package name `nexum:host` and interface names within it.
-- The per-interface typed errors over the shared `fault` vocabulary.
-- The `nexum.toml` manifest schema.
-- The `#[nexum::module]` macro surface.
-
-Additive changes (new interfaces, new manifest fields, new SDK helpers) may land in any 0.2.x release. Existing identifiers will not be removed or repurposed before 1.0 without a deprecation cycle of at least one minor release.
-
-The mobile/wallet host story (`query-module` production support, C ABI, `nexum-host` embedder crate) is on the 0.3 roadmap, conditional on a named design partner. The 0.2 `query-module` WIT is an experimental option, not a stable contract; expect changes to its error variants and request/response payload conventions before the 0.3 host ships.
-
----
-
-## 11. Getting help
-
-- Open an issue at the repo with the `migration-0.2` label.
-- The full 0.2 WIT lives in `wit/nexum-host/` (formerly `wit/web3-runtime/`).
-- The §8 cheat sheet has the mechanical sed commands; a `cargo nexum migrate --from 0.1` codemod that wraps them safely is planned for 0.3 alongside the rest of the `cargo-nexum` toolchain.
diff --git a/docs/operations/m3-edge-case-validation.md b/docs/operations/m3-edge-case-validation.md
index c31cda38..62b681ab 100644
--- a/docs/operations/m3-edge-case-validation.md
+++ b/docs/operations/m3-edge-case-validation.md
@@ -79,7 +79,7 @@ Error: load module target/wasm32-wasip2/release/stop_loss.wasm
 
 Caused by:
     0: capability violation in target/wasm32-wasip2/release/stop_loss.wasm
-    1: component imports `cow-api` (shepherd:cow/cow-api@0.2.0) but it
+    1: component imports `cow-api` (shepherd:cow/cow-api@0.1.0) but it
        is not listed in [capabilities].required or [capabilities].optional
 ```
 
diff --git a/docs/sdk.md b/docs/sdk.md
index 14d21da7..b27045af 100644
--- a/docs/sdk.md
+++ b/docs/sdk.md
@@ -42,11 +42,11 @@ macros generate that adapter). The traits in
 
 | Trait | Mirrors | What it does |
 |---|---|---|
-| `ChainHost` | `nexum:host/chain@0.2.0` | JSON-RPC dispatch (`eth_call`, `eth_getLogs`, …) |
-| `LocalStoreHost` | `nexum:host/local-store@0.2.0` | Per-module key-value store |
-| `LoggingHost` | `nexum:host/logging@0.2.0` | Structured log lines tagged by module |
+| `ChainHost` | `nexum:host/chain@0.1.0` | JSON-RPC dispatch (`eth_call`, `eth_getLogs`, …) |
+| `LocalStoreHost` | `nexum:host/local-store@0.1.0` | Per-module key-value store |
+| `LoggingHost` | `nexum:host/logging@0.1.0` | Structured log lines tagged by module |
 | `Host` | supertrait | Bundles the three core traits; blanket impl |
-| `CowApiHost` (shepherd-sdk) | `shepherd:cow/cow-api@0.2.0` | Orderbook submission (`POST /api/v1/orders`) |
+| `CowApiHost` (shepherd-sdk) | `shepherd:cow/cow-api@0.1.0` | Orderbook submission (`POST /api/v1/orders`) |
 | `CowHost` (shepherd-sdk) | supertrait | `Host` + `CowApiHost` for orderbook strategies |
 
 A module declaring `[capabilities].required = ["chain", "local-store",
diff --git a/wit/nexum-host/chain.wit b/wit/nexum-host/chain.wit
index 97055e5a..1d812dc6 100644
--- a/wit/nexum-host/chain.wit
+++ b/wit/nexum-host/chain.wit
@@ -1,4 +1,4 @@
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 interface chain {
     use types.{chain-id, fault};
diff --git a/wit/nexum-host/event-module.wit b/wit/nexum-host/event-module.wit
index db8d7f5a..277134a9 100644
--- a/wit/nexum-host/event-module.wit
+++ b/wit/nexum-host/event-module.wit
@@ -1,4 +1,4 @@
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 /// Event-driven module — automation, background processing.
 /// No UI capabilities. Runs on any conforming host.
diff --git a/wit/nexum-host/identity.wit b/wit/nexum-host/identity.wit
index 09dac970..2e82c9fe 100644
--- a/wit/nexum-host/identity.wit
+++ b/wit/nexum-host/identity.wit
@@ -1,4 +1,4 @@
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 /// Identity / signing capability.
 ///
diff --git a/wit/nexum-host/local-store.wit b/wit/nexum-host/local-store.wit
index 6c5a22b3..d0b54921 100644
--- a/wit/nexum-host/local-store.wit
+++ b/wit/nexum-host/local-store.wit
@@ -1,4 +1,4 @@
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 interface local-store {
     use types.{fault};
diff --git a/wit/nexum-host/logging.wit b/wit/nexum-host/logging.wit
index 37e9193f..8cd98140 100644
--- a/wit/nexum-host/logging.wit
+++ b/wit/nexum-host/logging.wit
@@ -1,4 +1,4 @@
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 interface logging {
     enum level {
diff --git a/wit/nexum-host/messaging.wit b/wit/nexum-host/messaging.wit
index 7f8e4bf6..30777ca7 100644
--- a/wit/nexum-host/messaging.wit
+++ b/wit/nexum-host/messaging.wit
@@ -1,4 +1,4 @@
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 interface messaging {
     use types.{fault, message};
diff --git a/wit/nexum-host/query-module.wit b/wit/nexum-host/query-module.wit
index 7dd52600..ffb29b87 100644
--- a/wit/nexum-host/query-module.wit
+++ b/wit/nexum-host/query-module.wit
@@ -1,4 +1,4 @@
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 /// Query module — synchronous, side-effect-free evaluation.
 ///
diff --git a/wit/nexum-host/remote-store.wit b/wit/nexum-host/remote-store.wit
index 731ae370..39b36bae 100644
--- a/wit/nexum-host/remote-store.wit
+++ b/wit/nexum-host/remote-store.wit
@@ -1,4 +1,4 @@
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 interface remote-store {
     use types.{fault};
diff --git a/wit/nexum-host/types.wit b/wit/nexum-host/types.wit
index b4349717..8e834263 100644
--- a/wit/nexum-host/types.wit
+++ b/wit/nexum-host/types.wit
@@ -1,4 +1,4 @@
-package nexum:host@0.2.0;
+package nexum:host@0.1.0;
 
 /// Common types shared across all runtime interfaces.
 ///
diff --git a/wit/shepherd-cow/cow-api.wit b/wit/shepherd-cow/cow-api.wit
index 5c7e379d..4d0df3ae 100644
--- a/wit/shepherd-cow/cow-api.wit
+++ b/wit/shepherd-cow/cow-api.wit
@@ -1,7 +1,7 @@
-package shepherd:cow@0.2.0;
+package shepherd:cow@0.1.0;
 
 interface cow-api {
-    use nexum:host/types@0.2.0.{chain-id, fault};
+    use nexum:host/types@0.1.0.{chain-id, fault};
 
     /// A non-2xx reply from the orderbook that carries no typed
     /// rejection envelope. `body` is the raw response text, foreign
diff --git a/wit/shepherd-cow/cow-ext.wit b/wit/shepherd-cow/cow-ext.wit
index ed71da3b..d78889c8 100644
--- a/wit/shepherd-cow/cow-ext.wit
+++ b/wit/shepherd-cow/cow-ext.wit
@@ -1,4 +1,4 @@
-package shepherd:cow@0.2.0;
+package shepherd:cow@0.1.0;
 
 /// Extension world: the cow-api interface alone, wired into a module
 /// linker by the cow extension. Kept separate from `shepherd` so the
diff --git a/wit/shepherd-cow/shepherd.wit b/wit/shepherd-cow/shepherd.wit
index 88aff143..729bcd0f 100644
--- a/wit/shepherd-cow/shepherd.wit
+++ b/wit/shepherd-cow/shepherd.wit
@@ -1,7 +1,7 @@
-package shepherd:cow@0.2.0;
+package shepherd:cow@0.1.0;
 
 /// Shepherd module — event-driven Nexum module with CoW Protocol extensions.
 world shepherd {
-    include nexum:host/event-module@0.2.0;
+    include nexum:host/event-module@0.1.0;
     import cow-api;
 }
diff --git a/wit/videre-venue/venue.wit b/wit/videre-venue/venue.wit
index 6516586c..695da46a 100644
--- a/wit/videre-venue/venue.wit
+++ b/wit/videre-venue/venue.wit
@@ -28,10 +28,10 @@ interface adapter {
 /// structurally cannot touch host key material or persistent state. Outbound
 /// HTTP is wasi:http, linked separately and allowlisted per adapter.
 world venue-adapter {
-    use nexum:host/types@0.2.0.{config, fault};
+    use nexum:host/types@0.1.0.{config, fault};
 
-    import nexum:host/chain@0.2.0;
-    import nexum:host/messaging@0.2.0;
+    import nexum:host/chain@0.1.0;
+    import nexum:host/messaging@0.1.0;
 
     /// Configure the adapter from its `[config]` before any submission.
     export init: func(config: config) -> result<_, fault>;