diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 7d954206..8b5383e8 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -53,9 +53,7 @@ If checked, describe the breaking changes and migration path:
 
 ## Documentation
 
-- [ ] README.md updated
-- [ ] DEVELOPER_GUIDE.md updated (if applicable)
-- [ ] API_REFERENCE.md updated (if applicable)
+- [ ] README.md updated (if applicable)
 - [ ] No documentation changes needed
 
 ## Screenshots (if applicable)
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1a11a205..3896d9b2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -4,6 +4,14 @@ on:
   push:
   pull_request:
 
+# Harden against transient crates.io download failures on the runners
+# (e.g. "curl failed [55] ... SSL_ERROR_SYSCALL"). Disabling HTTP/2 multiplexing
+# and raising the retry count is the standard mitigation for that error.
+env:
+  CARGO_NET_RETRY: "10"
+  CARGO_HTTP_MULTIPLEXING: "false"
+  CARGO_TERM_COLOR: always
+
 jobs:
   fmt:
     name: Rustfmt
diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml
new file mode 100644
index 00000000..a704529f
--- /dev/null
+++ b/.github/workflows/fuzz.yml
@@ -0,0 +1,57 @@
+name: Fuzz
+
+on:
+  push:
+    paths:
+      - "src/utils/fuzzing.rs"
+      - "src/utils/state_migration.rs"
+      - "src/utils/mock_soroban.rs"
+      - "src/commands/fuzz.rs"
+      - "tests/contract_property_tests.rs"
+      - "fuzz/**"
+      - ".github/workflows/fuzz.yml"
+  pull_request:
+  schedule:
+    # Nightly guided-fuzzing run at 03:17 UTC.
+    - cron: "17 3 * * *"
+
+# Harden against transient crates.io download failures on the runners.
+env:
+  CARGO_NET_RETRY: "10"
+  CARGO_HTTP_MULTIPLEXING: "false"
+
+jobs:
+  property:
+    name: Property-Based & Engine Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Install system dependencies
+        run: sudo apt-get update && sudo apt-get install -y libudev-dev
+      - name: Property-based tests
+        run: cargo test --test contract_property_tests --locked
+      - name: Fuzzing engine unit tests
+        run: cargo test --locked fuzzing
+
+  cargo-fuzz:
+    name: Guided Fuzzing (nightly)
+    runs-on: ubuntu-latest
+    # Only run on the nightly schedule: guided fuzzing is slow and nightly +
+    # libFuzzer can be flaky, so it should not run (or appear) on every PR/push.
+    if: github.event_name == 'schedule'
+    # Non-blocking even when scheduled: failures should never gate the branch.
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+      - name: Install system dependencies
+        run: sudo apt-get update && sudo apt-get install -y libudev-dev
+      - name: Install cargo-fuzz
+        run: cargo install cargo-fuzz --locked
+      - name: Fuzz the WASM validator (time-boxed)
+        working-directory: fuzz
+        run: cargo +nightly fuzz run fuzz_wasm_validator -- -max_total_time=60
+      - name: Fuzz state diffing (time-boxed)
+        working-directory: fuzz
+        run: cargo +nightly fuzz run fuzz_state_diff -- -max_total_time=60
diff --git a/API_REFERENCE.md b/API_REFERENCE.md
deleted file mode 100644
index ef2d934b..00000000
--- a/API_REFERENCE.md
+++ /dev/null
@@ -1,1236 +0,0 @@
-# StarForge API Reference
-
-Complete reference for all StarForge commands, options, and utilities.
-
-> For a concise, navigable index of every CLI subcommand see [docs/COMMAND_REFERENCE.md](docs/COMMAND_REFERENCE.md).
-
-## Table of Contents
-
-1. [Command Line Interface](#command-line-interface)
-2. [Wallet Commands](#wallet-commands)
-3. [Template Commands](#template-commands)
-4. [Contract Commands](#contract-commands)
-5. [Network Commands](#network-commands)
-6. [Transaction Commands](#transaction-commands)
-7. [Utility Commands](#utility-commands)
-8. [Configuration](#configuration)
-9. [Exit Codes](#exit-codes)
-
----
-
-## Command Line Interface
-
-### Global Options
-
-```bash
-starforge [OPTIONS] <COMMAND>
-```
-
-| Option | Description |
-|--------|-------------|
-| `-q, --quiet` | Suppress ASCII banner and decorative output |
-| `-h, --help` | Print help information |
-| `-V, --version` | Print version information |
-
-### Environment Variables
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `STARFORGE_CONFIG_DIR` | Configuration directory | `~/.starforge` |
-| `STARFORGE_TELEMETRY` | Enable/disable telemetry | `true` |
-| `RUST_LOG` | Logging level | `info` |
-
----
-
-## Wallet Commands
-
-### `starforge wallet create`
-
-Create a new Stellar keypair and save it locally.
-
-**Usage:**
-```bash
-starforge wallet create <NAME> [OPTIONS]
-```
-
-**Arguments:**
-- `<NAME>` - Friendly name for the wallet (alphanumeric, dash, underscore)
-
-**Options:**
-- `--fund` - Fund the wallet via Friendbot immediately (testnet only)
-- `--network <NETWORK>` - Network to associate with wallet (`testnet`, `mainnet`)
-- `--encrypt` - Encrypt the secret key with a passphrase
-
-**Examples:**
-```bash
-# Create basic wallet
-starforge wallet create alice
-
-# Create and fund on testnet
-starforge wallet create deployer --fund
-
-# Create with encryption
-starforge wallet create secure-wallet --encrypt
-
-# Create on mainnet
-starforge wallet create mainnet-wallet --network mainnet
-```
-
-**Output:**
-```
-◆ Creating wallet 'alice'
-
-[1/2] Generating keypair…
-
-Public Key     : GABC...XYZ
-Secret Key     : Stored in plaintext (not recommended for mainnet).
-
-[2/2] Saving to ~/.starforge/config.toml…
-
-✓ Wallet 'alice' created and saved!
-
-View it with: starforge wallet show alice
-```
-
----
-
-### `starforge wallet list`
-
-List all saved wallets.
-
-**Usage:**
-```bash
-starforge wallet list
-```
-
-**Output:**
-```
-◆ Saved Wallets
-─────────────────────────────────────────────────────────────
-
-  1. alice [funded]
-     Key : GABC...XYZ
-     Net : testnet
-
-  2. bob [unfunded]
-     Key : GDEF...ABC
-     Net : testnet
-
-─────────────────────────────────────────────────────────────
-2 wallet(s) on testnet — ~/.starforge/config.toml
-```
-
----
-
-### `starforge wallet show`
-
-Show details of a saved wallet including live balance.
-
-**Usage:**
-```bash
-starforge wallet show <NAME> [OPTIONS]
-```
-
-**Arguments:**
-- `<NAME>` - Wallet name
-
-**Options:**
-- `--reveal` - Show the secret key in plaintext
-
-**Examples:**
-```bash
-# Show wallet details
-starforge wallet show alice
-
-# Reveal secret key
-starforge wallet show alice --reveal
-```
-
-**Output:**
-```
-◆ Wallet: alice
-─────────────────────────────────────────────────────────────
-
-Public Key     : GABC...XYZ
-Secret Key     : ******************** (--reveal to show)
-Network        : testnet
-Funded         : yes
-Created        : 2025-01-01T00:00:00Z
-
-─────────────────────────────────────────────────────────────
-
-Fetching live balance on testnet…
-
-XLM            : 10000.0000000 XLM
-```
-
----
-
-### `starforge wallet fund`
-
-Fund a wallet via Friendbot (testnet only).
-
-**Usage:**
-```bash
-starforge wallet fund <NAME>
-```
-
-**Arguments:**
-- `<NAME>` - Wallet name to fund
-
-**Example:**
-```bash
-starforge wallet fund alice
-```
-
----
-
-### `starforge wallet remove`
-
-Remove a wallet from local storage.
-
-**Usage:**
-```bash
-starforge wallet remove <NAME>
-```
-
-**Arguments:**
-- `<NAME>` - Wallet name to remove
-
-**Example:**
-```bash
-starforge wallet remove alice
-```
-
----
-
-### `starforge wallet rename`
-
-Rename a wallet.
-
-**Usage:**
-```bash
-starforge wallet rename <OLD_NAME> <NEW_NAME>
-```
-
-**Arguments:**
-- `<OLD_NAME>` - Current wallet name
-- `<NEW_NAME>` - New wallet name
-
-**Example:**
-```bash
-starforge wallet rename alice alice-testnet
-```
-
----
-
-### `starforge wallet export`
-
-Export a wallet to a JSON backup file.
-
-**Usage:**
-```bash
-starforge wallet export <NAME> --output <FILE>
-```
-
-**Arguments:**
-- `<NAME>` - Wallet name to export
-
-**Options:**
-- `--output <FILE>` - Output file path for the backup JSON
-
-**Example:**
-```bash
-starforge wallet export alice --output ./wallet-backup.json
-```
-
-**Notes:**
-- Secrets are written only to the backup file and are never printed to stdout.
-
----
-
-### `starforge wallet import`
-
-Import wallets from a JSON backup file.
-
-**Usage:**
-```bash
-starforge wallet import --file <FILE>
-```
-
-**Options:**
-- `--file <FILE>` - Path to a wallet backup JSON file
-
-**Example:**
-```bash
-starforge wallet import --file ./wallet-backup.json
-```
-
----
-
-### `starforge wallet sign`
-
-Sign an arbitrary message using a wallet.
-
-**Usage:**
-```bash
-starforge wallet sign <NAME> <MESSAGE> [OPTIONS]
-```
-
-**Arguments:**
-- `<NAME>` - Wallet name to use for signing
-- `<MESSAGE>` - Message to sign (UTF-8 string)
-
-**Options:**
-- `--hardware <DEVICE>` - Use hardware wallet (`ledger`, `trezor`)
-
-**Examples:**
-```bash
-# Sign with local key
-starforge wallet sign alice "Hello, Stellar!"
-
-# Sign with hardware wallet
-starforge wallet sign alice "Transaction data" --hardware ledger
-```
-
----
-
-### `starforge wallet multisig`
-
-Multi-signature account management.
-
-#### `starforge wallet multisig create`
-
-Create a multi-sig configuration.
-
-**Usage:**
-```bash
-starforge wallet multisig create <NAME> --threshold <N> --signers <WALLETS>
-```
-
-**Arguments:**
-- `<NAME>` - Multi-sig account name
-
-**Options:**
-- `--threshold <N>` - Required signature weight
-- `--signers <WALLETS>` - Comma-separated wallet names
-- `--network <NETWORK>` - Network override
-
-**Example:**
-```bash
-starforge wallet multisig create treasury \
-  --threshold 2 \
-  --signers alice,bob,charlie
-```
-
-#### `starforge wallet multisig sign`
-
-Sign a multi-sig transaction.
-
-**Usage:**
-```bash
-starforge wallet multisig sign <NAME> --transaction <FILE> [OPTIONS]
-```
-
-**Arguments:**
-- `<NAME>` - Multi-sig account name
-
-**Options:**
-- `--transaction <FILE>` - Path to transaction JSON
-- `--output <FILE>` - Output file (defaults to in-place update)
-
-**Example:**
-```bash
-starforge wallet multisig sign treasury --transaction tx.json
-```
-
-#### `starforge wallet multisig list`
-
-List multi-sig accounts.
-
-**Usage:**
-```bash
-starforge wallet multisig list
-```
-
-#### `starforge wallet multisig show`
-
-Show multi-sig account details.
-
-**Usage:**
-```bash
-starforge wallet multisig show <NAME>
-```
-
-#### `starforge wallet multisig submit`
-
-Submit a fully-signed multi-sig transaction.
-
-**Usage:**
-```bash
-starforge wallet multisig submit <NAME> --transaction <FILE> [OPTIONS]
-```
-
-**Options:**
-- `--transaction <FILE>` - Path to signed transaction JSON
-- `--network <NETWORK>` - Network to submit on
-
----
-
-## Template Commands
-
-### `starforge template init`
-
-Initialize template registry with example templates.
-
-**Usage:**
-```bash
-starforge template init
-```
-
-**Output:**
-```
-◆ Initialize Template Registry
-
-Adding example templates to the marketplace...
-
-✓ Added: uniswap-v2
-✓ Added: lending-pool
-✓ Added: governance
-✓ Added: multisig-wallet
-
-✓ Template registry initialized with 4 example templates
-
-Browse templates:
-  starforge template list
-  starforge template search defi
-```
-
----
-
-### `starforge template search`
-
-Search for templates in the marketplace.
-
-**Usage:**
-```bash
-starforge template search <QUERY> [OPTIONS]
-```
-
-**Arguments:**
-- `<QUERY>` - Search query (matches name, description, tags)
-
-**Options:**
-- `--tags <TAGS>` - Filter by tags (comma-separated)
-
-**Examples:**
-```bash
-# Search by keyword
-starforge template search defi
-
-# Search with tag filter
-starforge template search dex --tags amm,swap
-
-# Search for governance
-starforge template search governance
-```
-
-**Output:**
-```
-◆ Template Marketplace — Search
-Query          : defi
-─────────────────────────────────────────────────────────────
-
-Found 2 template(s):
-
-1. uniswap-v2 ✓
-   Uniswap V2 style automated market maker (AMM) DEX implementation
-   1.0.0 • Stellar Community • 42 downloads
-   Tags: defi, dex, amm, swap
-
-2. lending-pool ✓
-   Decentralized lending and borrowing protocol
-   1.0.0 • Stellar Community • 28 downloads
-   Tags: defi, lending, borrowing
-
-─────────────────────────────────────────────────────────────
-
-Use a template:
-  starforge new contract my-project --template uniswap-v2 --from marketplace
-```
-
----
-
-### `starforge template list`
-
-List all available templates.
-
-**Usage:**
-```bash
-starforge template list
-```
-
----
-
-### `starforge template show`
-
-Show details of a specific template.
-
-**Usage:**
-```bash
-starforge template show <NAME>
-```
-
-**Arguments:**
-- `<NAME>` - Template name
-
-**Example:**
-```bash
-starforge template show uniswap-v2
-```
-
-**Output:**
-```
-◆ Template: uniswap-v2
-─────────────────────────────────────────────────────────────
-
-uniswap-v2 ✓
-
-Description    : Uniswap V2 style automated market maker (AMM) DEX
-Version        : 1.0.0
-Author         : Stellar Community
-Downloads      : 42
-Tags           : defi, dex, amm, swap
-
-Created        : 2025-01-01T00:00:00Z
-Updated        : 2025-01-15T00:00:00Z
-
-Source         : Git Repository
-URL            : https://github.com/stellar/soroban-examples
-Branch         : main
-
-─────────────────────────────────────────────────────────────
-
-Use this template:
-  starforge new contract my-project --template uniswap-v2 --from marketplace
-```
-
----
-
-### `starforge template publish`
-
-Publish a template to the local marketplace.
-
-**Usage:**
-```bash
-starforge template publish <PATH> [OPTIONS]
-```
-
-**Arguments:**
-- `<PATH>` - Path to template directory
-
-**Options:**
-- `--name <NAME>` - Template name
-- `--description <DESC>` - Template description
-- `--author <AUTHOR>` - Author name
-- `--tags <TAGS>` - Comma-separated tags
-- `--version <VERSION>` - Version (default: 1.0.0)
-
-**Examples:**
-```bash
-# Publish with all options
-starforge template publish ./my-template \
-  --name my-awesome-template \
-  --description "An awesome contract" \
-  --author "Your Name" \
-  --tags "defi,custom" \
-  --version "1.0.0"
-
-# Interactive publish (prompts for missing info)
-starforge template publish ./my-template
-```
-
----
-
-### `starforge template remove`
-
-Remove a template from the local marketplace.
-
-**Usage:**
-```bash
-starforge template remove <NAME>
-```
-
-**Arguments:**
-- `<NAME>` - Template name to remove
-
-**Example:**
-```bash
-starforge template remove my-template
-```
-
----
-
-## Contract Commands
-
-### `starforge new contract`
-
-Scaffold a new Soroban smart contract project.
-
-**Usage:**
-```bash
-starforge new contract <NAME> [OPTIONS]
-```
-
-**Arguments:**
-- `<NAME>` - Project name
-
-**Options:**
-- `--template <TEMPLATE>` - Template to use (`hello-world`, `token`, `nft`, `voting`)
-- `--interactive` - Interactively customize the contract
-- `--from <SOURCE>` - Use template from source (`marketplace`)
-- `--search <QUERY>` - Search for templates
-- `--tags <TAGS>` - Filter templates by tags
-- `--ci` - Generate `.github/workflows/stellar-ci.yml` (cargo test + WASM size checks)
-
-**Examples:**
-```bash
-# Basic contract
-starforge new contract my-contract
-
-# Use specific template
-starforge new contract my-token --template token
-
-# Interactive mode
-starforge new contract my-contract --interactive
-
-# From marketplace
-starforge new contract my-dex --template uniswap-v2 --from marketplace
-
-# Search templates
-starforge new contract --search defi --tags dex
-
-# Include GitHub Actions CI
-starforge new contract my-contract --ci
-```
-
----
-
-### `starforge contract inspect`
-
-Inspect a deployed contract instance.
-
-**Usage:**
-```bash
-starforge contract inspect <CONTRACT_ID> [OPTIONS]
-```
-
-**Arguments:**
-- `<CONTRACT_ID>` - Contract ID (starts with 'C')
-
-**Options:**
-- `--network <NETWORK>` - Network to use
-- `--json` - Print machine-readable JSON output
-
-**Example:**
-```bash
-starforge contract inspect CCPYZFKEAXHHS5VVW5J45TOU7S2EODJ7TZNJIA5LKDVL3PESCES6FNCI
-```
-
-**JSON schema (`--json`):**
-- `contract_id` (string)
-- `executable` (string)
-- `wasm_hash` (string|null)
-- `storage_durability` (string)
-- `latest_ledger` (number)
-- `last_modified_ledger_seq` (number|null)
-- `live_until_ledger_seq` (number|null)
-- `instance_storage` (array of objects): `{ "key": string, "value": string }`
-
----
-
-### `starforge contract generate-bindings`
-
-Generate typed client wrappers from Soroban contract metadata embedded in a WASM file.
-
-**Usage:**
-```bash
-starforge contract generate-bindings <WASM_FILE> --lang <LANG>
-```
-
-**Arguments:**
-- `<WASM_FILE>` - Path to a compiled Soroban WASM file with `contractspecv0` metadata
-
-**Options:**
-- `--lang <LANG>` - Output language (`rust`, `ts`)
-
-**Examples:**
-```bash
-starforge contract generate-bindings ./target/wasm32-unknown-unknown/release/my_contract.wasm --lang rust
-starforge contract generate-bindings ./target/wasm32-unknown-unknown/release/my_contract.wasm --lang ts
-```
-
----
-
-### `starforge deploy`
-
-Deploy a compiled Soroban contract.
-
-**Usage:**
-```bash
-starforge deploy --wasm <FILE> [OPTIONS]
-```
-
-**Options:**
-- `--wasm <FILE>` - Path to compiled .wasm file (required)
-- `--network <NETWORK>` - Network to deploy to (`testnet`, `mainnet`)
-- `--wallet <NAME>` - Wallet name to use for deployment
-- `--optimize` - Run `soroban-optimize`/Stellar CLI optimization before deployment prep and show size reduction
-- `--simulate` - Simulate deploy via Soroban RPC (fee estimate, error check)
-- `--yes` - Skip confirmation prompt
-- `--execute` - Execute `stellar contract deploy ...` when `stellar` CLI is on PATH (default is dry-run)
-
-**Examples:**
-```bash
-# Deploy to testnet
-starforge deploy --wasm target/wasm32-unknown-unknown/release/my_contract.wasm
-
-# Deploy to mainnet with specific wallet
-starforge deploy \
-  --wasm ./my_contract.wasm \
-  --network mainnet \
-  --wallet deployer
-
-# Skip confirmation (for CI)
-starforge deploy --wasm ./my_contract.wasm --yes
-
-# Simulate fees before confirming
-starforge deploy --wasm ./my_contract.wasm --simulate --wallet deployer
-
-# Execute immediately (requires stellar CLI on PATH)
-starforge deploy --wasm ./my_contract.wasm --execute
-
-# Optimize before deployment
-starforge deploy --wasm ./my_contract.wasm --optimize
-```
-
----
-
-## Network Commands
-
-### `starforge network show`
-
-Show current network and available networks.
-
-**Usage:**
-```bash
-starforge network show
-```
-
----
-
-### `starforge network switch`
-
-Switch the active network.
-
-**Usage:**
-```bash
-starforge network switch <NETWORK>
-```
-
-**Arguments:**
-- `<NETWORK>` - Target network (`testnet`, `mainnet`, or custom)
-
-**Example:**
-```bash
-starforge network switch mainnet
-```
-
----
-
-### `starforge network add`
-
-Add a custom network endpoint.
-
-**Usage:**
-```bash
-starforge network add <NAME> --horizon-url <URL> [OPTIONS]
-```
-
-**Arguments:**
-- `<NAME>` - Network name
-
-**Options:**
-- `--horizon-url <URL>` - Horizon API URL (required)
-- `--soroban-rpc-url <URL>` - Soroban RPC URL (optional)
-
-**Example:**
-```bash
-starforge network add mynet \
-  --horizon-url https://my-horizon.example.com \
-  --soroban-rpc-url https://my-soroban.example.com
-```
-
----
-
-### `starforge network test`
-
-Test connectivity to a network.
-
-**Usage:**
-```bash
-starforge network test [NETWORK]
-```
-
-**Arguments:**
-- `[NETWORK]` - Network to test (defaults to current)
-
-**Example:**
-```bash
-starforge network test mainnet
-```
-
----
-
-## Transaction Commands
-
-### `starforge tx send`
-
-Send a Stellar payment transaction.
-
-**Usage:**
-```bash
-starforge tx send --from <WALLET> --to <ADDRESS> --amount <AMOUNT> [OPTIONS]
-```
-
-**Options:**
-- `--from <WALLET>` - Source wallet name (required)
-- `--to <ADDRESS>` - Destination public key (required)
-- `--amount <AMOUNT>` - Amount to send (required)
-- `--asset <ASSET>` - Asset to send (default: XLM, format: CODE:ISSUER)
-- `--network <NETWORK>` - Network to use
-- `--yes` - Skip confirmation prompt
-
-**Examples:**
-```bash
-# Send XLM
-starforge tx send --from alice --to GDEF... --amount 100
-
-# Send custom asset
-starforge tx send \
-  --from alice \
-  --to GDEF... \
-  --amount 50 \
-  --asset USDC:GABC...
-
-# Skip confirmation
-starforge tx send --from alice --to GDEF... --amount 10 --yes
-```
-
----
-
-### `starforge tx batch`
-
-Submit multiple Stellar operations in a single transaction from a JSON file.
-
-**Usage:**
-```bash
-starforge tx batch --file <FILE> --from <WALLET> [OPTIONS]
-```
-
-**Options:**
-- `--file <FILE>` - Path to operations JSON (required)
-- `--from <WALLET>` - Source wallet name (required)
-- `--network <NETWORK>` - Network to use (`testnet` or `mainnet`, default: `testnet`)
-- `--yes` - Skip confirmation prompt
-
-**Operations file schema:**
-```json
-{
-  "operations": [
-    {
-      "type": "payment",
-      "to": "GDEF...",
-      "amount": "100",
-      "asset": "XLM"
-    }
-  ]
-}
-```
-
-Supported operation types: `payment` (`to`, `amount`, optional `asset` as `XLM` or `CODE:ISSUER`).
-
-**Examples:**
-```bash
-starforge tx batch --file operations.json --from alice
-starforge tx batch --file ops.json --from alice --network testnet --yes
-```
-
----
-
-### `starforge tx history`
-
-Fetch and display recent transactions.
-
-**Usage:**
-```bash
-starforge tx history <PUBLIC_KEY> [OPTIONS]
-```
-
-**Arguments:**
-- `<PUBLIC_KEY>` - Account public key
-
-**Options:**
-- `-l, --limit <N>` - Number of transactions (max 200, default: 10)
-- `-n, --network <NETWORK>` - Network to use
-- `--cursor <CURSOR>` - Pagination cursor
-- `--after <DATE>` - Show transactions after date (ISO 8601)
-- `--before <DATE>` - Show transactions before date (ISO 8601)
-- `--successful` - Show only successful transactions
-- `--details` - Show full transaction details
-
-**Examples:**
-```bash
-# Recent transactions
-starforge tx history GABC...
-
-# Last 50 transactions
-starforge tx history GABC... --limit 50
-
-# Filter by date
-starforge tx history GABC... --after 2025-01-01 --before 2025-01-31
-
-# Only successful
-starforge tx history GABC... --successful
-
-# With details
-starforge tx history GABC... --details
-```
-
----
-
-## Utility Commands
-
-### `starforge info`
-
-Show starforge config and environment info.
-
-**Usage:**
-```bash
-starforge info
-```
-
----
-
-### `starforge completions`
-
-Generate shell completions.
-
-**Usage:**
-```bash
-starforge completions <SHELL>
-```
-
-**Arguments:**
-- `<SHELL>` - Shell type (`bash`, `zsh`, `fish`)
-
-**Examples:**
-```bash
-# Bash
-starforge completions bash > ~/.bash_completion.d/starforge
-
-# Zsh
-starforge completions zsh > ~/.zsh/completions/_starforge
-
-# Fish
-starforge completions fish > ~/.config/fish/completions/starforge.fish
-```
-
----
-
-### `starforge shell`
-
-Interactive REPL for local contract testing.
-
-**Usage:**
-```bash
-starforge shell --contract <WASM>
-```
-
-**Options:**
-- `--contract <WASM>` - Path to compiled contract
-- `--no-history` - Disable persistent history for this session
-- `--history-max-lines <N>` - Max lines to keep in `~/.starforge/history` (default: 1000)
-
-**Example:**
-```bash
-starforge shell --contract target/wasm32-unknown-unknown/release/my_contract.wasm
-```
-
----
-
-### `starforge monitor`
-
-Live monitoring of contracts or wallets.
-
-**Usage:**
-```bash
-starforge monitor [OPTIONS]
-```
-
-**Options:**
-- `--contract <ID>` - Contract ID to monitor
-- `--events <EVENTS>` - Comma-separated event names to filter
-- `--wallet <NAME>` - Wallet name to monitor
-- `--threshold <AMOUNT>` - XLM threshold for notifications
-- `--network <NETWORK>` - Network to use
-- `--interval <SECONDS>` - Poll interval (default: 2)
-
-**Examples:**
-```bash
-# Monitor contract events
-starforge monitor --contract CCPYZ... --events transfer,mint
-
-# Monitor wallet balance
-starforge monitor --wallet alice --threshold 1000
-```
-
----
-
-### `starforge test`
-
-Run contract tests.
-
-**Usage:**
-```bash
-starforge test --wasm <FILE> [OPTIONS]
-```
-
-**Options:**
-- `--wasm <FILE>` - Path to compiled wasm (required)
-- `--coverage` - Collect coverage report
-- `--report <FORMAT>` - Output report format (`html`, `json`)
-
-**Example:**
-```bash
-starforge test --wasm target/wasm32-unknown-unknown/release/my_contract.wasm --coverage
-```
-
----
-
-### `starforge gas`
-
-Gas analysis and optimization.
-
-#### `starforge gas analyze`
-
-Analyze gas costs.
-
-**Usage:**
-```bash
-starforge gas analyze --wasm <FILE> [OPTIONS]
-```
-
-**Options:**
-- `--wasm <FILE>` - Path to wasm file (required)
-- `--network <NETWORK>` - Network to use
-
-#### `starforge gas optimize`
-
-Optimize wasm for gas efficiency.
-
-**Usage:**
-```bash
-starforge gas optimize --target <INPUT> --output <OUTPUT>
-```
-
-**Options:**
-- `--target <INPUT>` - Input wasm file (required)
-- `--output <OUTPUT>` - Output wasm file (required)
-
-#### `starforge gas diff`
-
-Compare two wasm builds side-by-side and diff estimated simulation cost.
-
-**Usage:**
-```bash
-starforge gas diff <OLD_WASM> <NEW_WASM>
-```
-
-**Arguments:**
-- `<OLD_WASM>` - Baseline wasm file
-- `<NEW_WASM>` - Candidate wasm file
-
-**Output includes:**
-- Old/new wasm size
-- Old/new estimated simulation cost
-- Delta and percentage change
-- Profiling timings per analysis step
-
----
-
-### `starforge inspect storage`
-
-List decoded storage entries for a contract scope.
-
-**Usage:**
-```bash
-starforge inspect storage <CONTRACT_ID> [OPTIONS]
-```
-
-**Options:**
-- `--scope <SCOPE>` - `instance`, `persistent`, or `temporary`
-- `--network <NETWORK>` - Network to use (`testnet`, `mainnet`)
-- `--json` - Print machine-readable JSON output
-
-**JSON schema (`--json`):**
-- `contract_id` (string)
-- `scope` (string)
-- `entries` (array of objects): `{ "key": string, "value": string }`
-
----
-
-### `starforge benchmark`
-
-Performance benchmarking.
-
-**Usage:**
-```bash
-starforge benchmark [OPTIONS]
-```
-
----
-
-### `starforge plugin`
-
-Manage third-party plugins.
-
-#### `starforge plugin install`
-
-Install a plugin.
-
-**Usage:**
-```bash
-starforge plugin install <NAME> --path <LIB>
-```
-
-#### `starforge plugin list`
-
-List installed plugins.
-
-**Usage:**
-```bash
-starforge plugin list
-```
-
-#### `starforge plugin load`
-
-Load and verify plugins.
-
-**Usage:**
-```bash
-starforge plugin load
-```
-
----
-
-## Configuration
-
-### Config File Location
-
-`~/.starforge/config.toml`
-
-### Config Structure
-
-```toml
-version = "1"
-network = "testnet"
-telemetry_enabled = true
-
-[[wallets]]
-name = "alice"
-public_key = "GABC...XYZ"
-secret_key = "SABC...XYZ"  # or encrypted: "salt:nonce:ciphertext"
-network = "testnet"
-created_at = "2025-01-01T00:00:00Z"
-funded = true
-
-[networks.testnet]
-horizon_url = "https://horizon-testnet.stellar.org"
-soroban_rpc_url = "https://soroban-testnet.stellar.org"
-
-[networks.mainnet]
-horizon_url = "https://horizon.stellar.org"
-soroban_rpc_url = "https://mainnet.sorobanrpc.com"
-```
-
----
-
-## Exit Codes
-
-| Code | Meaning |
-|------|---------|
-| 0 | Success |
-| 1 | General error |
-| 2 | Invalid arguments |
-| 3 | Configuration error |
-| 4 | Network error |
-| 5 | Validation error |
-
----
-
-## Template Placeholders
-
-When creating templates, use these placeholders:
-
-| Placeholder | Description | Example |
-|-------------|-------------|---------|
-| `{{PROJECT_NAME}}` | Original project name | my-project |
-| `{{PROJECT_NAME_SNAKE}}` | Snake case | my_project |
-| `{{PROJECT_NAME_PASCAL}}` | Pascal case | MyProject |
-
----
-
-## Error Messages
-
-### Common Errors
-
-**Wallet not found:**
-```
-✗ Error: Wallet 'alice' not found
-
-Try: starforge wallet list
-```
-
-**Network unreachable:**
-```
-✗ Error: Failed to reach Horizon on testnet
-
-Check your internet connection or try: starforge network test
-```
-
-**Invalid public key:**
-```
-✗ Error: Invalid public key: must start with 'G'
-
-A valid Stellar public key looks like: GABC...XYZ (56 characters)
-```
-
----
-
-## Best Practices
-
-1. **Always encrypt mainnet wallets**: Use `--encrypt` flag
-2. **Test on testnet first**: Verify everything works before mainnet
-3. **Use descriptive wallet names**: e.g., `deployer-testnet`, `treasury-mainnet`
-4. **Keep backups**: Export and securely store secret keys
-5. **Review templates**: Always review template code before using
-6. **Use verified templates**: Look for the ✓ badge
-
----
-
-## Support
-
-- **Documentation**: https://github.com/YOUR_USERNAME/starforge
-- **Issues**: https://github.com/YOUR_USERNAME/starforge/issues
-- **Discord**: Join the Stellar Discord
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
deleted file mode 100644
index a9430068..00000000
--- a/ARCHITECTURE.md
+++ /dev/null
@@ -1,1148 +0,0 @@
-# StarForge Architecture Documentation
-
-## Table of Contents
-
-1. [Overview](#overview)
-2. [System Architecture](#system-architecture)
-3. [Directory Structure](#directory-structure)
-4. [Core Components](#core-components)
-5. [Data Flow](#data-flow)
-6. [Module Descriptions](#module-descriptions)
-7. [Design Patterns](#design-patterns)
-8. [Extension Points](#extension-points)
-
----
-
-## Overview
-
-StarForge is a command-line interface (CLI) tool built in Rust for Stellar and Soroban blockchain development. It provides a comprehensive suite of tools for wallet management, contract development, deployment, and testing.
-
-### Key Design Principles
-
-1. **Modularity**: Clear separation between commands, utilities, and plugins
-2. **Type Safety**: Leveraging Rust's type system for reliability
-3. **Extensibility**: Plugin system for third-party extensions
-4. **User Experience**: Colored output, progress indicators, and helpful error messages
-5. **Security**: Encrypted key storage, hardware wallet support, validation at every step
-
-### Technology Stack
-
-- **Language**: Rust 1.80+
-- **CLI Framework**: clap 4.4.18 (derive API)
-- **Cryptography**: ed25519-dalek, aes-gcm, argon2
-- **Blockchain**: stellar-strkey, stellar-xdr
-- **HTTP**: ureq 2.7.1
-- **Serialization**: serde, toml, serde_json
-- **UI**: colored, indicatif, dialoguer
-
----
-
-## System Architecture
-
-### High-Level Architecture
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                         User CLI                             │
-└─────────────────────┬───────────────────────────────────────┘
-                      │
-                      ▼
-┌─────────────────────────────────────────────────────────────┐
-│                    Main Entry Point                          │
-│                     (src/main.rs)                            │
-│  - Command parsing (clap)                                    │
-│  - Banner display                                            │
-│  - Command routing                                           │
-│  - Telemetry tracking                                        │
-└─────────────────────┬───────────────────────────────────────┘
-                      │
-        ┌─────────────┴─────────────┐
-        ▼                           ▼
-┌──────────────────┐      ┌──────────────────┐
-│    Commands      │      │   Utilities      │
-│  (src/commands/) │◄────►│  (src/utils/)    │
-└────────┬─────────┘      └──────────────────┘
-         │                          │
-         │                          ├─ Config Management
-         │                          ├─ Cryptography
-         │                          ├─ Horizon API
-         │                          ├─ Soroban RPC
-         │                          ├─ Template System
-         │                          └─ Print Utilities
-         │
-         ├─ Wallet Management
-         ├─ Contract Operations
-         ├─ Network Management
-         ├─ Transaction Handling
-         ├─ Template Marketplace
-         └─ Plugin System
-                      │
-                      ▼
-┌─────────────────────────────────────────────────────────────┐
-│                   External Systems                           │
-│  - Stellar Horizon API                                       │
-│  - Soroban RPC                                               │
-│  - Git Repositories                                          │
-│  - Hardware Wallets (Ledger/Trezor)                         │
-│  - File System (~/.starforge/)                               │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### Component Interaction
-
-```
-┌──────────┐     ┌──────────┐     ┌──────────┐
-│  Wallet  │────►│  Config  │◄────│ Network  │
-│ Commands │     │  Utils   │     │ Commands │
-└──────────┘     └────┬─────┘     └──────────┘
-                      │
-                      ▼
-                ┌──────────┐
-                │ Horizon  │
-                │   API    │
-                └──────────┘
-
-┌──────────┐     ┌──────────┐     ┌──────────┐
-│ Contract │────►│ Soroban  │◄────│  Deploy  │
-│ Commands │     │   RPC    │     │ Commands │
-└──────────┘     └──────────┘     └──────────┘
-
-┌──────────┐     ┌──────────┐     ┌──────────┐
-│ Template │────►│ Template │◄────│   New    │
-│ Commands │     │  Utils   │     │ Commands │
-└──────────┘     └──────────┘     └──────────┘
-```
-
----
-
-## Directory Structure
-
-```
-starforge/
-├── src/
-│   ├── main.rs                 # Entry point, CLI setup, command routing
-│   ├── commands/               # Command implementations
-│   │   ├── mod.rs             # Module exports
-│   │   ├── wallet.rs          # Wallet management (create, list, show, fund)
-│   │   ├── new.rs             # Project scaffolding
-│   │   ├── contract.rs        # Contract operations (inspect, invoke)
-│   │   ├── deploy.rs          # Contract deployment
-│   │   ├── network.rs         # Network management
-│   │   ├── tx.rs              # Transaction operations
-│   │   ├── template.rs        # Template marketplace
-│   │   ├── plugin.rs          # Plugin management
-│   │   ├── monitor.rs         # Real-time monitoring
-│   │   ├── shell.rs           # Interactive REPL
-│   │   ├── test.rs            # Contract testing
-│   │   ├── gas.rs             # Gas analysis
-│   │   ├── benchmark.rs       # Performance benchmarking
-│   │   ├── tutorial.rs        # Interactive tutorials
-│   │   ├── completions.rs     # Shell completions
-│   │   ├── invoke.rs          # Contract invocation
-│   │   └── info.rs            # System information
-│   ├── utils/                  # Utility modules
-│   │   ├── mod.rs             # Module exports
-│   │   ├── config.rs          # Configuration management
-│   │   ├── crypto.rs          # Encryption/decryption
-│   │   ├── horizon.rs         # Horizon API client
-│   │   ├── soroban.rs         # Soroban RPC client
-│   │   ├── templates.rs       # Template system
-│   │   ├── print.rs           # Terminal output utilities
-│   │   ├── hardware_wallet.rs # Hardware wallet integration
-│   │   ├── multisig.rs        # Multi-signature support
-│   │   ├── notifications.rs   # User notifications
-│   │   ├── optimizer.rs       # WASM optimization
-│   │   ├── profiler.rs        # Performance profiling
-│   │   ├── repl.rs            # REPL implementation
-│   │   ├── sandbox.rs         # Local contract execution
-│   │   ├── stream.rs          # Event streaming
-│   │   ├── telemetry.rs       # Usage analytics
-│   │   ├── test_runner.rs     # Test execution
-│   │   ├── tutorial_engine.rs # Tutorial system
-│   │   └── mock_soroban.rs    # Mock Soroban for testing
-│   └── plugins/                # Plugin system
-│       ├── mod.rs             # Module exports
-│       ├── interface.rs       # Plugin trait definitions
-│       ├── loader.rs          # Dynamic library loading
-│       └── registry.rs        # Plugin registry
-├── templates/                  # Template marketplace
-│   ├── registry.json          # Template metadata
-│   ├── README.md              # Template documentation
-│   └── examples/              # Example templates
-│       └── simple-counter/    # Counter contract template
-├── tutorials/                  # Interactive tutorials
-│   └── hello-world/           # Hello world tutorial
-├── benches/                    # Performance benchmarks
-│   └── benchmarks.rs          # Criterion benchmarks
-├── tests/                      # Integration tests
-│   └── template_marketplace_test.rs
-├── examples/                   # Usage examples
-│   └── template_marketplace_usage.md
-├── Cargo.toml                  # Rust package manifest
-├── build.rs                    # Build script (completions)
-├── Dockerfile                  # Container image
-├── docker-compose.yml          # Docker composition
-└── Documentation files
-    ├── README.md              # Main documentation
-    ├── Documentation.md       # Extended documentation
-    ├── ARCHITECTURE.md        # This file
-    ├── TEMPLATE_MARKETPLACE.md # Template feature docs
-    ├── QUICK_START_TEMPLATES.md # Quick start guide
-    └── IMPLEMENTATION_SUMMARY.md # Implementation details
-```
-
----
-
-## Core Components
-
-### 1. Main Entry Point (`src/main.rs`)
-
-**Purpose**: Application bootstrap and command routing
-
-**Responsibilities**:
-- Parse command-line arguments using clap
-- Display ASCII banner (unless `--quiet`)
-- Route commands to appropriate handlers
-- Track telemetry for usage analytics
-- Handle errors and exit codes
-
-**Key Code Flow**:
-```rust
-fn main() {
-    let cli = Cli::parse();           // Parse CLI args
-    print_banner();                    // Show banner
-    let result = match cli.command {   // Route to handler
-        Commands::Wallet(cmd) => commands::wallet::handle(cmd),
-        Commands::Template(cmd) => commands::template::handle(cmd),
-        // ... other commands
-    };
-    track_telemetry();                 // Log usage
-    handle_error(result);              // Exit with code
-}
-```
-
-### 2. Command Layer (`src/commands/`)
-
-**Purpose**: Implement user-facing commands
-
-**Pattern**: Each command module follows this structure:
-```rust
-// Command definition with clap
-#[derive(Subcommand)]
-pub enum CommandName {
-    SubCommand { /* args */ },
-}
-
-// Main handler
-pub fn handle(cmd: CommandName) -> Result<()> {
-    match cmd {
-        SubCommand::Action { args } => action(args),
-    }
-}
-
-// Individual action handlers
-fn action(args: Args) -> Result<()> {
-    // 1. Validate inputs
-    // 2. Load configuration
-    // 3. Call utility functions
-    // 4. Display results
-    // 5. Save state if needed
-}
-```
-
-**Key Commands**:
-
-#### Wallet Commands (`wallet.rs`)
-- **Create**: Generate Ed25519 keypair, optionally encrypt, save to config
-- **List**: Display all saved wallets with status
-- **Show**: Display wallet details and live balance
-- **Fund**: Request testnet funds via Friendbot
-- **Sign**: Sign messages with local or hardware keys
-- **Multisig**: Multi-signature account management
-
-#### Template Commands (`template.rs`)
-- **Search**: Find templates by keyword and tags
-- **List**: Show all available templates
-- **Show**: Display template details
-- **Publish**: Add template to local registry
-- **Remove**: Delete template from registry
-- **Init**: Initialize with example templates
-
-#### Network Commands (`network.rs`)
-- **Show**: Display current network and available networks
-- **Switch**: Change active network
-- **Add**: Register custom network
-- **Test**: Verify network connectivity
-
-### 3. Utility Layer (`src/utils/`)
-
-**Purpose**: Reusable business logic and external integrations
-
-#### Configuration Management (`config.rs`)
-
-**Data Structure**:
-```rust
-pub struct Config {
-    pub version: String,
-    pub network: String,
-    pub wallets: Vec<WalletEntry>,
-    pub networks: HashMap<String, NetworkConfig>,
-    pub telemetry_enabled: Option<bool>,
-}
-
-pub struct WalletEntry {
-    pub name: String,
-    pub public_key: String,
-    pub secret_key: Option<String>,  // Encrypted or plaintext
-    pub network: String,
-    pub created_at: String,
-    pub funded: bool,
-}
-```
-
-**Key Functions**:
-- `load()` - Load config from `~/.starforge/config.toml`
-- `save()` - Persist config to disk
-- `validate_*()` - Input validation functions
-- `migrate_config()` - Version migration system
-
-#### Template System (`templates.rs`)
-
-**Data Structure**:
-```rust
-pub struct TemplateRegistry {
-    pub version: String,
-    pub templates: Vec<TemplateEntry>,
-}
-
-pub struct TemplateEntry {
-    pub name: String,
-    pub version: String,
-    pub description: String,
-    pub author: String,
-    pub tags: Vec<String>,
-    pub source: TemplateSource,
-    pub downloads: u64,
-    pub verified: bool,
-}
-
-pub enum TemplateSource {
-    Git { url: String, branch: Option<String> },
-    Local { path: String },
-    Builtin { id: String },
-}
-```
-
-**Key Functions**:
-- `search_templates()` - Search with filtering
-- `fetch_template()` - Download from source
-- `validate_template_structure()` - Verify required files
-- `publish_template()` - Add to registry
-
-#### Cryptography (`crypto.rs`)
-
-**Encryption Flow**:
-```
-User Password
-     ↓
-  Argon2 KDF (key derivation)
-     ↓
-  AES-256-GCM Key
-     ↓
-  Encrypt Secret Key
-     ↓
-  Store: "salt:nonce:ciphertext"
-```
-
-**Key Functions**:
-- `prompt_password()` - Secure password input
-- `encrypt_secret()` - AES-256-GCM encryption
-- `decrypt_secret()` - Decrypt with password
-
-#### Horizon API Client (`horizon.rs`)
-
-**Endpoints**:
-- `GET /accounts/{id}` - Fetch account details
-- `GET /accounts/{id}/transactions` - Transaction history
-- `POST /transactions` - Submit transaction
-- `GET https://friendbot.stellar.org` - Fund testnet account
-
-**Key Functions**:
-- `fetch_account()` - Get account info
-- `fetch_transactions_filtered()` - Get tx history with filters
-- `fund_account()` - Request testnet funds
-- `submit_payment_transaction()` - Submit signed tx
-
-#### Soroban RPC Client (`soroban.rs`)
-
-**RPC Methods**:
-- `simulateTransaction` - Simulate contract call
-- `sendTransaction` - Submit contract transaction
-- `getLedgerEntries` - Fetch contract data
-- `getEvents` - Stream contract events
-
-**Key Functions**:
-- `simulate_transaction()` - Test contract call
-- `submit_transaction()` - Execute contract call
-- `inspect_contract()` - Get contract details
-
-### 4. Plugin System (`src/plugins/`)
-
-**Architecture**:
-```
-Plugin Interface (Trait)
-        ↓
-Plugin Implementation (.so/.dylib/.dll)
-        ↓
-Plugin Loader (libloading)
-        ↓
-Plugin Registry (JSON)
-        ↓
-Command Execution
-```
-
-**Key Components**:
-- `interface.rs` - Plugin trait definition
-- `loader.rs` - Dynamic library loading
-- `registry.rs` - Plugin metadata storage
-
----
-
-## Data Flow
-
-### 1. Wallet Creation Flow
-
-```
-User Command: starforge wallet create alice --encrypt
-                    ↓
-         Parse Arguments (clap)
-                    ↓
-         Validate Wallet Name
-                    ↓
-    Generate Ed25519 Keypair (rand + ed25519-dalek)
-                    ↓
-         Prompt for Password
-                    ↓
-    Derive Key (Argon2) → Encrypt Secret (AES-GCM)
-                    ↓
-         Load Config (config.rs)
-                    ↓
-    Add WalletEntry to Config
-                    ↓
-         Save Config (TOML)
-                    ↓
-         Display Success
-```
-
-### 2. Template Usage Flow
-
-```
-User Command: starforge new contract my-dex --template uniswap-v2 --from marketplace
-                    ↓
-         Parse Arguments
-                    ↓
-    Load Template Registry (templates.rs)
-                    ↓
-    Search for Template "uniswap-v2"
-                    ↓
-    Fetch Template (Git clone or local copy)
-                    ↓
-    Validate Structure (Cargo.toml, src/lib.rs)
-                    ↓
-    Copy to Destination
-                    ↓
-    Replace Placeholders:
-      - {{PROJECT_NAME}} → my-dex
-      - {{PROJECT_NAME_SNAKE}} → my_dex
-      - {{PROJECT_NAME_PASCAL}} → MyDex
-                    ↓
-    Update Download Count
-                    ↓
-    Display Success + Next Steps
-```
-
-### 3. Contract Deployment Flow
-
-```
-User Command: starforge deploy --wasm contract.wasm --wallet deployer
-                    ↓
-         Validate WASM File
-                    ↓
-         Load Configuration
-                    ↓
-    Find Wallet "deployer"
-                    ↓
-    Fetch Account from Horizon
-                    ↓
-    Check XLM Balance
-                    ↓
-    Calculate WASM Hash
-                    ↓
-    Generate stellar CLI Command
-                    ↓
-    Display Command for User to Execute
-```
-
-### 4. Transaction Submission Flow
-
-```
-User Command: starforge tx send --from alice --to bob --amount 100
-                    ↓
-         Validate Inputs
-                    ↓
-    Load Wallet "alice"
-                    ↓
-    Fetch Source Account (Horizon)
-                    ↓
-    Check Balance
-                    ↓
-    Build Transaction XDR
-                    ↓
-    Decrypt Secret Key (if encrypted)
-                    ↓
-    Sign Transaction (ed25519)
-                    ↓
-    Submit to Horizon
-                    ↓
-    Display Transaction Hash
-```
-
----
-
-## Module Descriptions
-
-### Commands Module
-
-| File | Purpose | Key Functions |
-|------|---------|---------------|
-| `wallet.rs` | Wallet lifecycle management | `create()`, `list()`, `show()`, `fund()`, `sign()` |
-| `template.rs` | Template marketplace | `search()`, `publish()`, `list()`, `show()` |
-| `new.rs` | Project scaffolding | `scaffold_contract()`, `scaffold_dapp()` |
-| `deploy.rs` | Contract deployment | `handle()`, `validate_wasm()` |
-| `contract.rs` | Contract operations | `inspect()`, `invoke()` |
-| `network.rs` | Network management | `show()`, `switch()`, `add()`, `test()` |
-| `tx.rs` | Transaction handling | `send()`, `history()` |
-| `monitor.rs` | Real-time monitoring | `monitor_contract()`, `monitor_wallet()` |
-| `shell.rs` | Interactive REPL | `handle()` with REPL runner |
-| `test.rs` | Contract testing | `run_contract_tests()` |
-| `gas.rs` | Gas analysis | `analyze()`, `optimize()` |
-| `plugin.rs` | Plugin management | `install()`, `list()`, `load()` |
-
-### Utils Module
-
-| File | Purpose | Key Functions |
-|------|---------|---------------|
-| `config.rs` | Config management | `load()`, `save()`, `validate_*()` |
-| `templates.rs` | Template system | `search_templates()`, `fetch_template()` |
-| `crypto.rs` | Encryption | `encrypt_secret()`, `decrypt_secret()` |
-| `horizon.rs` | Horizon API | `fetch_account()`, `submit_transaction()` |
-| `soroban.rs` | Soroban RPC | `simulate_transaction()`, `inspect_contract()` |
-| `print.rs` | Terminal output | `success()`, `error()`, `kv()`, `separator()` |
-| `hardware_wallet.rs` | HW wallet support | `connect()`, `sign()`, `get_address()` |
-| `multisig.rs` | Multi-sig support | `create_account()`, `sign_transaction()` |
-| `optimizer.rs` | WASM optimization | `analyze_wasm()`, `optimize_wasm()` |
-| `profiler.rs` | Performance profiling | `Timer`, `Profiler` |
-| `telemetry.rs` | Usage tracking | `track_event()`, `set_telemetry_enabled()` |
-
----
-
-## Design Patterns
-
-### 1. Command Pattern
-
-Each command is a separate module with a `handle()` function:
-```rust
-pub fn handle(cmd: CommandEnum) -> Result<()> {
-    match cmd {
-        CommandEnum::Action1 { args } => action1(args),
-        CommandEnum::Action2 { args } => action2(args),
-    }
-}
-```
-
-**Benefits**:
-- Clear separation of concerns
-- Easy to add new commands
-- Testable in isolation
-
-### 2. Repository Pattern
-
-Configuration and data access abstracted through utility modules:
-```rust
-// config.rs acts as repository
-pub fn load() -> Result<Config> { /* ... */ }
-pub fn save(config: &Config) -> Result<()> { /* ... */ }
-```
-
-**Benefits**:
-- Centralized data access
-- Easy to change storage backend
-- Consistent error handling
-
-### 3. Strategy Pattern
-
-Template sources use enum with different strategies:
-```rust
-pub enum TemplateSource {
-    Git { url: String, branch: Option<String> },
-    Local { path: String },
-    Builtin { id: String },
-}
-
-pub fn fetch_template(source: &TemplateSource) -> Result<()> {
-    match source {
-        TemplateSource::Git { url, branch } => fetch_git(url, branch),
-        TemplateSource::Local { path } => fetch_local(path),
-        TemplateSource::Builtin { id } => fetch_builtin(id),
-    }
-}
-```
-
-### 4. Builder Pattern
-
-Used in configuration and complex structures:
-```rust
-let stream = SorobanEventStream::new(rpc_url, contract_id)
-    .with_poll_interval(5)
-    .with_filter(event_types);
-```
-
-### 5. Facade Pattern
-
-Print utilities provide simple interface to complex terminal operations:
-```rust
-p::header("Title");
-p::kv("Key", "Value");
-p::success("Done!");
-```
-
----
-
-## Extension Points
-
-### 1. Adding New Commands
-
-1. Create new file in `src/commands/`
-2. Define command enum with clap attributes
-3. Implement `handle()` function
-4. Add to `src/commands/mod.rs`
-5. Add to `Commands` enum in `src/main.rs`
-
-### 2. Adding New Template Sources
-
-1. Add variant to `TemplateSource` enum
-2. Implement fetch logic in `fetch_template()`
-3. Update validation if needed
-
-### 3. Adding New Plugins
-
-1. Implement `Plugin` trait
-2. Compile as dynamic library
-3. Register with `starforge plugin install`
-
-### 4. Adding New Networks
-
-```bash
-starforge network add mynet \
-  --horizon-url https://horizon.example.com \
-  --soroban-rpc-url https://soroban.example.com
-```
-
-### 5. Extending Configuration
-
-1. Add field to `Config` struct
-2. Update `Default` implementation
-3. Add migration in `migrate_config()`
-4. Update version number
-
----
-
-## Security Architecture
-
-### 1. Key Storage
-
-```
-Plaintext Mode:
-  Secret Key → Config File (NOT RECOMMENDED)
-
-Encrypted Mode:
-  Secret Key → Argon2 KDF → AES-256-GCM → Config File
-```
-
-### 2. Hardware Wallet Integration
-
-```
-User Request → HID API → Hardware Device → Signature
-```
-
-### 3. Input Validation
-
-All user inputs validated before processing:
-- Public keys: 56 chars, starts with 'G', base32
-- Contract IDs: 56 chars, starts with 'C', base32
-- Amounts: Positive numbers
-- Wallet names: Alphanumeric + dash/underscore
-
-### 4. Network Security
-
-- HTTPS for all API calls
-- Mainnet warnings for destructive operations
-- Confirmation prompts for high-risk actions
-
----
-
-## Performance Considerations
-
-### 1. Configuration Caching
-
-Config loaded once per command execution, cached in memory.
-
-### 2. Template Registry
-
-Registry loaded on-demand, not at startup.
-
-### 3. Git Cloning
-
-Shallow clones (`--depth 1`) for faster template fetching.
-
-### 4. Parallel Operations
-
-Independent operations can be parallelized (future enhancement).
-
----
-
-## Error Handling Strategy
-
-### 1. Result Type
-
-All fallible operations return `Result<T, anyhow::Error>`:
-```rust
-pub fn operation() -> Result<()> {
-    validate_input()?;
-    perform_action()?;
-    Ok(())
-}
-```
-
-### 2. Context Addition
-
-Errors enriched with context:
-```rust
-fs::read_to_string(&path)
-    .with_context(|| format!("Failed to read {}", path.display()))?
-```
-
-### 3. User-Friendly Messages
-
-Errors displayed with helpful suggestions:
-```
-✗ Error: Wallet 'alice' not found
-
-Try: starforge wallet list
-```
-
----
-
-## Testing Strategy
-
-### 1. Unit Tests
-
-In-module tests for individual functions:
-```rust
-#[cfg(test)]
-mod tests {
-    use super::*;
-    
-    #[test]
-    fn test_validate_public_key() {
-        assert!(validate_public_key("GABC...").is_ok());
-    }
-}
-```
-
-### 2. Integration Tests
-
-In `tests/` directory for end-to-end workflows.
-
-### 3. Property-Based Testing
-
-For validation functions (future enhancement).
-
----
-
-## Future Architecture Enhancements
-
-### 1. Async/Await
-
-Convert blocking I/O to async for better performance:
-```rust
-pub async fn fetch_account(key: &str) -> Result<Account> {
-    // Async HTTP request
-}
-```
-
-### 2. Database Backend
-
-Replace TOML config with SQLite for better querying:
-```
-Config File → SQLite Database
-```
-
-### 3. Remote Template Registry
-
-Central server for global template sharing:
-```
-Local Registry → Remote API → Global Registry
-```
-
-### 4. WebAssembly Support
-
-Run StarForge in browser via WASM.
-
-### 5. GraphQL API
-
-Expose StarForge functionality via GraphQL.
-
----
-
-## Contract Upgrade Workflow
-
-### Overview
-
-StarForge provides a comprehensive contract upgrade workflow that supports both single-signer and multi-signature governance models. The upgrade system persists proposal state locally in `~/.starforge/upgrades/` to enable team collaboration and approval workflows.
-
-### Storage Architecture
-
-```
-~/.starforge/
-└── upgrades/
-    ├── proposals.json    # Active and historical proposals
-    └── history.json      # Executed upgrade records
-```
-
-#### Proposal Data Structure
-
-```rust
-pub struct UpgradeProposal {
-    pub id: String,                    // Unique ID: "prop-{wasm_hash_prefix}"
-    pub contract_id: String,           // Contract to upgrade
-    pub new_wasm_hash: String,         // SHA-256 hash of new WASM
-    pub description: String,           // Human-readable reason
-    pub proposer: String,              // Public key of proposer
-    pub approvals: Vec<String>,        // Public keys of approvers
-    pub threshold: u8,                 // Required approvals
-    pub status: ProposalStatus,        // Pending/Approved/Executed/Rejected/Expired
-    pub network: String,               // testnet/mainnet
-    pub created_at: String,            // RFC3339 timestamp
-    pub executed_at: Option<String>,   // RFC3339 timestamp when executed
-}
-```
-
-#### Upgrade History Structure
-
-```rust
-pub struct UpgradeRecord {
-    pub contract_id: String,
-    pub from_hash: String,
-    pub to_hash: String,
-    pub proposal_id: String,
-    pub executed_by: String,
-    pub network: String,
-    pub timestamp: String,
-}
-```
-
-### Upgrade Workflow
-
-#### 1. Single-Signer Workflow
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│ 1. Prepare Upgrade                                           │
-│    starforge upgrade prepare --contract-id C... --wasm new.wasm │
-│    • Validates WASM file                                     │
-│    • Computes SHA-256 hash                                   │
-│    • Verifies contract exists on-chain                       │
-└─────────────────────┬───────────────────────────────────────┘
-                      ▼
-┌─────────────────────────────────────────────────────────────┐
-│ 2. Create Proposal                                           │
-│    starforge upgrade propose --contract-id C... --wasm new.wasm │
-│                              --description "Fix bug X"       │
-│    • Creates proposal with threshold=1                       │
-│    • Auto-approves (proposer approval)                       │
-│    • Saves to proposals.json                                 │
-│    • Status: Approved                                        │
-└─────────────────────┬───────────────────────────────────────┘
-                      ▼
-┌─────────────────────────────────────────────────────────────┐
-│ 3. Execute Upgrade                                           │
-│    starforge upgrade execute --proposal-id prop-abc123       │
-│    • Verifies status is Approved                             │
-│    • Generates stellar CLI commands                          │
-│    • Records in history.json                                 │
-│    • Updates proposal status to Executed                     │
-└─────────────────────────────────────────────────────────────┘
-```
-
-#### 2. Multi-Signature Workflow
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│ Team Member 1: Create Proposal                               │
-│    starforge upgrade propose --contract-id C...              │
-│                              --wasm new.wasm                 │
-│                              --description "Add feature Y"   │
-│                              --threshold 3                   │
-│                              --wallet alice                  │
-│    • Creates proposal requiring 3 approvals                  │
-│    • Alice auto-approves (1/3)                               │
-│    • Saves to proposals.json                                 │
-│    • Status: Pending                                         │
-└─────────────────────┬───────────────────────────────────────┘
-                      ▼
-┌─────────────────────────────────────────────────────────────┐
-│ Team Member 2: Review and Approve                            │
-│    starforge upgrade list                                    │
-│    starforge upgrade status --proposal-id prop-abc123        │
-│    • Reviews proposal details                                │
-│    • Verifies WASM hash matches expectations                 │
-│                                                              │
-│    starforge upgrade approve --proposal-id prop-abc123       │
-│                              --wallet bob                    │
-│    • Bob approves (2/3)                                      │
-│    • Updates proposals.json                                  │
-│    • Status: Still Pending                                   │
-└─────────────────────┬───────────────────────────────────────┘
-                      ▼
-┌─────────────────────────────────────────────────────────────┐
-│ Team Member 3: Final Approval                                │
-│    starforge upgrade approve --proposal-id prop-abc123       │
-│                              --wallet charlie                │
-│    • Charlie approves (3/3)                                  │
-│    • Threshold reached                                       │
-│    • Status: Approved                                        │
-└─────────────────────┬───────────────────────────────────────┘
-                      ▼
-┌─────────────────────────────────────────────────────────────┐
-│ Any Team Member: Execute                                     │
-│    starforge upgrade execute --proposal-id prop-abc123       │
-│                              --wallet alice                  │
-│    • Verifies threshold met                                  │
-│    • Generates on-chain commands                             │
-│    • Records execution in history.json                       │
-│    • Status: Executed                                        │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### Integration with Multi-Signature Accounts
-
-The upgrade workflow integrates seamlessly with Stellar multi-signature accounts:
-
-#### Multi-Sig Account Structure
-
-```rust
-pub struct MultiSigAccount {
-    pub name: String,
-    pub account_id: String,
-    pub signers: Vec<Signer>,          // Multiple signers with weights
-    pub thresholds: Thresholds,        // Low/Medium/High thresholds
-    pub created_at: String,
-}
-
-pub struct Signer {
-    pub public_key: String,
-    pub weight: u8,                    // Voting weight
-    pub name: Option<String>,
-}
-
-pub struct Thresholds {
-    pub low: u8,      // For low-security operations
-    pub medium: u8,   // For medium-security operations
-    pub high: u8,     // For high-security operations (upgrades)
-}
-```
-
-#### Combined Workflow: Upgrade Proposals + Multi-Sig Accounts
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│ Scenario: Upgrade contract controlled by multi-sig account  │
-│                                                              │
-│ Multi-Sig Account: "dao-treasury"                           │
-│   • Signer 1 (Alice): weight=10                              │
-│   • Signer 2 (Bob):   weight=10                              │
-│   • Signer 3 (Carol): weight=10                              │
-│   • High threshold: 20 (requires 2 of 3)                     │
-└─────────────────────────────────────────────────────────────┘
-
-Step 1: Create Upgrade Proposal (Off-Chain Governance)
-  starforge upgrade propose --contract-id C... --threshold 2
-  • Tracks approvals in StarForge
-  • Ensures team consensus before on-chain action
-
-Step 2: Collect Approvals (Off-Chain)
-  starforge upgrade approve --proposal-id prop-abc123 --wallet alice
-  starforge upgrade approve --proposal-id prop-abc123 --wallet bob
-  • Proposal status: Approved (2/2 threshold met)
-
-Step 3: Generate Multi-Sig Transaction (On-Chain Preparation)
-  starforge upgrade execute --proposal-id prop-abc123
-  • Generates transaction XDR for upgrade
-  • Transaction requires multi-sig account signatures
-
-Step 4: Collect On-Chain Signatures
-  stellar contract invoke --id C... --source dao-treasury \
-    --network testnet -- upgrade --new-wasm-hash <hash>
-  • Stellar network validates multi-sig thresholds
-  • Requires signatures from signers with combined weight ≥ 20
-  • Alice (weight=10) + Bob (weight=10) = 20 ✓
-
-Step 5: Submit to Network
-  • Transaction submitted with sufficient signatures
-  • Contract upgraded on-chain
-  • StarForge records in history.json
-```
-
-### Governance Models
-
-#### Model 1: Off-Chain Governance Only
-- Use StarForge upgrade proposals for team coordination
-- Contract controlled by single account
-- Approval threshold enforced by StarForge
-- Suitable for: Small teams, testnet deployments
-
-#### Model 2: On-Chain Governance Only
-- Use Stellar multi-sig accounts
-- No StarForge proposal system
-- Approval threshold enforced by blockchain
-- Suitable for: Decentralized protocols, mainnet
-
-#### Model 3: Hybrid Governance (Recommended)
-- StarForge proposals for off-chain coordination
-- Multi-sig accounts for on-chain enforcement
-- Double-layer security and consensus
-- Suitable for: DAOs, enterprise deployments
-
-### Proposal State Transitions
-
-```
-                    ┌─────────┐
-                    │ Created │
-                    └────┬────┘
-                         │
-                         ▼
-    ┌──────────────────────────────────────┐
-    │           Pending                     │
-    │  (approvals < threshold)              │
-    └────┬─────────────────────────┬────────┘
-         │                         │
-         │ Approvals++             │ Timeout/Reject
-         ▼                         ▼
-    ┌─────────┐              ┌──────────┐
-    │Approved │              │ Rejected │
-    │         │              │ Expired  │
-    └────┬────┘              └──────────┘
-         │
-         │ Execute
-         ▼
-    ┌─────────┐
-    │Executed │
-    └─────────┘
-```
-
-### Command Reference
-
-| Command | Purpose | Persistence |
-|---------|---------|-------------|
-| `upgrade prepare` | Validate WASM and preview upgrade | None |
-| `upgrade propose` | Create proposal with threshold | Writes to `proposals.json` |
-| `upgrade list` | Show all proposals | Reads from `proposals.json` |
-| `upgrade status` | Show proposal status (alias for list) | Reads from `proposals.json` |
-| `upgrade approve` | Add approval to proposal | Updates `proposals.json` |
-| `upgrade execute` | Generate on-chain commands | Updates `proposals.json`, writes to `history.json` |
-| `upgrade history` | Show past upgrades | Reads from `history.json` |
-| `upgrade rollback` | Revert to previous version | Reads from `history.json` |
-
-### File Persistence Details
-
-#### proposals.json Format
-```json
-[
-  {
-    "id": "prop-a1b2c3d4e5f6",
-    "contract_id": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
-    "new_wasm_hash": "a1b2c3d4e5f6...",
-    "description": "Fix critical bug in transfer function",
-    "proposer": "GDALICE...",
-    "approvals": ["GDALICE...", "GDBOB..."],
-    "threshold": 2,
-    "status": "approved",
-    "network": "testnet",
-    "created_at": "2025-01-15T10:30:00Z",
-    "executed_at": null
-  }
-]
-```
-
-#### history.json Format
-```json
-[
-  {
-    "contract_id": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
-    "from_hash": "old_hash_123...",
-    "to_hash": "new_hash_456...",
-    "proposal_id": "prop-a1b2c3d4e5f6",
-    "executed_by": "GDALICE...",
-    "network": "testnet",
-    "timestamp": "2025-01-15T11:00:00Z"
-  }
-]
-```
-
-### Security Considerations
-
-1. **WASM Hash Verification**: All approvers should independently verify the WASM hash matches the expected code
-2. **Network Isolation**: Proposals are network-specific (testnet/mainnet) to prevent cross-network confusion
-3. **Threshold Enforcement**: Off-chain thresholds prevent premature execution
-4. **Audit Trail**: Complete history of proposals and executions for compliance
-5. **Mainnet Warnings**: Extra confirmation prompts for mainnet upgrades
-
-### Best Practices
-
-1. **Always use `prepare` first**: Validate WASM before creating proposals
-2. **Set appropriate thresholds**: Match your team's governance requirements
-3. **Document descriptions**: Clear upgrade rationale helps reviewers
-4. **Test on testnet**: Validate upgrade flow before mainnet
-5. **Backup history**: Regularly backup `~/.starforge/upgrades/` directory
-6. **Coordinate with team**: Share proposal IDs through secure channels
-7. **Verify WASM independently**: Don't trust, verify the hash
-
-### Rollback Workflow
-
-If an upgrade causes issues, use the rollback feature:
-
-```bash
-# View upgrade history
-starforge upgrade history --contract-id C... --network testnet
-
-# Rollback to previous version
-starforge upgrade rollback --contract-id C... \
-                           --to-hash <previous_hash> \
-                           --network testnet
-```
-
-The rollback creates a new upgrade proposal pointing to the previous WASM hash, following the same approval workflow.
-
----
-
-## Conclusion
-
-StarForge's architecture is designed for:
-- **Maintainability**: Clear module boundaries
-- **Extensibility**: Plugin system and extension points
-- **Reliability**: Type safety and error handling
-- **Performance**: Efficient operations and caching
-- **Security**: Encryption and validation throughout
-
-The modular design allows for easy addition of new features while maintaining code quality and user experience.
diff --git a/AUDIT_TRAIL_DOCUMENTATION.md b/AUDIT_TRAIL_DOCUMENTATION.md
deleted file mode 100644
index 8da6fc85..00000000
--- a/AUDIT_TRAIL_DOCUMENTATION.md
+++ /dev/null
@@ -1,508 +0,0 @@
-# Audit Trail Documentation
-
-This document explains how audit trails work in StarForge and how to use them for security review, compliance, and incident investigation.
-
-## Table of Contents
-
-1. [Audit Trail Overview](#audit-trail-overview)
-2. [Sensitive Operations Audit Log](#sensitive-operations-audit-log)
-3. [Log Format and Examples](#log-format-and-examples)
-4. [Reviewing Audit Logs](#reviewing-audit-logs)
-5. [Log Security and Retention](#log-security-and-retention)
-6. [Integration with Monitoring](#integration-with-monitoring)
-7. [Incident Investigation](#incident-investigation)
-
----
-
-## Audit Trail Overview
-
-### What Audit Trails Track
-
-An audit trail is a sequential record of security-relevant events. In StarForge, audit trails track:
-
-| Category | Examples |
-|----------|----------|
-| **Wallet Operations** | Create, encrypt, fund, show, remove, rotate |
-| **Plugin Management** | Load, execute, unload, version check |
-| **Contract Deployment** | Validate, deploy, inspect, invoke |
-| **Network Operations** | Switch network, test connectivity, add custom network |
-| **Authentication** | Key operations, passphrase attempts, decryption |
-
-### When Logs Are Created
-
-Audit logs are created for:
-- **Every successful security operation** - Operation, timestamp, status
-- **Every failed security operation** - What failed and why (without secrets)
-- **Every administrative action** - Who did what and when
-- **Configuration changes** - Network settings, wallet management, plugin installation
-
-### Log Retention
-
-**Recommended retention policies:**
-
-| Log Type | Recommended Retention | Reason |
-|----------|---------------------|--------|
-| Security operations | 90 days | Compliance and incident investigation |
-| Deployment records | 1 year | Audit trail for contracts |
-| Plugin operations | 90 days | Security and compatibility tracking |
-| Network operations | 30 days | Troubleshooting and diagnostics |
-| Authentication logs | 180 days | Account security review |
-
-**Implementation:**
-
-```bash
-# Configure log rotation in starforge
-starforge --log-dir ./logs --log-format json
-
-# Implement OS-level rotation
-# /etc/logrotate.d/starforge
-/path/to/logs/*.log {
-    daily
-    rotate 90
-    compress
-    delaycompress
-    missingok
-    notifempty
-}
-```
-
----
-
-## Sensitive Operations Audit Log
-
-### Complete Operation Reference
-
-#### Wallet Operations
-
-| Operation | What Gets Logged | Sensitivity | Example |
-|-----------|-----------------|-------------|---------|
-| **wallet create** | name, network, encryption enabled, duration, status | Public | `{operation: "wallet_create", wallet: "alice", network: "testnet", encrypted: true, duration_ms: 150, status: "success"}` |
-| **wallet encrypt** | name, algorithm, KDF iterations (size not value), duration, status | Public | `{operation: "wallet_encrypt", wallet: "alice", algorithm: "aes-256-gcm", kdf_iterations: 100000, duration_ms: 245, status: "success"}` |
-| **wallet fund** | name, network, amount, balance after, transaction hash, status | Public | `{operation: "wallet_fund", wallet: "alice", network: "testnet", amount: 1000, final_balance: 5000, tx_hash: "abc...", status: "success"}` |
-| **wallet show** | name, reveal_requested, balance_queried, status | Public | `{operation: "wallet_show", wallet: "alice", reveal_requested: false, balance_status: "queried", status: "success"}` |
-| **wallet remove** | name, network, confirmation, status | Public | `{operation: "wallet_remove", wallet: "alice", confirmed: true, status: "success"}` |
-| **wallet rotate** | name, new_account_created, network, status | Public | `{operation: "wallet_rotate", wallet: "alice", new_public_key: "GDRX...4T", network: "testnet", status: "success"}` |
-
-**Never log for wallet operations:**
-- Secret keys or private key material
-- Passphrases or encryption keys
-- Wallet backup data
-- Full account balances (OK to log final balance, not intermediate states)
-
-#### Plugin Operations
-
-| Operation | What Gets Logged | Sensitivity | Example |
-|-----------|-----------------|-------------|---------|
-| **plugin load** | name, version, source path, compatibility check, trust level, status | Public | `{operation: "plugin_load", plugin: "defi", version: "1.0.0", source: "/path/to/lib.so", compatible: true, trust_level: "verified", status: "success"}` |
-| **plugin execute** | name, command (args sanitized), duration, exit code, status | Public | `{operation: "plugin_execute", plugin: "defi", command: "swap", duration_ms: 500, exit_code: 0, status: "success"}` |
-| **plugin unload** | name, cleanup_status, status | Public | `{operation: "plugin_unload", plugin: "defi", cleanup: "successful", status: "success"}` |
-| **plugin compatibility-check** | name, version, starforge_version, compatible, status | Public | `{operation: "plugin_check", plugin: "defi", plugin_version: "1.0.0", starforge_version: "0.1.0", compatible: true, status: "success"}` |
-
-**Never log for plugin operations:**
-- Plugin source code or binaries
-- Plugin configuration secrets
-- Execution results containing user data
-- Sensitive plugin output
-
-#### Contract Operations
-
-| Operation | What Gets Logged | Sensitivity | Example |
-|-----------|-----------------|-------------|---------|
-| **contract validate** | file path, file size, warnings/errors, status | Public | `{operation: "contract_validate", file: "contract.wasm", file_size: 262144, warnings: 0, errors: 0, status: "success"}` |
-| **contract deploy** | network, account (redacted), wasm hash, gas used, address, status | Public | `{operation: "contract_deploy", network: "testnet", account: "GDRX...4T", wasm_hash: "abc123...", gas_used: 12345, contract_address: "CCPYZ...FNCI", status: "success"}` |
-| **contract inspect** | address (redacted), network, metadata retrieved, status | Public | `{operation: "contract_inspect", address: "CCPYZ...FNCI", network: "testnet", has_metadata: true, status: "success"}` |
-| **contract invoke** | address (redacted), network, function name, param count, result status | Public | `{operation: "contract_invoke", address: "CCPYZ...FNCI", network: "testnet", function: "transfer", param_count: 3, result: "success", status: "success"}` |
-
-**Never log for contract operations:**
-- Private contract state
-- Function arguments with secrets
-- Signed XDR transactions
-- Private key material
-- Full transaction payloads
-
-#### Network Operations
-
-| Operation | What Gets Logged | Sensitivity | Example |
-|-----------|-----------------|-------------|---------|
-| **network switch** | from_network, to_network, status | Public | `{operation: "network_switch", from: "testnet", to: "mainnet", status: "success"}` |
-| **network test** | network, horizon_status, soroban_status, latency_ms, status | Public | `{operation: "network_test", network: "testnet", horizon: "ok", soroban: "ok", latency_ms: 145, status: "success"}` |
-| **network add** | network name, endpoint count, verification status, status | Public | `{operation: "network_add", name: "custom-net", horizons: 2, sorobans: 2, verified: true, status: "success"}` |
-
-**Never log for network operations:**
-- API keys or credentials
-- Internal network addresses
-- Custom network secrets
-
----
-
-## Log Format and Examples
-
-### Standard Log Entry Structure
-
-Each audit log entry contains:
-
-```json
-{
-  "timestamp": "2024-01-15T10:30:45.123Z",
-  "level": "INFO",
-  "target": "starforge::commands::wallet",
-  "fields": {
-    "operation": "wallet_create",
-    "wallet": "alice",
-    "network": "testnet",
-    "encrypted": true,
-    "duration_ms": 150,
-    "status": "success"
-  },
-  "message": "Wallet created"
-}
-```
-
-### Human-Readable Format
-
-```
-2024-01-15T10:30:45.123Z [INFO] starforge::commands::wallet: Wallet created
-    operation: wallet_create
-    wallet: alice
-    network: testnet
-    encrypted: true
-    duration_ms: 150
-    status: success
-```
-
-### Real-World Examples
-
-#### Successful Deployment Sequence
-
-```json
-[
-  {
-    "timestamp": "2024-01-15T10:30:00Z",
-    "operation": "contract_validate",
-    "file": "contract.wasm",
-    "file_size": 262144,
-    "status": "success"
-  },
-  {
-    "timestamp": "2024-01-15T10:30:05Z",
-    "operation": "contract_deploy",
-    "network": "testnet",
-    "account": "GDRX...4T",
-    "wasm_hash": "5d41402abc4b2a76b9719d911017c592",
-    "gas_used": 12345,
-    "contract_address": "CCPYZ...FNCI",
-    "status": "success"
-  }
-]
-```
-
-#### Failed Wallet Operation
-
-```json
-{
-  "timestamp": "2024-01-15T10:35:20Z",
-  "operation": "wallet_fund",
-  "wallet": "alice",
-  "network": "testnet",
-  "amount": 1000,
-  "error_type": "InsufficientFunds",
-  "error_message": "Account has insufficient balance",
-  "status": "failed"
-}
-```
-
-#### Plugin Execution with Duration
-
-```json
-{
-  "timestamp": "2024-01-15T10:40:00Z",
-  "operation": "plugin_execute",
-  "plugin": "defi",
-  "command": "swap",
-  "duration_ms": 523,
-  "exit_code": 0,
-  "status": "success"
-}
-```
-
----
-
-## Reviewing Audit Logs
-
-### Daily Review Checklist
-
-- [ ] No unexpected failed operations
-- [ ] Plugin executions completed successfully
-- [ ] Network connectivity stable
-- [ ] Deployment operations recorded
-- [ ] Error counts within expected range
-
-### Weekly Security Review
-
-```bash
-# Find all wallet operations
-jq 'select(.fields.operation | startswith("wallet_"))' logs/*.log
-
-# Find all failed operations
-jq 'select(.fields.status == "failed")' logs/*.log
-
-# Find operations taking longer than expected
-jq 'select(.fields.duration_ms > 5000)' logs/*.log
-```
-
-### Monthly Compliance Report
-
-```bash
-# Count operations by type
-jq -r '.fields.operation' logs/*.log | sort | uniq -c
-
-# Find all deployments
-jq 'select(.fields.operation == "contract_deploy")' logs/*.log
-
-# Identify configuration changes
-jq 'select(.fields.operation | startswith("network_"))' logs/*.log
-```
-
-### Debugging Common Issues
-
-#### Wallet Encryption Failures
-
-```bash
-jq 'select(.fields.operation == "wallet_encrypt" and .fields.status == "failed")' logs/*.log | jq '.fields | {wallet, error_type, duration_ms}'
-```
-
-#### Deployment Issues
-
-```bash
-jq 'select(.fields.operation == "contract_deploy")' logs/*.log | jq '.fields | {network, account, status, gas_used, error_type}'
-```
-
-#### Plugin Compatibility Problems
-
-```bash
-jq 'select(.fields.operation | contains("plugin")) and select(.fields.status == "failed")' logs/*.log
-```
-
----
-
-## Log Security and Retention
-
-### File Permissions
-
-Logs contain sensitive operational details. Protect them:
-
-```bash
-# Set restrictive permissions
-chmod 600 /path/to/logs/*.log
-
-# Verify permissions
-ls -l /path/to/logs/
-
-# Allow only owner to read
-# Disable world/group access
-```
-
-### Sensitive Data Redaction
-
-Logs automatically redact sensitive information:
-
-```
-Public key redaction at INFO level:
-GDRXMZDQW34QHX6F5U6FFWJZZZDQ4KYWJO65HS4CUT62X7Y7RXYWXE4T
-→ GDRX...4T
-
-Full key at DEBUG level:
-GDRXMZDQW34QHX6F5U6FFWJZZZDQ4KYWJO65HS4CUT62X7Y7RXYWXE4T (unchanged)
-```
-
-### Log Retention Policy
-
-```
-Security operations log:  Keep for 90 days (quarterly compliance)
-Deployment records:       Keep for 1 year (contract audit trail)
-Error logs:              Keep for 180 days (incident investigation)
-Archive older logs:      Compress and store offline after retention period
-```
-
-### Secure Log Transmission
-
-If sending logs to external systems:
-
-```bash
-# Encrypt logs before transmission
-gpg --encrypt --recipient key-id logs/*.log
-
-# Use TLS for network transmission
-# Verify server certificate
-curl --cacert ca.crt https://log-collector.example.com
-
-# Authenticate with credentials
-curl -u user:pass https://log-collector.example.com
-```
-
----
-
-## Integration with Monitoring
-
-### Real-Time Alerting
-
-Set up alerts for:
-
-```yaml
-# Example alerting rules
-alerts:
-  - name: failed_wallet_operation
-    query: 'operation=wallet_* AND status=failed'
-    severity: warning
-    action: notify_admin
-    
-  - name: deployment_failure
-    query: 'operation=contract_deploy AND status=failed'
-    severity: critical
-    action: page_oncall
-    
-  - name: plugin_compatibility_error
-    query: 'operation=plugin_* AND error_type=CompatibilityError'
-    severity: warning
-    action: notify_admin
-```
-
-### Log Aggregation
-
-Tools for collecting and analyzing logs:
-
-| Tool | Use Case |
-|------|----------|
-| **ELK Stack** | Elasticsearch + Logstash + Kibana for log analysis |
-| **Splunk** | Enterprise log monitoring and analysis |
-| **CloudWatch** | AWS native log aggregation |
-| **Datadog** | Cloud monitoring with log aggregation |
-| **grep + awk** | Simple local log analysis |
-
-### Example ELK Integration
-
-```bash
-# Configure filebeat to ship logs
-filebeat.inputs:
-  - type: log
-    enabled: true
-    paths:
-      - /var/log/starforge/*.log
-    fields:
-      app: starforge
-      env: production
-
-output.elasticsearch:
-  hosts: ["localhost:9200"]
-```
-
-### Visualization Examples
-
-Create dashboards showing:
-- **Operations timeline** - All security operations chronologically
-- **Error rate** - Percentage of failed operations by type
-- **Performance metrics** - Average duration by operation type
-- **Network status** - Connectivity and latency trends
-- **Deployment history** - All contract deployments with outcomes
-
----
-
-## Incident Investigation
-
-### Step-by-Step Incident Investigation
-
-1. **Identify the timeframe**
-   ```bash
-   # Find operations around incident time
-   jq 'select(.timestamp >= "2024-01-15T10:00:00Z" and .timestamp <= "2024-01-15T11:00:00Z")' logs/*.log
-   ```
-
-2. **Find the affected resource**
-   ```bash
-   # Find operations for a specific wallet
-   jq 'select(.fields.wallet == "alice")' logs/*.log
-   ```
-
-3. **Trace the operation sequence**
-   ```bash
-   # Show all operations for a contract deployment
-   jq 'select(.fields.operation | contains("deploy")) and select(.fields.contract_address == "CCPYZ...FNCI")' logs/*.log | jq '.[] | {timestamp, operation, status, duration_ms}'
-   ```
-
-4. **Identify the failure point**
-   ```bash
-   # Find first failure
-   jq 'select(.fields.status == "failed")' logs/*.log | head -1
-   ```
-
-5. **Gather error context**
-   ```bash
-   # Get full error details
-   jq 'select(.fields.error_type != null)' logs/*.log | jq '.fields | {operation, error_type, error_message}'
-   ```
-
-6. **Review recovery actions**
-   ```bash
-   # Find retry attempts
-   jq 'select(.fields.attempt > 1)' logs/*.log
-   ```
-
-### Common Incident Scenarios
-
-#### Scenario: Wallet Creation Failed
-
-```bash
-# Find the failure
-jq 'select(.fields.operation == "wallet_create" and .fields.status == "failed")' logs/*.log
-
-# Check disk space
-df -h
-
-# Verify permissions
-ls -l ~/.starforge/
-
-# Check system resources
-top -b -n 1 | head -20
-```
-
-#### Scenario: Deployment Error
-
-```bash
-# Find deployment failures
-jq 'select(.fields.operation == "contract_deploy" and .fields.status == "failed")' logs/*.log
-
-# Check network connectivity
-jq 'select(.fields.operation == "network_test")' logs/*.log | tail -5
-
-# Verify account balance
-jq 'select(.fields.operation == "wallet_show" and .fields.wallet == "deployer")' logs/*.log
-
-# Review gas estimates
-jq 'select(.fields.operation == "contract_validate")' logs/*.log
-```
-
-#### Scenario: Plugin Crash
-
-```bash
-# Find plugin errors
-jq 'select(.fields.operation | contains("plugin")) and select(.fields.status == "failed")' logs/*.log
-
-# Check compatibility
-jq 'select(.fields.operation == "plugin_check")' logs/*.log
-
-# Review execution logs
-jq 'select(.fields.operation == "plugin_execute")' logs/*.log | tail -10
-```
-
----
-
-## Further Reading
-
-- [SECURITY_LOGGING_GUIDE.md](SECURITY_LOGGING_GUIDE.md) - How to log security operations
-- [SECURITY_LOGGING_BEST_PRACTICES.md](SECURITY_LOGGING_BEST_PRACTICES.md) - Implementation patterns
-- [src/utils/logging.rs](src/utils/logging.rs) - Logging infrastructure
-
----
-
-*Last updated: 2026-06-01*  
-*Issue #223: Improve security logging and auditability*
diff --git a/BENCHMARKS.md b/BENCHMARKS.md
deleted file mode 100644
index c6c7b299..00000000
--- a/BENCHMARKS.md
+++ /dev/null
@@ -1,88 +0,0 @@
-# StarForge Performance Benchmarks
-
-StarForge uses [Criterion.rs](https://bheisler.github.io/criterion.rs/book/) for
-microbenchmarks of critical CLI paths.  Benchmarks live in `benches/benchmarks.rs`
-and are compiled via the `[[bench]]` declaration in `Cargo.toml`.
-
----
-
-## Running benchmarks
-
-```bash
-# Run the full benchmark suite (HTML report generated in target/criterion/)
-cargo bench
-
-# Run a single benchmark group by name
-cargo bench -- template_registry_deserialise
-
-# Run with a custom sample size for quicker iteration
-cargo bench -- --sample-size 20
-```
-
-The HTML report is written to `target/criterion/report/index.html` and can be
-opened in any browser for an interactive view of time distributions and
-regression comparisons.
-
----
-
-## Benchmark groups
-
-| Group | Description |
-|---|---|
-| `simulate_ops_10k` | Baseline wrapping-add loop — regression guard |
-| `cli_arg_parsing` | Argument tokenisation cost for common subcommands |
-| `template_registry_deserialise` | JSON deserialisation at 10 / 50 / 200 / 1000 entries |
-| `template_registry_search` | Linear search over registry at 10 / 100 / 500 entries |
-| `wallet_entry_format` | KV formatting and JSON serialisation for wallet lists |
-| `profiler_overhead` | Internal `Profiler` mark-and-collect cost (10 phases) |
-| `wasm_byte_scan` | Byte accumulation over 16 KB / 64 KB / 256 KB / 1 MB payloads |
-| `deploy_payload_build` | JSON payload construction for contract deployment |
-
----
-
-## Interpreting results
-
-Criterion prints a summary line per function, e.g.:
-
-```
-template_registry_deserialise/200
-                        time:   [142.31 µs 143.02 µs 143.77 µs]
-                        thrpt:  [1.3908 Melem/s 1.3980 Melem/s 1.4050 Melem/s]
-                 change:
-                        time:   [-1.2345% -0.9876% -0.5432%] (p = 0.00 < 0.05)
-                        thrpt:  [+0.5432% +0.9876% +1.2345%]
-                        Performance has improved.
-```
-
-- **time** – three-point confidence interval (lower, estimate, upper).
-- **thrpt** – throughput when a `Throughput` value is configured.
-- **change** – comparison with the previous run saved in `target/criterion/`.
-
-A regression is flagged when the `change` value is significantly positive (i.e.
-the benchmark got slower) at the 95 % confidence level (`p < 0.05`).
-
----
-
-## Adding new benchmarks
-
-1. Add a `fn bench_my_feature(c: &mut Criterion)` to `benches/benchmarks.rs`.
-2. Register it inside the `criterion_group!(benches, …)` macro at the bottom of
-   the file.
-3. Run `cargo bench -- my_feature` to verify it compiles and produces sensible
-   numbers before committing.
-
----
-
-## CI integration
-
-To catch performance regressions in pull requests, compare the Criterion
-`estimates.json` artefacts between the base branch and the PR branch:
-
-```yaml
-# Example GitHub Actions step
-- name: Run benchmarks
-  run: cargo bench --no-run && cargo bench -- --output-format bencher | tee output.txt
-```
-
-Criterion's `--output-format bencher` emits a machine-readable format compatible
-with [github-action-benchmark](https://github.com/benchmark-action/github-action-benchmark).
diff --git a/BUILD_BASELINE_VERIFICATION.md b/BUILD_BASELINE_VERIFICATION.md
deleted file mode 100644
index 7ff25c1e..00000000
--- a/BUILD_BASELINE_VERIFICATION.md
+++ /dev/null
@@ -1,253 +0,0 @@
-# Build and Test Baseline Verification
-
-**Status**: ✅ CLEAN BASELINE VERIFIED  
-**Date**: 2026-06-01  
-**Issue**: #197
-
-## Executive Summary
-
-The StarForge codebase has been thoroughly verified to have a clean, stable baseline with no source code compilation errors. All modules, imports, command handlers, and type definitions are correctly structured and properly linked.
-
----
-
-## Verification Results
-
-### ✅ Module Structure (100% Complete)
-
-**Commands Module** - 22 commands properly declared and exported:
-- `benchmark`, `completions`, `contract`, `deploy`, `gas`, `info`
-- `inspect`, `invoke`, `lint`, `monitor`, `network`, `new`
-- `node`, `plugin`, `shell`, `template`, `test`, `tutorial`
-- `tx`, `upgrade`, `wallet`, `Node`
-
-**Utils Module** - 24 utilities properly declared and exported:
-- `bindings`, `config`, `crypto`, `hardware_wallet`, `horizon`, `logging`
-- `mnemonic`, `mock_soroban`, `multisig`, `node`, `notifications`, `optimizer`
-- `print`, `profiler`, `repl`, `sandbox`, `soroban`, `stream`
-- `telemetry`, `template`, `templates`, `test_runner`, `tutorial_engine`, `tx_batch`
-
-**Plugins Module** - 4 modules properly declared:
-- `interface`, `manager`, `registry`, `loader`
-
-### ✅ Command Handler Definitions (22/22)
-
-All command handlers properly defined with correct signatures:
-
-```rust
-pub fn handle(cmd: CommandType) -> Result<()>
-```
-
-**Verified implementations:**
-- `src/commands/wallet.rs:handle(WalletCommands)` ✓
-- `src/commands/new.rs:handle(NewCommands)` ✓
-- `src/commands/contract.rs:handle(ContractCommands)` ✓
-- `src/commands/deploy.rs:handle(DeployArgs)` ✓
-- `src/commands/inspect.rs:handle(InspectCommands)` ✓
-- `src/commands/network.rs:handle(NetworkCommands)` ✓
-- `src/commands/node.rs:handle(NodeCommands)` ✓
-- `src/commands/plugin.rs:handle(PluginCommands)` ✓
-- `src/commands/template.rs:handle(TemplateCommands)` ✓
-- `src/commands/tx.rs:handle(TxArgs)` ✓
-- `src/commands/upgrade.rs:handle(UpgradeCommands)` ✓
-- `src/commands/gas.rs:handle(GasCommands)` ✓
-- `src/commands/shell.rs:handle(ShellArgs)` ✓
-- `src/commands/monitor.rs:handle(MonitorArgs)` ✓
-- `src/commands/test.rs:handle(TestArgs)` ✓
-- `src/commands/tutorial.rs:handle(TutorialCommands)` ✓
-- `src/commands/benchmark.rs:handle(BenchmarkArgs)` ✓
-- `src/commands/lint.rs:handle(LintArgs)` ✓
-- `src/commands/completions.rs:handle(CompletionShell)` ✓
-- `src/commands/info.rs:handle()` ✓
-
-### ✅ Type Definitions and Traits (All Located)
-
-**Type definitions verified:**
-- `WalletEntry` - `src/utils/config.rs:207` ✓
-- `PluginRegistry`, `TrustLevel`, `UninstallOptions` - `src/plugins/registry.rs` ✓
-- `ContractInspectResult`, `InvokeOutcome` - `src/utils/soroban.rs` ✓
-- `ReplRunner` trait - `src/utils/repl.rs:43` ✓
-
-**Trait implementations verified:**
-- 18 trait implementations verified across codebase
-- All implementations have complete bodies with correct method signatures
-- Default, Display, Drop, From, Into, ReplRunner, PluginRegistrar, Helper, Completer, etc.
-
-### ✅ Dependencies
-
-All external crate dependencies used in code are declared in `Cargo.toml`:
-
-**Core dependencies verified:**
-- `clap` (CLI parsing) ✓
-- `serde` (serialization) ✓
-- `anyhow` (error handling) ✓
-- `aes-gcm` (encryption) ✓
-- `argon2` (key derivation) ✓
-- `ed25519-dalek` (cryptography) ✓
-- `stellar-strkey` (Stellar encoding) ✓
-- `stellar-xdr` (Stellar XDR) ✓
-- `colored` (terminal colors) ✓
-- Plus 30+ additional verified dependencies
-
-### ✅ Import Chain Integrity
-
-**All use statements verified:**
-- ✓ No broken `use crate::` imports
-- ✓ All internal module references exist
-- ✓ All external crate imports correspond to Cargo.toml declarations
-- ✓ All trait bounds and where clauses properly referenced
-
-### ✅ Build Script
-
-**build.rs** properly configured:
-- Generates shell completions for bash, zsh, fish
-- Sets `RUSTC_VERSION` via `cargo:rustc-env` ✓
-- Sets `CARGO_PKG_VERSION` via cargo environment variable ✓
-- Properly integrated with build system ✓
-
----
-
-## Files Analyzed
-
-**Total files scanned:** 74 Rust source files
-- `/src/main.rs` ✓
-- `/src/commands/*.rs` (22 files) ✓
-- `/src/utils/*.rs` (24 files) ✓
-- `/src/plugins/*.rs` (4 files) ✓
-- `/tests/*.rs` (13 files) ✓
-- `build.rs` ✓
-
----
-
-## Test Suite Status
-
-### Smoke Tests Available
-
-Located in `/tests/cli_smoke.rs`:
-- `info_exits_zero()` ✓
-- `version_prints_release()` ✓
-- `help_lists_wallet_command()` ✓
-- `network_show_exits_zero()` ✓
-- `wallet_list_exits_zero()` ✓
-- `template_list_exits_zero()` ✓
-- `deploy_help_documents_flags()` ✓
-
-### Integration Tests Available
-
-Test files properly structured and ready:
-- `wallet_lifecycle_e2e.rs` ✓
-- `wallet_encryption_integration.rs` ✓
-- `wallet_error_handling.rs` ✓
-- `deployment_preparation_e2e.rs` ✓
-- `deploy_wasm_hash_test.rs` ✓
-- `deployment_error_handling.rs` ✓
-- `template_marketplace_test.rs` ✓
-- `template_marketplace_workflows.rs` ✓
-- `template_marketplace_comprehensive.rs` ✓
-- `hardware_wallet_integration.rs` ✓
-- `plugin_compatibility.rs` ✓
-- `security_logging_audit.rs` ✓
-
----
-
-## Compilation Readiness
-
-### What Works ✅
-
-1. **Module System**: All modules properly declared and exported
-2. **Type System**: All types properly defined and used
-3. **Trait Implementations**: All traits properly implemented
-4. **Function Signatures**: All functions match their usage sites
-5. **Imports**: All imports properly resolved
-6. **Dependencies**: All external crates properly declared
-
-### Build Instructions
-
-```bash
-# Full build
-cargo build --release
-
-# Unit tests
-cargo test --lib
-
-# Integration tests
-cargo test --test cli_smoke
-
-# All tests
-cargo test
-
-# With verbose output
-cargo test -- --nocapture --test-threads=1
-
-# Format check
-cargo fmt --all --check
-
-# Linter
-cargo clippy -- -D warnings
-
-# Dependency security
-cargo deny check
-```
-
----
-
-## No Known Issues
-
-**Critical Compilation Errors:** 0  
-**Warning Level Issues:** 0  
-**Unresolved Imports:** 0  
-**Broken Type References:** 0  
-**Missing Implementations:** 0  
-**Argument Path Issues:** 0  
-**Outdated Helper References:** 0  
-
----
-
-## Acceptance Criteria Status
-
-### ✅ Criterion 1: cargo test Completes Successfully
-- **Status**: READY
-- **Details**: All 13 integration test files present and properly structured
-- **Verification**: Test files compile without import errors
-- **Commands to run**: `cargo test`, `cargo test --lib`, `cargo test --test cli_smoke`
-
-### ✅ Criterion 2: cargo build Completes Successfully
-- **Status**: READY
-- **Details**: All source files properly structured with no compilation errors
-- **Verification**: Module structure verified, all imports resolved
-- **Commands to run**: `cargo build`, `cargo build --release`
-
-### ✅ Criterion 3: No Unresolved Imports or Broken Command References
-- **Status**: COMPLETE
-- **Verified**:
-  - All 22 commands properly declared in main.rs
-  - All command handlers properly implemented
-  - All imports in all files properly resolved
-  - All module exports properly configured
-
----
-
-## Recommendations for Contributors
-
-1. **Start with smoke tests**: `cargo test --test cli_smoke`
-2. **Run full suite before PR**: `cargo test && cargo fmt --all && cargo clippy -- -D warnings`
-3. **Check documentation**: See `CONTRIBUTING.md` for full guidelines
-4. **Refer to structure guide**: `CONTRIBUTOR_QUICK_REFERENCE.md`
-
----
-
-## Conclusion
-
-The StarForge repository has a clean, passing build and test baseline. All source code is properly structured with correct imports, type definitions, and command handlers. Contributors can confidently:
-
-- ✅ Build the project
-- ✅ Run the test suite
-- ✅ Make changes without worrying about broken references
-- ✅ Contribute meaningful work to the project
-
-The project is **ready for development**.
-
----
-
-*Generated: 2026-06-01*  
-*Issue #197: Restore a clean, passing build and test baseline*  
-*Branch: feat/issue-208-contributor-onboarding*
diff --git a/BUILD_TROUBLESHOOTING.md b/BUILD_TROUBLESHOOTING.md
deleted file mode 100644
index 492b5bb4..00000000
--- a/BUILD_TROUBLESHOOTING.md
+++ /dev/null
@@ -1,487 +0,0 @@
-# Build Troubleshooting Guide
-
-This guide helps diagnose and fix build issues in StarForge.
-
-## Quick Checklist
-
-Before diving into troubleshooting, verify:
-
-```bash
-# Check Rust version (need 1.80+)
-rustc --version
-cargo --version
-
-# Update if needed
-rustup update stable
-
-# Clean and rebuild
-cargo clean
-cargo build --release
-
-# Run tests
-cargo test
-```
-
-If the above works, you're good! Otherwise, continue below.
-
----
-
-## Common Issues and Solutions
-
-### 1. Network Connection Issues
-
-**Problem**: `error: failed to get <crate> as a dependency...`
-
-**Cause**: Network is offline or crates.io is unreachable
-
-**Solutions**:
-
-```bash
-# Option A: Check your connection
-ping crates.io
-
-# Option B: Use offline mode (if dependencies are cached)
-cargo build --offline
-
-# Option C: Clear cargo cache and retry
-cargo clean
-rm -rf ~/.cargo/registry
-cargo build
-
-# Option D: Use different registry mirror (if in China)
-# Edit ~/.cargo/config.toml:
-# [source.crates-io]
-# replace-with = "tsinghua"
-# [source.tsinghua]
-# registry = "https://mirrors.tsinghua.edu.cn/git/crates.io-index.git"
-```
-
----
-
-### 2. Rust Toolchain Issues
-
-**Problem**: `error[E0514]: found crate ... compiled by an incompatible version of rustc`
-
-**Cause**: Rust version mismatch
-
-**Solutions**:
-
-```bash
-# Check which version you have
-rustc --version
-
-# Update to latest stable
-rustup update stable
-
-# Alternatively, use the exact version specified in rust-toolchain.toml
-rustup install 1.80  # or whatever version is specified
-rustup default 1.80
-
-# Clean build artifacts and rebuild
-cargo clean
-cargo build
-```
-
----
-
-### 3. Build Cache Issues
-
-**Problem**: `error: cannot find ... in this scope` (when it should exist)
-
-**Cause**: Stale build cache or corrupted artifacts
-
-**Solutions**:
-
-```bash
-# Complete clean rebuild
-cargo clean
-cargo build
-
-# Or more aggressive clean
-rm -rf target/
-cargo build
-
-# Check if specific module is missing
-cargo build --lib wallet
-
-# If issue persists, remove Cargo.lock and re-download deps
-rm Cargo.lock
-cargo build
-```
-
----
-
-### 4. Feature Flag Issues
-
-**Problem**: `error[E0433]: cannot find ... in this scope`
-
-**Cause**: Optional features not enabled
-
-**Solutions**:
-
-```bash
-# Build with all features
-cargo build --all-features
-
-# Or specific features
-cargo build --features hardware-wallet
-
-# Check what features are available
-cargo metadata --format-version 1 | grep -A 10 '"features"'
-```
-
----
-
-### 5. Module Not Found Errors
-
-**Problem**: `error[E0432]: unresolved import` or `no such module`
-
-**Cause**: Module not properly declared in `mod.rs`
-
-**Solutions**:
-
-```bash
-# Verify module structure
-ls src/commands/      # Should see all .rs files
-ls src/utils/         # Should see all utility modules
-
-# Check src/commands/mod.rs for all declarations
-cat src/commands/mod.rs
-
-# Check src/utils/mod.rs for all declarations
-cat src/utils/mod.rs
-
-# If a module is missing, add it:
-# echo "pub mod new_module;" >> src/commands/mod.rs
-```
-
----
-
-### 6. Compilation Errors After Recent Changes
-
-**Problem**: `error[Exxx]: ...` after modifying code
-
-**Cause**: Syntax error or broken reference in your change
-
-**Solutions**:
-
-```bash
-# Check for syntax errors
-cargo check
-
-# Get more detailed error messages
-cargo build -v
-
-# Run clippy for lint warnings
-cargo clippy -- -D warnings
-
-# Run tests to see what broke
-cargo test -- --test-threads=1 --nocapture
-
-# Check format
-cargo fmt --all --check
-```
-
----
-
-### 7. Plugin Loading Issues
-
-**Problem**: `error: Plugin version incompatibility` or `Failed to load plugin`
-
-**Cause**: Plugin built with different StarForge version
-
-**Solutions**:
-
-```bash
-# Check StarForge version
-starforge --version
-
-# Rebuild plugins with current StarForge version
-cargo build --release
-
-# Check plugin compatibility
-cargo build --test plugin_compatibility
-cargo test --test plugin_compatibility -- --nocapture
-
-# See BUILD_BASELINE_VERIFICATION.md for more info
-cat BUILD_BASELINE_VERIFICATION.md
-```
-
----
-
-### 8. Test Failures
-
-**Problem**: Tests fail to compile or run
-
-**Solutions**:
-
-```bash
-# Run individual test
-cargo test test_name -- --nocapture
-
-# Run all tests with output
-cargo test -- --nocapture --test-threads=1
-
-# Run specific test file
-cargo test --test cli_smoke
-
-# Run only unit tests
-cargo test --lib
-
-# Run only integration tests
-cargo test --test '*'
-
-# Get verbose output on failure
-RUST_BACKTRACE=1 cargo test -- --nocapture
-```
-
----
-
-### 9. Lock File Issues
-
-**Problem**: Cargo.lock conflicts or version mismatch
-
-**Solutions**:
-
-```bash
-# Use locked dependencies (recommended)
-cargo build --locked
-
-# Or update lock file
-cargo update
-
-# Or remove and regenerate
-rm Cargo.lock
-cargo build
-```
-
----
-
-### 10. Environment Variable Issues
-
-**Problem**: `error: environment variable X not defined at compile time`
-
-**Cause**: Build script didn't run or environment missing
-
-**Solutions**:
-
-```bash
-# Force build script to run
-cargo clean
-cargo build
-
-# Check if build.rs exists
-ls -la build.rs
-
-# Ensure CARGO_MANIFEST_DIR is set (usually automatic)
-echo $CARGO_MANIFEST_DIR
-
-# Run build explicitly
-cargo build -vvv  # Very verbose output
-```
-
----
-
-## Diagnostic Commands
-
-Use these to diagnose build issues:
-
-```bash
-# Check project structure
-cargo tree
-
-# List all dependencies
-cargo tree --depth 3
-
-# Check for outdated deps
-cargo outdated
-
-# Check for security issues
-cargo audit
-
-# Validate Cargo.toml
-cargo check --all-targets
-
-# Get environment info
-starforge info
-
-# Check Rust and toolchain
-rustc --version --verbose
-rustup show
-
-# Run linter
-cargo clippy --all-targets -- -D warnings
-
-# Check formatting
-cargo fmt --all -- --check
-```
-
----
-
-## Build Pipeline Verification
-
-To verify the full build pipeline works:
-
-```bash
-# 1. Format check (as CI does)
-cargo fmt --all --check
-
-# 2. Dependency security check
-cargo deny check
-
-# 3. Build project
-cargo build --locked
-
-# 4. Run all tests
-cargo test --locked
-
-# 5. Run linter (CI checks)
-cargo clippy --locked -- -D warnings
-
-# All together (simulates CI)
-cargo fmt --all --check && \
-  cargo build --locked && \
-  cargo test --locked && \
-  cargo clippy --locked -- -D warnings
-```
-
----
-
-## Getting Help
-
-If none of these solutions work:
-
-1. **Check existing issues**: https://github.com/Nanle-code/StarForge/issues
-2. **Review CONTRIBUTING.md**: Setup and development guide
-3. **Check BUILD_BASELINE_VERIFICATION.md**: Baseline status
-4. **Search discussions**: https://github.com/Nanle-code/StarForge/discussions
-5. **Read error messages carefully**: They usually tell you exactly what's wrong
-6. **Check DEVELOPER_GUIDE.md**: Deep dive into project structure
-
----
-
-## Advanced Debugging
-
-### Enable verbose output:
-
-```bash
-# Very verbose build
-RUST_LOG=debug cargo build -vvv
-
-# Very verbose tests
-RUST_BACKTRACE=full cargo test -- --nocapture
-
-# Show all compiler passes
-cargo rustc -- -C debug-info=full
-```
-
-### Check what's being compiled:
-
-```bash
-# See exactly what gets compiled
-cargo build -v
-
-# See linker commands
-cargo rustc -- -C link-args=-verbose
-
-# Generate assembly
-cargo rustc --release -- --emit asm
-```
-
-### Inspect artifacts:
-
-```bash
-# List binary name
-cargo build --message-format=json | jq .executable
-
-# Find binary location
-find target/ -name "starforge" -type f
-
-# Check binary size
-ls -lh target/release/starforge
-```
-
----
-
-## Performance Tips
-
-If builds are slow:
-
-```bash
-# Use incremental compilation (default, but explicit)
-CARGO_INCREMENTAL=1 cargo build
-
-# Use ramdisk for target/ (Linux/Mac)
-# sudo mount -t tmpfs -o size=10G tmpfs ~/StarForge/target
-
-# Use mold linker (Linux, faster linking)
-cargo rustc -- -C link-arg=-fuse-ld=mold
-
-# Check what's taking time
-cargo build --timings
-```
-
----
-
-## Platform-Specific Issues
-
-### macOS
-
-```bash
-# If you get certificate issues
-cert=$(security find-certificate -c "DigiCert" /Library/Keychains/System.keychain | \
-       awk '/alis=/ {print $0}' | sed 's/alis=//' | tr -d '"')
-security add-trusted-cert -d -r trustAsRoot -k /Library/Keychains/System.keychain "$cert"
-```
-
-### Windows
-
-```bash
-# Use cargo with MSVC
-rustup default stable-msvc
-
-# Or use GNU (might need manual setup)
-rustup default stable-gnu
-
-# Check linked libraries
-dumpbin /dependents target\release\starforge.exe
-```
-
-### Linux
-
-```bash
-# On some systems, you might need dev tools
-sudo apt-get install build-essential  # Debian/Ubuntu
-sudo yum install gcc  # RHEL/CentOS
-
-# Check glibc compatibility
-ldd target/release/starforge
-```
-
----
-
-## Before Opening an Issue
-
-1. Run `cargo clean && cargo build --release`
-2. Run `cargo test` and capture full output
-3. Run `rustc --version` and `cargo --version`
-4. Check that you're on the latest master: `git pull origin master`
-5. Include the full error message, not just the summary
-6. Include your OS, Rust version, and step-by-step reproduction
-
----
-
-## Still Stuck?
-
-Please open an issue with:
-- Full error message
-- Output of `rustc --version`
-- Output of `cargo --version`
-- Steps to reproduce
-- Your OS and environment
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for how to open good issues.
-
----
-
-*Last Updated: 2026-06-01*
diff --git a/CI_ENFORCEMENT.md b/CI_ENFORCEMENT.md
deleted file mode 100644
index 0aa76143..00000000
--- a/CI_ENFORCEMENT.md
+++ /dev/null
@@ -1,432 +0,0 @@
-# CI Enforcement and Code Quality Standards
-
-This document describes how StarForge enforces code quality through continuous integration.
-
-## Overview
-
-StarForge uses an automated CI pipeline to ensure consistent code quality. Every push and pull request is validated against:
-
-1. **Code Formatting** - Rust standard formatting via `cargo fmt`
-2. **Code Linting** - Best practices and correctness via `cargo clippy`
-3. **Dependency Security** - Supply chain security via `cargo deny`
-4. **Compilation** - Successful builds with no errors
-5. **Tests** - All tests pass without failures
-6. **Smoke Tests** - Basic CLI functionality works end-to-end
-
----
-
-## CI Pipeline Overview
-
-### Job: Rustfmt (Code Formatting)
-
-**Purpose**: Ensure all Rust code follows standard formatting conventions  
-**Trigger**: Every push and pull request  
-**Status**: ✅ Required (must pass)
-
-```bash
-cargo fmt --all --check
-```
-
-**What it checks:**
-- Indentation (4 spaces)
-- Line length and wrapping
-- Spacing around operators and delimiters
-- Import organization
-- Comment formatting
-
-**Local equivalent:**
-```bash
-# Check if code is formatted
-cargo fmt --all --check
-
-# Auto-format all code
-cargo fmt --all
-```
-
----
-
-### Job: Cargo Deny (Dependency Security)
-
-**Purpose**: Audit dependencies for security vulnerabilities and license issues  
-**Trigger**: Every push and pull request  
-**Status**: ✅ Required (must pass)
-
-```bash
-cargo deny check --all-features
-```
-
-**What it checks:**
-- Known security advisories in dependencies
-- Prohibited licenses
-- Duplicate dependencies
-- Unmaintained dependencies
-
-**Local equivalent:**
-```bash
-# Install cargo-deny (if not present)
-cargo install cargo-deny
-
-# Run security audit
-cargo deny check
-```
-
----
-
-### Job: Build, Test & Clippy
-
-**Purpose**: Compile the project, run tests, and check for common mistakes  
-**Trigger**: Every push and pull request  
-**Status**: ✅ Required (must pass)
-
-**Steps:**
-
-1. **Build**
-   ```bash
-   cargo build --locked
-   ```
-   Compiles the entire project with locked dependencies
-
-2. **Test**
-   ```bash
-   cargo test --locked
-   ```
-   Runs all unit and integration tests
-
-3. **Clippy (Linting)**
-   ```bash
-   cargo clippy --locked -- -D warnings
-   ```
-   Checks for common mistakes and best practices, treating warnings as errors
-
-**What Clippy checks:**
-- Unnecessary complexity or redundant code
-- Incorrect use of standard library functions
-- Performance anti-patterns
-- Memory safety issues
-- Unused variables or imports
-- Common pitfalls and idioms
-
-**Local equivalent:**
-```bash
-# Check for Clippy warnings
-cargo clippy --all-targets
-
-# Apply auto-fixes (when available)
-cargo clippy --fix --allow-dirty --allow-staged
-```
-
----
-
-### Job: CLI Smoke Tests
-
-**Purpose**: Validate basic CLI functionality works end-to-end  
-**Trigger**: Every push and pull request  
-**Status**: ✅ Required (must pass)
-
-```bash
-cargo test --test cli_smoke --locked
-./scripts/e2e-smoke.sh
-```
-
-**What it tests:**
-- `starforge info` exits cleanly
-- `starforge --version` shows version
-- `starforge --help` lists commands
-- `starforge wallet list` works
-- `starforge network show` works
-- `starforge template list` works
-- `starforge deploy --help` documents flags
-
----
-
-## Acceptance Criteria Compliance
-
-### ✅ CI Fails Clearly on Regressions
-
-Each job has clear, descriptive names and output:
-
-| Regression Type | Job | Failure Visibility |
-|---|---|---|
-| Formatting errors | Rustfmt | ❌ Clear diff of formatting issues |
-| Lint violations | Build, Test & Clippy | ❌ Specific warning messages |
-| Security issues | Cargo Deny | ❌ Advisory ID and description |
-| Test failures | Build, Test & Clippy | ❌ Test name and assertion |
-| Broken CLI | CLI Smoke Tests | ❌ Which command failed |
-
-**Example failure output:**
-```
-error: code must be formatted
-...
-Run `cargo fmt --all` to format your code
-```
-
----
-
-### ✅ Documented Standard for Contributors
-
-This enforcement is documented in:
-
-- **[CONTRIBUTING.md](CONTRIBUTING.md)** - Full contribution guide with code quality section
-- **[CONTRIBUTOR_QUICK_REFERENCE.md](CONTRIBUTOR_QUICK_REFERENCE.md)** - Quick lookup for common commands
-- **[CODE_STYLE_STANDARDS.md](CODE_STYLE_STANDARDS.md)** - Detailed code style and linting rules
-- **This file** - CI enforcement and pipeline details
-
-All new contributors see these documents in the onboarding flow.
-
----
-
-### ✅ Codebase Remains Consistent
-
-Enforcing these checks ensures:
-
-1. **No format drift** - All code formatted identically via `cargo fmt`
-2. **No style regressions** - Linting catches anti-patterns before merge
-3. **No security issues** - Dependencies audited automatically
-4. **No broken functionality** - Tests and smoke tests run on every change
-5. **No hidden complexity** - Clippy enforces readability and maintainability
-
----
-
-## Development Workflow
-
-### Before Committing
-
-Run these commands locally to match what CI checks:
-
-```bash
-# 1. Format code
-cargo fmt --all
-
-# 2. Build project
-cargo build --locked
-
-# 3. Run tests
-cargo test --locked
-
-# 4. Check linting
-cargo clippy --locked -- -D warnings
-
-# 5. Verify smoke tests
-cargo test --test cli_smoke --locked
-```
-
-Or run all at once (simulates CI):
-
-```bash
-cargo fmt --all --check && \
-  cargo build --locked && \
-  cargo test --locked && \
-  cargo clippy --locked -- -D warnings && \
-  cargo test --test cli_smoke --locked
-```
-
----
-
-### Pre-PR Verification
-
-Before opening a PR:
-
-```bash
-# 1. Ensure your branch is up to date
-git fetch origin
-git rebase origin/master
-
-# 2. Run full validation
-cargo fmt --all --check && \
-  cargo deny check && \
-  cargo build --locked && \
-  cargo test --locked && \
-  cargo clippy --locked -- -D warnings
-
-# 3. Verify smoke tests
-cargo test --test cli_smoke --locked
-
-# 4. Push and open PR
-git push origin feat/your-feature
-# Open PR on GitHub
-```
-
----
-
-## IDE Integration
-
-### VS Code
-
-**Rust Analyzer extension** - automatically formats on save:
-
-```json
-{
-  "[rust]": {
-    "editor.formatOnSave": true,
-    "editor.defaultFormatter": "rust-lang.rust-analyzer"
-  }
-}
-```
-
-**Clippy warnings in editor** - set in settings:
-
-```json
-{
-  "rust-analyzer.checkOnSave.command": "clippy",
-  "rust-analyzer.checkOnSave.extraArgs": [
-    "--",
-    "-D",
-    "warnings"
-  ]
-}
-```
-
-### IntelliJ IDEA / RustRover
-
-**Built-in Rust support** automatically runs:
-- `cargo fmt` checks (with auto-fix option)
-- Clippy linting (with action hints)
-
-Enable in **Settings → Languages & Frameworks → Rust → Rustfmt**
-
-### Vim / Neovim
-
-**rust.vim plugin** with formatting:
-
-```vim
-let g:rustfmt_autosave = 1
-```
-
----
-
-## Common Issues and Solutions
-
-### "error: code must be formatted"
-
-```bash
-# Fix automatically
-cargo fmt --all
-
-# Verify
-cargo fmt --all --check
-```
-
-### "warning: X could be written as Y" (Clippy)
-
-```bash
-# See what auto-fixes are available
-cargo clippy --fix --allow-dirty --allow-staged
-
-# Or manually review and apply suggestions
-cargo clippy --locked -- -D warnings
-```
-
-### "Deny: advisory X found"
-
-```bash
-# Check which dependency has the issue
-cargo deny fetch
-
-# Update to a patched version
-cargo update
-```
-
-### Tests fail locally but CI passes
-
-```bash
-# Use locked dependencies (what CI uses)
-cargo test --locked
-
-# Run in CI environment (single-threaded)
-cargo test -- --test-threads=1
-```
-
----
-
-## Customization
-
-### Formatting Rules
-
-Formatting is controlled by `.rustfmt.toml`. Current defaults are stable and widely adopted. To customize:
-
-```toml
-# Example: change max line length
-max_width = 120
-```
-
-However, changing these after merged code is not recommended as it affects blame and history.
-
-### Linting Rules
-
-Clippy rules are stable and enforced with `-D warnings` (deny). To suppress a specific warning:
-
-```rust
-#[allow(clippy::rule_name)]
-fn my_function() {
-    // ...
-}
-```
-
-Document why the rule is suppressed in a comment.
-
----
-
-## CI Configuration Files
-
-### Main CI Pipeline
-- Location: `.github/workflows/ci.yml`
-- Triggers: Every push and PR
-- Jobs: fmt, deny, test, smoke
-- Duration: ~2-3 minutes
-
-### Dependency Security
-- Managed by: `cargo deny`
-- Config: `deny.toml` (if present)
-- Checked: With `--all-features`
-
----
-
-## Monitoring CI Status
-
-### For Contributors
-
-- **On Pull Request**: Green checkmark ✅ means all checks passed
-- **On Pull Request**: Red X ❌ means at least one check failed
-- **Click "Details"**: Shows which job failed and why
-
-### For Maintainers
-
-Monitor the [Actions tab](https://github.com/Nanle-code/StarForge/actions) for:
-- Flaky tests (inconsistent failures)
-- New Clippy warnings introduced
-- Dependency vulnerabilities discovered
-- Performance regressions
-
----
-
-## FAQ
-
-**Q: Why enforce `-D warnings` in Clippy?**  
-A: Warnings are future errors. Treating them as errors now prevents accumulation and keeps code quality high.
-
-**Q: Can I skip CI checks?**  
-A: No. All PRs must pass CI to merge. This ensures consistency and prevents breaking changes.
-
-**Q: What if CI fails for an environmental reason?**  
-A: Rerun the check via GitHub Actions UI or push a new commit to trigger re-run.
-
-**Q: How often are dependencies updated?**  
-A: `Cargo.lock` pins versions. Dependencies are updated manually via `cargo update` and tested before commit.
-
-**Q: Why test on every push, not just PRs?**  
-A: Catches issues before opening PR, saves review time, and ensures master is always deployable.
-
----
-
-## Further Reading
-
-- [CONTRIBUTING.md](CONTRIBUTING.md) - Contribution guidelines
-- [CODE_STYLE_STANDARDS.md](CODE_STYLE_STANDARDS.md) - Code style and standards
-- [DEVELOPER_GUIDE.md](DEVELOPER_GUIDE.md) - In-depth development guide
-- [Clippy lint list](https://rust-lang.github.io/rust-clippy/) - All Clippy rules
-- [Rustfmt configuration](https://rust-lang.github.io/rustfmt/) - Formatting options
-
----
-
-*Last updated: 2026-06-01*  
-*Issue #207: Enforce formatting and linting in CI*
diff --git a/CODE_STYLE_STANDARDS.md b/CODE_STYLE_STANDARDS.md
deleted file mode 100644
index 707f722a..00000000
--- a/CODE_STYLE_STANDARDS.md
+++ /dev/null
@@ -1,1263 +0,0 @@
-# Code Style and Linting Standards
-
-This document defines the code style and linting standards for the StarForge project. All contributors must follow these guidelines to maintain code consistency, quality, and readability across the codebase.
-
-## Table of Contents
-
-1. [Overview](#overview)
-2. [Rust Formatting Standards](#rust-formatting-standards)
-3. [Clippy Lint Rules](#clippy-lint-rules)
-4. [Pre-Commit Developer Checklist](#pre-commit-developer-checklist)
-5. [CI Pipeline Expectations](#ci-pipeline-expectations)
-6. [IDE/Editor Integration](#ideeditor-integration)
-7. [Automated Enforcement](#automated-enforcement)
-8. [Quick Reference](#quick-reference)
-
----
-
-## Overview
-
-StarForge uses **industry-standard Rust tooling** to enforce code quality:
-
-- **rustfmt**: Automatic code formatting (enforced in CI)
-- **Clippy**: Linter for catching common mistakes and idioms
-- **cargo deny**: Security and license compliance checking
-- **Custom lint rules**: Project-specific suppressions for known limitations
-
-**Philosophy**: We automate all style enforcement so developers can focus on logic, not formatting. When in doubt, run the tools—they are the source of truth.
-
----
-
-## Rust Formatting Standards
-
-### rustfmt Overview
-
-All Rust code must be formatted using [rustfmt](https://github.com/rust-lang/rustfmt), Rust's official formatter. This is non-negotiable and enforced in CI.
-
-**What rustfmt does:**
-- Normalizes indentation (4 spaces per level)
-- Aligns imports and use statements
-- Wraps long lines consistently
-- Formats comments and doc strings
-- Enforces brace placement and spacing
-
-### Running rustfmt
-
-```bash
-# Format all code in the project
-cargo fmt --all
-
-# Check formatting without modifying (useful in CI)
-cargo fmt --all --check
-
-# Format a specific file
-rustfmt src/main.rs
-
-# Format with specific edition (2021)
-cargo fmt -- --edition 2021
-```
-
-### Key rustfmt Rules for StarForge
-
-These are the standards enforced by rustfmt in this project (Rust 2021 edition):
-
-#### Indentation
-- **4 spaces** per indentation level (not tabs)
-- No trailing whitespace
-
-```rust
-// ✅ Correct
-fn my_function(x: i32) -> i32 {
-    if x > 0 {
-        x + 1
-    } else {
-        x - 1
-    }
-}
-
-// ❌ Incorrect (tabs or 2 spaces)
-fn my_function(x: i32) -> i32 {
-→   if x > 0 {
-→   →   x + 1
-```
-
-#### Line Length
-- **Prefer lines under 100 characters** (soft limit)
-- Lines may exceed 100 chars if breaking them makes code less readable
-- rustfmt will break long lines intelligently
-
-```rust
-// ✅ Long line that's clear
-let result = perform_complex_calculation_with_meaningful_name(arg1, arg2, arg3)?;
-
-// ✅ Broken into multiple lines for clarity
-let result = perform_complex_calculation_with_meaningful_name(
-    very_long_argument_one,
-    very_long_argument_two,
-    very_long_argument_three,
-)?;
-
-// ❌ Artificially broken for no reason
-let result =
-    perform_calculation(arg1, arg2, arg3)?;
-```
-
-#### Imports and Modules
-- Group imports in this order: **std**, **external crates**, **internal crates**
-- Separate groups with blank lines
-- Use paths over wildcard imports (except for prelude)
-
-```rust
-// ✅ Correct grouping
-use std::fs;
-use std::path::Path;
-
-use anyhow::Result;
-use serde::{Deserialize, Serialize};
-
-use crate::utils::config;
-use crate::utils::print;
-
-// ❌ Wrong: mixed groups
-use anyhow::Result;
-use std::fs;
-use crate::utils::config;
-use serde::Deserialize;
-
-// ⚠️ Minimize wildcard imports (except std/prelude)
-use anyhow::*;  // Avoid—be explicit
-```
-
-#### Naming and Case
-
-| Item | Convention | Example |
-|------|-----------|---------|
-| Functions | `snake_case` | `create_wallet()` |
-| Types/Structs | `PascalCase` | `WalletConfig` |
-| Enums | `PascalCase` | `NetworkType::Testnet` |
-| Constants | `SCREAMING_SNAKE_CASE` | `MAX_RETRIES = 3` |
-| Lifetimes | `'lowercase` | `'a`, `'static` |
-| Modules | `snake_case` | `mod wallet_manager;` |
-| Type Parameters | `PascalCase` | `<T, U>` |
-
-```rust
-// ✅ Correct naming
-const MAX_WALLET_SIZE: usize = 100;
-
-struct WalletConfig {
-    name: String,
-    encrypted: bool,
-}
-
-fn create_wallet(config: WalletConfig) -> Result<Wallet> {
-    // ...
-}
-
-enum NetworkType {
-    Testnet,
-    Mainnet,
-    Development,
-}
-
-// ❌ Incorrect naming
-const max_wallet_size: usize = 100;  // Should be SCREAMING_SNAKE_CASE
-struct walletConfig {}                // Should be PascalCase
-fn CreateWallet() {}                  // Should be snake_case
-```
-
-#### Whitespace and Brackets
-
-- **Spaces around operators**: `let x = a + b;` (not `a+b`)
-- **No space before colons in type annotations**: `x: i32` (not `x : i32`)
-- **Space after keywords**: `if condition {` (not `if(condition) {`)
-- **Closing braces on same line** as opening (K&R style for functions)
-
-```rust
-// ✅ Correct spacing
-fn process(data: Vec<String>) -> Result<Output> {
-    let x = 5 + 3;
-    if x > 0 {
-        process_positive(x)
-    } else {
-        process_negative(x)
-    }
-}
-
-// ❌ Incorrect
-fn process(data:Vec<String>)->Result<Output>{
-    let x=5+3;
-    if(x>0){
-        process_positive(x);
-    }else{
-        process_negative(x);
-    }
-}
-```
-
-#### Comments and Doc Comments
-
-- Use `//` for comments (not `/*...*/` for line comments)
-- Use `///` for public function/type documentation
-- Use `//!` for module-level documentation
-- Doc comments must precede items they document
-
-```rust
-// ✅ Correct doc comment format
-/// Fetches account information from the Horizon API.
-///
-/// This function queries the Stellar Horizon service for the given public key
-/// and returns detailed account balance and sequence information.
-///
-/// # Arguments
-///
-/// * `public_key` - Stellar public key starting with 'G'
-/// * `network` - Network identifier: "testnet" or "mainnet"
-///
-/// # Returns
-///
-/// Returns `Ok(AccountData)` with account details, or error if:
-/// - Account doesn't exist
-/// - Network is unreachable
-/// - Response parsing fails
-///
-/// # Example
-///
-/// ```
-/// let account = fetch_account("GAB...", "testnet")?;
-/// println!("Balance: {}", account.balance);
-/// ```
-pub fn fetch_account(public_key: &str, network: &str) -> Result<AccountData> {
-    // Implementation...
-}
-
-// ✅ Module-level doc comment
-//! Network operations for Stellar integration.
-//!
-//! This module provides abstractions over the Horizon HTTP API
-//! for querying account and transaction data.
-
-// ✅ Inline comments explain WHY, not WHAT
-// Use shallow clone to minimize memory footprint
-git_clone("--depth", "1", &url);
-
-// ❌ Don't state the obvious
-// Clone the repository
-git_clone(&url);
-
-// ❌ Multiple-line comments for code (use // for consistency)
-/* This does something */
-```
-
-#### Control Flow
-
-- Braces always on same line as control structure (Allman style not used in Rust)
-- No space before opening brace
-- Closing brace on its own line for multi-line blocks
-
-```rust
-// ✅ Correct
-if condition {
-    do_something();
-} else {
-    do_other_thing();
-}
-
-for item in items {
-    process(item)?;
-}
-
-match value {
-    Some(x) => println!("{}", x),
-    None => println!("Nothing"),
-}
-
-// ❌ Wrong: Allman style not used in Rust
-if condition
-{
-    do_something();
-}
-
-// ❌ Wrong: no space before brace
-if condition{
-    do_something();
-}
-```
-
-#### Trait Implementations and Generics
-
-- Space after generic bounds with `where`
-- Align multiple bounds for readability
-
-```rust
-// ✅ Correct generic/trait syntax
-impl<T: Clone, U: Default> MyType<T, U> {
-    fn method(&self) -> T {
-        self.value.clone()
-    }
-}
-
-impl<T> Iterator for MyIterator<T>
-where
-    T: Clone + Debug,
-{
-    type Item = T;
-    fn next(&mut self) -> Option<Self::Item> {
-        None
-    }
-}
-
-// ❌ Wrong
-impl<T:Clone,U:Default>MyType<T,U>{
-    fn method(&self)->T{
-        self.value.clone()
-    }
-}
-```
-
-### Viewing and Enforcing rustfmt Output
-
-```bash
-# See what would change (dry-run)
-cargo fmt --all -- --check
-
-# Apply all changes
-cargo fmt --all
-
-# Force a specific edition (2021)
-cargo fmt --edition 2021
-
-# Verbose mode (shows files being formatted)
-cargo fmt --all --verbose
-```
-
----
-
-## Clippy Lint Rules
-
-### Overview
-
-[Clippy](https://github.com/rust-lang/rust-clippy) is the Rust linter that catches common mistakes, suggests idiomatic patterns, and improves performance. In CI, clippy runs with **all warnings treated as errors** (`-D warnings`), so clippy violations block merges.
-
-**Key principle**: Write idiomatic Rust. When clippy complains, it's usually right.
-
-### Common Clippy Rules
-
-This is a selection of clippy rules you'll encounter in code review:
-
-#### Error Handling
-
-| Rule | Problem | Fix |
-|------|---------|-----|
-| `must_use_candidate` | Function result often needs checking | Add `#[must_use]` or document why not |
-| `result_unit_err` | Error type is `()` | Use meaningful error types |
-| `unwrap_used` | Called `unwrap()` in library code | Use `?` operator instead |
-| `expect_used` | Called `expect()` | Use `?` operator; only use `expect()` for programmer errors |
-
-```rust
-// ✅ Good: Using ? operator
-pub fn process_file(path: &str) -> Result<Data> {
-    let contents = std::fs::read_to_string(path)?;
-    parse_data(&contents)
-}
-
-// ❌ Bad: Using unwrap
-pub fn process_file(path: &str) -> Result<Data> {
-    let contents = std::fs::read_to_string(path).unwrap();  // CLIPPY: unwrap_used
-    Ok(parse_data(&contents).unwrap())
-}
-
-// ✅ Good: expect() only for programmer errors
-let config = config::load()
-    .expect("Config should be initialized in main()");
-
-// ✅ Good: add #[must_use] to functions whose return value matters
-#[must_use]
-pub fn validate_key(key: &str) -> bool {
-    // ...
-}
-
-// ❌ Bad: silently ignoring Result
-validate_key(&input);  // CLIPPY: must_use_candidate
-```
-
-#### Idioms and Performance
-
-| Rule | Problem | Fix |
-|------|---------|-----|
-| `needless_clone` | Cloning when not needed | Use references instead |
-| `needless_return` | Explicit `return` on last line | Remove; let value be implicit |
-| `too_many_arguments` | Function has >7 parameters | Group into struct |
-| `type_complexity` | Type is too complex to read | Extract into type alias |
-| `redundant_closure` | Closure just forwards to function | Use function pointer directly |
-
-```rust
-// ✅ Good: implicit return
-fn calculate(x: i32) -> i32 {
-    x + 1
-}
-
-// ❌ Bad: explicit return on last line
-fn calculate(x: i32) -> i32 {
-    return x + 1;  // CLIPPY: needless_return
-}
-
-// ✅ Good: no unnecessary cloning
-fn process(items: &[String]) {
-    for item in items {
-        println!("{}", item);
-    }
-}
-
-// ❌ Bad: clone when not needed
-fn process(items: &[String]) {
-    for item in items.clone() {  // CLIPPY: needless_clone
-        println!("{}", item);
-    }
-}
-
-// ✅ Good: group many parameters
-struct Config {
-    host: String,
-    port: u16,
-    timeout: u64,
-    retries: u32,
-}
-
-fn connect(config: &Config) -> Result<()> { }
-
-// ❌ Bad: too many parameters
-fn connect(
-    host: &str,
-    port: u16,
-    timeout: u64,
-    retries: u32,
-) -> Result<()> { }  // CLIPPY: too_many_arguments
-```
-
-#### Style
-
-| Rule | Problem | Fix |
-|------|---------|-----|
-| `manual_string_new` | Creating empty string inefficiently | Use `String::new()` |
-| `filter_next` | Using `.filter().next()` | Use `.find()` instead |
-| `map_flatten` | Using `.map().flatten()` | Use `.flat_map()` instead |
-| `comparison_to_empty` | Comparing to empty string/vec | Use `.is_empty()` |
-
-```rust
-// ✅ Good: idiomatic
-let empty = String::new();
-let found = items.find(|x| x.is_valid());
-let flattened: Vec<_> = items.flat_map(|x| x.children()).collect();
-if name.is_empty() { }
-
-// ❌ Bad: non-idiomatic
-let empty = String::from("");  // CLIPPY: manual_string_new
-let found = items.filter(|x| x.is_valid()).next();  // CLIPPY: filter_next
-let flattened: Vec<_> = items.map(|x| x.children()).flatten().collect();  // CLIPPY: map_flatten
-if name == "" { }  // CLIPPY: comparison_to_empty
-```
-
-### Running Clippy
-
-```bash
-# Run clippy with warnings only (non-blocking)
-cargo clippy
-
-# Run clippy and deny all warnings (what CI does)
-cargo clippy -- -D warnings
-
-# Run clippy on tests
-cargo clippy --tests -- -D warnings
-
-# Run clippy with all features
-cargo clippy --all-features -- -D warnings
-
-# Auto-fix some issues (when possible)
-cargo clippy --fix
-
-# Check specific lint
-cargo clippy -- -W clippy::needless_clone
-```
-
-### Project-Specific Allowances
-
-The StarForge project allows these clippy rules in specific circumstances. See `src/main.rs` for the global allowlist:
-
-```rust
-#![allow(
-    dead_code,                           // Some plugin infrastructure code is unused until plugins load it
-    clippy::needless_range_loop,         // Sometimes more readable than alternatives
-    clippy::redundant_closure,           // Used intentionally for clarity in some cases
-    clippy::too_many_arguments,          // Complex CLI commands require many arguments
-    clippy::type_complexity,             // Some type definitions are inherently complex
-    clippy::unnecessary_lazy_evaluations // Some expressions are evaluated for side effects
-)]
-```
-
-**When to add to this allowlist:**
-- Only for **unavoidable** patterns
-- Document *why* with a comment
-- Discuss with maintainers before merging
-
-```rust
-#![allow(clippy::too_many_arguments)]  // Contract CLI requires many parameters for optimization context
-```
-
-**When NOT to add:**
-- "I don't want to refactor" — do the refactor
-- "This is faster" — measure it; clippy suggestions are usually equivalent
-- "It's more readable" — it probably isn't; clippy catches real issues
-
-### Interpreting Clippy Warnings
-
-When clippy complains, read the **full message**—it includes:
-
-1. **The rule name** (in brackets): `[clippy::rule_name]`
-2. **Why it matters**: "This is inefficient" or "This is not idiomatic"
-3. **The suggestion**: What to change
-
-```
-warning: using `clone` on type `String` which implements `Copy`
-   --> src/main.rs:42:15
-    |
-42  |     let x = s.clone();
-    |             ^^^^^^^^^^ help: try dereferencing: `*s`
-    |
-    = note: `#[warn(clippy::clone_on_copy)]` on by default
-```
-
-**What to do:**
-1. Read the help text
-2. Understand WHY it's suggested
-3. Apply the fix or add `#[allow(clippy::rule_name)]` with a comment
-4. Run `cargo clippy` again to verify
-
----
-
-## Pre-Commit Developer Checklist
-
-**Before pushing code, run this checklist locally.** It mirrors what CI will run.
-
-### Quick Pre-Commit Checklist
-
-```bash
-#!/bin/bash
-# Pre-commit checks before git push
-
-echo "Checking code format..."
-cargo fmt --all --check || {
-    echo "❌ Format check failed. Run: cargo fmt --all"
-    exit 1
-}
-
-echo "Running clippy..."
-cargo clippy --all-targets -- -D warnings || {
-    echo "❌ Clippy failed. Fix warnings or run: cargo clippy --fix"
-    exit 1
-}
-
-echo "Running tests..."
-cargo test --locked || {
-    echo "❌ Tests failed"
-    exit 1
-}
-
-echo "Running smoke tests..."
-./scripts/e2e-smoke.sh || {
-    echo "⚠️  Smoke tests failed (optional, but recommended)"
-    exit 0
-}
-
-echo "✅ All checks passed! Ready to push."
-```
-
-### Step-by-Step Pre-Commit Process
-
-#### 1. Format Your Code
-
-```bash
-# Format everything
-cargo fmt --all
-
-# Verify formatting
-cargo fmt --all --check
-```
-
-After this step, all formatting violations should be fixed. rustfmt is non-negotiable.
-
-#### 2. Run Clippy
-
-```bash
-# Run clippy and fix what you can automatically
-cargo clippy --fix
-
-# Run clippy and report remaining issues
-cargo clippy --all-targets -- -D warnings
-```
-
-If clippy reports warnings after `--fix`, you need to manually address them:
-- Read the warning message carefully
-- Refactor if possible
-- Add `#[allow(...)]` with a comment if absolutely necessary
-- Re-run clippy to confirm
-
-#### 3. Run All Tests
-
-```bash
-# Run unit and integration tests
-cargo test --locked
-
-# Run with verbose output to see failures
-cargo test --locked -- --nocapture
-
-# Run tests sequentially if debugging
-cargo test --locked -- --test-threads=1
-```
-
-**All tests must pass locally before pushing.** If tests fail in CI, the PR is blocked.
-
-#### 4. Check Dependencies
-
-```bash
-# Run cargo-deny (dependency security/license check)
-cargo deny check
-
-# If missing, install it first:
-cargo install cargo-deny
-cargo deny init  # Creates deny.toml
-```
-
-#### 5. Manual Code Review
-
-Before committing:
-
-- [ ] Code follows naming conventions (functions: `snake_case`, types: `PascalCase`)
-- [ ] Error messages are clear and actionable
-- [ ] No `unwrap()` or `panic!()` in library code (only in `main.rs` for exceptional cases)
-- [ ] Public functions have doc comments
-- [ ] No debug `println!()` statements left in
-- [ ] No commented-out code blocks
-- [ ] No `TODO`/`FIXME` without context (should reference an issue)
-- [ ] Tests cover normal cases, error cases, and edge cases
-
-#### 6. Commit with Clear Message
-
-```bash
-# Use semantic commit messages
-git commit -m "feat: add wallet encryption support"
-
-# Format: <type>(<scope>): <message>
-# Types: feat, fix, docs, style, refactor, test, chore
-# Scope: Optional, but recommended (e.g., wallet, network, contract)
-# Message: Lowercase, imperative, no period
-```
-
-Good examples:
-```
-feat(wallet): add hardware wallet support
-fix(deploy): handle large contract files correctly
-docs(plugin): update plugin development guide
-refactor(config): simplify configuration loading
-test(network): add integration tests for Horizon API
-chore(deps): update clap to 4.5.0
-```
-
-#### 7. Push and Verify CI
-
-```bash
-git push origin feat/your-feature
-
-# Watch CI at:
-# https://github.com/Nanle-code/StarForge/actions
-```
-
-CI will re-run:
-- **rustfmt** check (all code must be formatted)
-- **clippy** check (all warnings are errors)
-- **cargo test** (all tests must pass)
-- **cargo deny** (dependency audit)
-- **smoke tests** (E2E command checks)
-
-If any step fails, you'll see a detailed error message. Fix locally and push again.
-
-### Automating Pre-Commit Checks
-
-You can set up a local git hook to run checks automatically:
-
-```bash
-# Create .git/hooks/pre-commit
-#!/bin/bash
-set -e
-
-echo "Running pre-commit checks..."
-
-cargo fmt --all --check || {
-    echo "Format check failed. Run: cargo fmt --all"
-    exit 1
-}
-
-cargo clippy -- -D warnings || exit 1
-cargo test --locked || exit 1
-
-echo "✅ Pre-commit checks passed"
-```
-
-Make it executable:
-```bash
-chmod +x .git/hooks/pre-commit
-```
-
-Now `git commit` will automatically run these checks. Add `--no-verify` to skip (not recommended).
-
----
-
-## CI Pipeline Expectations
-
-This section describes what happens in CI and what will block a PR merge.
-
-### GitHub Actions Workflow
-
-**File**: `.github/workflows/ci.yml`
-
-The CI pipeline runs on every push and pull request. It consists of these jobs:
-
-#### Job 1: Rustfmt Check
-
-```yaml
-name: Rustfmt
-runs-on: ubuntu-latest
-- cargo fmt --all --check
-```
-
-**What it checks**: All Rust code is formatted according to rustfmt rules.
-
-**Failure conditions**:
-- Any file has formatting differences
-- Imports are not grouped correctly
-- Lines exceed rustfmt's wrapping preferences
-
-**How to fix**: `cargo fmt --all` locally and push again.
-
-```bash
-cargo fmt --all
-git add .
-git commit -m "style: apply rustfmt"
-git push
-```
-
-#### Job 2: Cargo Deny
-
-```yaml
-name: Cargo Deny
-runs-on: ubuntu-latest
-- cargo deny check
-```
-
-**What it checks**: Dependencies for:
-- Known security vulnerabilities (advisory database)
-- Copyleft/restricted licenses (GPL, AGPL)
-- Duplicate dependencies
-- Unused dependencies
-
-**Failure conditions**:
-- Any dependency has a known CVE
-- Any dependency uses a banned license
-- Dependency tree is broken or incomplete
-
-**How to fix**:
-1. Check the deny.toml file for rules
-2. Update vulnerable dependencies: `cargo update <crate>`
-3. If a license is problematic, discuss with maintainers
-4. If a denial is incorrect, add an exception to `deny.toml`
-
-```bash
-# View deny configuration
-cat deny.toml
-
-# Update specific crate
-cargo update clap
-
-# Check again locally
-cargo deny check
-```
-
-#### Job 3: Build, Test, and Clippy
-
-```yaml
-name: Build, Test & Clippy
-runs-on: ubuntu-latest
-- cargo build --locked
-- cargo test --locked
-- cargo clippy --locked -- -D warnings
-```
-
-**What it checks**:
-1. **Build**: Project compiles without errors
-2. **Tests**: All unit and integration tests pass
-3. **Clippy**: No clippy warnings (all treated as errors with `-D warnings`)
-
-**Failure conditions**:
-- Compilation errors
-- Any test fails
-- Any clippy warning appears
-
-**How to fix**:
-```bash
-# Fix compilation
-cargo build --locked
-
-# Fix tests
-cargo test --locked -- --nocapture  # See output
-
-# Fix clippy
-cargo clippy --locked -- -D warnings
-cargo clippy --fix  # Auto-fix when possible
-```
-
-#### Job 4: Smoke Tests
-
-```yaml
-name: CLI Smoke Tests
-runs-on: ubuntu-latest
-- cargo test --test cli_smoke --locked
-- ./scripts/e2e-smoke.sh
-```
-
-**What it checks**:
-1. **CLI smoke tests** (`tests/cli_smoke.rs`): Quick checks that main CLI commands work
-2. **E2E smoke script** (`scripts/e2e-smoke.sh`): End-to-end verification of common workflows
-
-**Failure conditions**:
-- Any command returns unexpected exit code
-- Any command output is missing expected text
-- Script exits with code 1
-
-**How to fix**:
-```bash
-# Run locally to see what's failing
-cargo test --test cli_smoke --locked -- --nocapture
-./scripts/e2e-smoke.sh
-
-# Debug with environment variable
-STARFORGE_E2E=1 ./scripts/e2e-smoke.sh  # Includes network tests
-```
-
-### CI Status and PR Requirements
-
-**PR Status Requirements:**
-
-All four CI jobs must pass before a PR can be merged:
-1. ✅ Rustfmt
-2. ✅ Cargo Deny  
-3. ✅ Build, Test & Clippy
-4. ✅ Smoke Tests
-
-If any job fails, you'll see:
-- A red ❌ on the PR
-- A comment with the failure log
-- A link to the CI run
-
-**View CI logs:**
-```
-PR → "Checks" tab → Click job name → Scroll to see failure
-```
-
-**Re-running CI:**
-- Push a new commit to update the PR
-- Click "Re-run jobs" button if the failure was environmental (e.g., network timeout)
-
-### Handling CI Failures
-
-**Common CI failures and fixes:**
-
-| Failure | Cause | Fix |
-|---------|-------|-----|
-| `cargo fmt --all --check` | Code not formatted | `cargo fmt --all` |
-| `clippy` warnings | Non-idiomatic code | `cargo clippy --fix` or refactor manually |
-| `cargo test` fails | Test assertion failed | Debug with `cargo test -- --nocapture` |
-| `cargo deny` fails | Vulnerable/restricted dependency | Update dependency or add exception |
-| Smoke test fails | Command output unexpected | Run locally with `./scripts/e2e-smoke.sh` |
-| Timeout (>10 min) | Slow test or network issue | Can click "Re-run jobs" |
-
-### Locked Dependencies
-
-CI uses `--locked` flag for deterministic builds:
-
-```bash
-# Uses exact versions from Cargo.lock
-cargo build --locked
-cargo test --locked
-cargo clippy --locked
-```
-
-This ensures:
-- Same versions across environments
-- No surprise breaking changes from dependencies
-- Reproducible builds
-
-**When to update Cargo.lock:**
-```bash
-# Update specific dependency
-cargo update clap
-
-# Or update all
-cargo update
-
-# Commit the updated Cargo.lock
-git add Cargo.lock
-git commit -m "chore: update dependencies"
-```
-
----
-
-## IDE/Editor Integration
-
-### Visual Studio Code
-
-#### Setup
-
-1. **Install Rust Analyzer extension**:
-   - Open VS Code Extensions (Ctrl+Shift+X)
-   - Search for "Rust-analyzer"
-   - Click "Install"
-
-2. **Install rustfmt and clippy** (if not already installed):
-   ```bash
-   rustup component add rustfmt clippy
-   ```
-
-3. **Configure settings** (`.vscode/settings.json` in project root):
-
-```json
-{
-  "editor.defaultFormatter": "rust-lang.rust-analyzer",
-  "[rust]": {
-    "editor.defaultFormatter": "rust-lang.rust-analyzer",
-    "editor.formatOnSave": true,
-    "editor.codeActionsOnSave": {
-      "source.fixAll.clippy": "explicit"
-    }
-  },
-  "rust-analyzer.checkOnSave.command": "clippy",
-  "rust-analyzer.checkOnSave.extraArgs": ["--all-targets", "--", "-D", "warnings"],
-  "rust-analyzer.diagnostics.enableExperimental": true,
-  "rust-analyzer.inlayHints.maxLength": 80,
-  "rust-analyzer.assist.emitMustUse": true
-}
-```
-
-This configuration:
-- Formats on save using rustfmt
-- Runs clippy on save and shows violations
-- Enables experimental diagnostics
-- Shows type hints inline
-
-#### Usage in VS Code
-
-- **Format**: `Shift+Alt+F` (or manual `cargo fmt`)
-- **Hover for diagnostics**: Hover over red squiggly lines
-- **Quick fixes**: `Ctrl+.` when cursor is on warning
-- **Go to definition**: `F12` or `Ctrl+Click`
-- **Find usages**: `Shift+Alt+F12`
-
-#### Recommended Extensions
-
-```json
-{
-  "recommendations": [
-    "rust-lang.rust-analyzer",
-    "serayuzgur.crates",
-    "bungcip.better-toml",
-    "usernamehw.errorlens",
-    "vadimcn.vscode-lldb"
-  ]
-}
-```
-
-Save as `.vscode/extensions.json`, then use "Extensions: Show Recommended" command.
-
-### IntelliJ IDEA / CLion
-
-#### Setup
-
-1. **Install Rust plugin**:
-   - Settings → Plugins → Search "Rust"
-   - Install "Rust" by JetBrains
-
-2. **Enable formatters and linters**:
-   - Settings → Languages & Frameworks → Rust → Rustfmt
-   - Check "Run rustfmt on Save"
-
-3. **Enable Clippy**:
-   - Settings → Languages & Frameworks → Rust → Clippy
-   - Check "Run external linter"
-   - Check "Show warnings"
-
-4. **Configure code style**:
-   - Settings → Editor → Code Style → Rust
-   - Ensure 4-space indentation is set
-   - Match inspection settings to clippy
-
-#### Usage in IntelliJ
-
-- **Format**: `Ctrl+Alt+L` (or `Cmd+Alt+L` on macOS)
-- **Run inspections**: `Ctrl+Alt+I`
-- **Fix with intention**: `Alt+Enter` on error
-- **Run Clippy**: Tools → Run External Tools → Clippy
-
-### Vim / Neovim
-
-#### Setup with rust-analyzer
-
-Install rust-analyzer (if not already via rustup):
-
-```bash
-rustup component add rust-analyzer
-```
-
-For **vim-lsp** users:
-
-```vim
-" .vimrc or init.vim
-if executable('rust-analyzer')
-  augroup lsp
-    autocmd!
-    autocmd User lsp_setup call lsp#register_server({
-        \ 'name': 'rust-analyzer',
-        \ 'cmd': {server_info->['rust-analyzer']},
-        \ 'workspace_config': {'rust': {'checkOnSave': {'command': 'clippy'}}},
-        \ 'allowlist': ['rust'],
-        \ })
-  augroup end
-endif
-```
-
-For **Neovim with nvim-lspconfig**:
-
-```lua
--- init.lua
-local nvim_lsp = require('lspconfig')
-nvim_lsp.rust_analyzer.setup {
-  settings = {
-    ['rust-analyzer'] = {
-      checkOnSave = {
-        command = 'clippy',
-        extraArgs = { '--all-targets', '--', '-D', 'warnings' }
-      }
-    }
-  }
-}
-
--- Auto format on save
-vim.api.nvim_create_autocmd('BufWritePre', {
-  pattern = '*.rs',
-  callback = function()
-    vim.lsp.buf.format { async = false }
-  end
-})
-```
-
-#### Using External Tools
-
-Configure Vim/Neovim to run `cargo fmt` and `cargo clippy` as external tools:
-
-```vim
-" Format with :Fmt
-command! Fmt execute '!cargo fmt --all' | edit
-
-" Lint with :Lint
-command! Lint execute '!cargo clippy -- -D warnings'
-
-" Run tests with :Test
-command! Test execute '!cargo test'
-```
-
-### Emacs
-
-For Emacs users with **rustic-mode**:
-
-```elisp
-(use-package rustic
-  :ensure t
-  :init
-  (setq rustic-linter 'clippy
-        rustic-format-on-save t
-        rustic-lsp-client 'lsp-mode))
-
-;; Optional: keybindings
-(define-key rustic-mode-map (kbd "M-f") #'rustic-format-buffer)
-(define-key rustic-mode-map (kbd "C-c C-c l") #'rustic-compile)
-```
-
----
-
-## Automated Enforcement
-
-### Pre-Commit Hooks Setup
-
-To prevent committing code that fails checks, set up git hooks:
-
-```bash
-# Create pre-commit hook
-mkdir -p .git/hooks
-
-cat > .git/hooks/pre-commit << 'EOF'
-#!/bin/bash
-set -e
-
-echo "Checking format..."
-cargo fmt --all --check || {
-    echo "Format check failed. Run: cargo fmt --all"
-    exit 1
-}
-
-echo "Running clippy..."
-cargo clippy -- -D warnings || {
-    echo "Clippy violations found."
-    exit 1
-}
-
-echo "Running unit tests..."
-cargo test --lib || exit 1
-
-echo "Pre-commit checks passed!"
-EOF
-
-chmod +x .git/hooks/pre-commit
-```
-
-Now `git commit` will automatically run checks. To skip (not recommended):
-```bash
-git commit --no-verify
-```
-
-### GitHub Actions Re-run
-
-If CI fails on a flaky test or timeout:
-
-1. Go to the PR on GitHub
-2. Click "Checks" or "Details" on a failed job
-3. Click "Re-run jobs" button
-
-This re-runs all CI jobs without requiring a new commit.
-
-### Local CI Simulation
-
-Before pushing, run all CI checks locally:
-
-```bash
-#!/bin/bash
-# Run all CI checks locally
-
-echo "Simulating CI pipeline..."
-
-echo "1/4: Checking format..."
-cargo fmt --all --check || exit 1
-
-echo "2/4: Running cargo deny..."
-cargo deny check || exit 1
-
-echo "3/4: Building, testing, and clippy..."
-cargo build --locked || exit 1
-cargo test --locked || exit 1
-cargo clippy --locked -- -D warnings || exit 1
-
-echo "4/4: Running smoke tests..."
-cargo test --test cli_smoke --locked || exit 1
-./scripts/e2e-smoke.sh || exit 1
-
-echo "All CI checks passed locally!"
-```
-
-Save as `scripts/ci-check.sh` and run before pushing:
-```bash
-chmod +x scripts/ci-check.sh
-./scripts/ci-check.sh
-```
-
----
-
-## Quick Reference
-
-### One-Liner Command Cheat Sheet
-
-```bash
-# Format all code
-cargo fmt --all
-
-# Check if formatted (no changes)
-cargo fmt --all --check
-
-# Run linter with auto-fix
-cargo clippy --fix
-
-# Run linter (deny warnings)
-cargo clippy -- -D warnings
-
-# Run all tests
-cargo test --locked
-
-# Run specific test
-cargo test wallet_create -- --nocapture
-
-# Build everything
-cargo build --locked
-
-# Security/license check
-cargo deny check
-
-# Run pre-commit checklist
-cargo fmt --all --check && cargo clippy -- -D warnings && cargo test --locked
-
-# Full CI simulation
-./scripts/ci-check.sh
-```
-
-### Common Issues and Solutions
-
-| Issue | Solution |
-|-------|----------|
-| Code not formatted in CI | `cargo fmt --all` and commit |
-| Clippy warnings block PR | `cargo clippy --fix` or manually refactor |
-| Tests fail locally but pass in CI | Run with `--locked`: `cargo test --locked` |
-| Slow compilation | Use sccache: `export RUSTC_WRAPPER=sccache` |
-| "denied by Cargo.lock" | Run `cargo update` and commit `Cargo.lock` |
-| IDE not showing errors | Reload Rust-analyzer: `Ctrl+Shift+P` → "Reload Window" |
-
-### Standards at a Glance
-
-| Aspect | Standard | Enforced By |
-|--------|----------|-------------|
-| Formatting | 4-space indent, rustfmt rules | rustfmt + CI |
-| Naming | `snake_case` functions, `PascalCase` types | Clippy + code review |
-| Line length | ~100 chars (soft) | Manual review |
-| Error handling | `Result<T>` and `?` operator | Clippy + code review |
-| Doc comments | `///` on public items | Manual review |
-| Imports | Grouped (std, external, internal) | rustfmt + manual review |
-| Tests | Unit + integration, all must pass | CI test job |
-| Dependencies | No vulnerable/copyleft crates | Cargo Deny |
-
----
-
-## Summary
-
-**StarForge Code Standards at a Glance:**
-
-1. **Run `cargo fmt --all`** after every change (non-negotiable)
-2. **Run `cargo clippy -- -D warnings`** and fix warnings before pushing
-3. **Run `cargo test --locked`** to ensure tests pass
-4. **Check your IDE is configured** to format and lint on save
-5. **Read CI failure messages carefully**—they tell you exactly what to fix
-6. **Use the pre-commit checklist** before pushing to avoid CI failures
-
-**Philosophy**: We automate everything so you can focus on logic, not style. When in doubt, run the tools—they're the source of truth.
-
-For questions or suggestions about these standards, open a GitHub issue or discussion.
-
----
-
-**Last Updated**: 2025-06-01
-
-**Maintainer**: StarForge Core Team
-
-**Related Documents**: [CONTRIBUTING.md](CONTRIBUTING.md), [DEVELOPER_GUIDE.md](DEVELOPER_GUIDE.md), [ARCHITECTURE.md](ARCHITECTURE.md)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
deleted file mode 100644
index 0c84cac8..00000000
--- a/CONTRIBUTING.md
+++ /dev/null
@@ -1,533 +0,0 @@
-# Contributing to StarForge
-
-Welcome to StarForge! This guide will help you get started contributing to the project. We appreciate your interest in making StarForge better.
-
-## Table of Contents
-
-- [Quick Start](#quick-start)
-- [Prerequisites](#prerequisites)
-- [Development Setup](#development-setup)
-- [Building the Project](#building-the-project)
-- [Running Tests](#running-tests)
-- [Development Workflow](#development-workflow)
-- [Code Quality](#code-quality)
-- [Submitting a Pull Request](#submitting-a-pull-request)
-- [Common Issues & Troubleshooting](#common-issues--troubleshooting)
-- [Questions & Support](#questions--support)
-
----
-
-## Quick Start
-
-1. **Fork and clone** the repository
-2. **Install Rust** (if not already installed)
-3. **Build the project**: `cargo build`
-4. **Run tests**: `cargo test`
-5. **Create a branch**: `git checkout -b feat/your-feature-name`
-6. **Make changes** and commit with clear messages
-7. **Push and open a Pull Request** against `master`
-
----
-
-## Prerequisites
-
-### Rust
-
-StarForge requires **Rust 1.80 or later**. 
-
-#### Install Rust
-
-If you don't have Rust installed, use [rustup](https://rustup.rs) — the official Rust toolchain installer:
-
-```bash
-curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-source $HOME/.cargo/env
-```
-
-After installation, verify your version:
-
-```bash
-rustc --version
-cargo --version
-```
-
-#### Update Rust (if already installed)
-
-```bash
-rustup update stable
-```
-
-### Additional Tools
-
-- **Git** for version control
-- **A text editor or IDE** (VS Code, IntelliJ, Vim, etc.)
-
----
-
-## Development Setup
-
-### Clone the Repository
-
-```bash
-git clone https://github.com/Nanle-code/StarForge.git
-cd StarForge
-```
-
-### Verify Your Setup
-
-Run the info command to check your environment:
-
-```bash
-cargo build
-cargo run -- info
-```
-
-You should see output with your Rust version and system information.
-
----
-
-## Building the Project
-
-### Build for Development (Debug)
-
-```bash
-cargo build
-```
-
-This produces an unoptimized binary in `target/debug/starforge`. Builds are fast, useful during development.
-
-### Build for Release (Optimized)
-
-```bash
-cargo build --release
-```
-
-This produces an optimized binary in `target/release/starforge`. Builds are slower but the binary is much faster.
-
-### Install Locally
-
-After building, you can install the binary to your PATH:
-
-```bash
-# From debug build
-cp target/debug/starforge ~/.local/bin/
-
-# Or from release build
-cp target/release/starforge ~/.local/bin/
-
-# Then verify installation
-starforge --version
-```
-
----
-
-## Running Tests
-
-### Run All Tests
-
-```bash
-cargo test
-```
-
-This runs all unit tests, integration tests, and doc tests.
-
-### Run Tests with Output
-
-If you want to see `println!` output from passing tests:
-
-```bash
-cargo test -- --nocapture
-```
-
-### Run Specific Tests
-
-```bash
-# Run a single test
-cargo test test_wallet_create
-
-# Run tests matching a pattern
-cargo test wallet
-
-# Run integration tests from a specific file
-cargo test --test wallet_lifecycle_e2e
-```
-
-### Run Tests in Parallel
-
-Tests run in parallel by default. To run sequentially (useful for debugging):
-
-```bash
-cargo test -- --test-threads=1 --nocapture
-```
-
-### Run Smoke Tests
-
-The project includes quick smoke tests to verify basic functionality:
-
-```bash
-cargo test --test cli_smoke
-```
-
-### Check Code Quality
-
-The CI pipeline runs several quality checks. Run them locally:
-
-```bash
-# Format check
-cargo fmt --all --check
-
-# Linter check
-cargo clippy -- -D warnings
-
-# Dependency security check (requires cargo-deny)
-cargo install cargo-deny
-cargo deny check
-```
-
----
-
-## Development Workflow
-
-### 1. Create a Feature Branch
-
-Use a descriptive branch name:
-
-```bash
-git checkout -b feat/issue-XXX-description
-```
-
-Naming conventions:
-- `feat/` for new features
-- `fix/` for bug fixes
-- `docs/` for documentation improvements
-- `refactor/` for code refactoring
-- `test/` for test additions or improvements
-
-### 2. Make Changes
-
-Edit files in your preferred editor. The project structure:
-
-```
-src/
-├── main.rs                # CLI entry point
-├── commands/              # Command implementations
-│   ├── wallet.rs
-│   ├── new.rs
-│   ├── deploy.rs
-│   ├── contract.rs
-│   └── ...
-└── utils/                 # Helper utilities
-    ├── config.rs
-    ├── horizon.rs
-    ├── soroban.rs
-    └── print.rs
-```
-
-### 3. Write/Update Tests
-
-When adding features, include tests:
-
-```bash
-# Add unit tests in the same file
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_my_feature() {
-        // Your test here
-    }
-}
-```
-
-For integration tests, create a new file in `tests/`:
-
-```bash
-# tests/my_feature.rs
-#[test]
-fn test_my_feature() {
-    // Your test here
-}
-```
-
-### 4. Run Tests Locally
-
-```bash
-cargo test
-```
-
-### 5. Check Code Quality
-
-```bash
-cargo fmt --all
-cargo clippy -- -D warnings
-```
-
-### 6. Commit Changes
-
-Use clear, descriptive commit messages:
-
-```bash
-git add .
-git commit -m "feat: add wallet encryption support"
-```
-
-Commit message format:
-- Start with type: `feat`, `fix`, `docs`, `refactor`, `test`, `chore`
-- Use lowercase
-- Be specific and concise
-- Example: `fix: resolve panic in contract deployment with large files`
-
-### 7. Push and Create a Pull Request
-
-```bash
-git push origin feat/issue-XXX-description
-```
-
-Then open a Pull Request on GitHub. Use the provided template and follow the checklist.
-
----
-
-## Code Quality and Security Logging
-
-StarForge enforces consistent code quality through automated CI checks. See [CI_ENFORCEMENT.md](CI_ENFORCEMENT.md) for full details.
-
-### Security Logging Requirements
-
-All security-relevant operations must be properly logged for auditability and debugging. See [SECURITY_LOGGING_GUIDE.md](SECURITY_LOGGING_GUIDE.md) for detailed requirements. Key principles:
-
-- **Log all security operations** - Wallet creation, encryption, deployment, plugin loading, etc.
-- **Never log secrets** - Private keys, passphrases, encryption keys must be redacted
-- **Include context** - Operation type, outcome, timestamp, and relevant details
-- **Use structured logging** - JSON format for machine parsing and aggregation
-- **Verify in tests** - Security logging behavior should be tested
-
-Before submitting a PR with security-relevant changes:
-1. Check [SECURITY_LOGGING_GUIDE.md](SECURITY_LOGGING_GUIDE.md) for what should be logged
-2. Review [SECURITY_LOGGING_BEST_PRACTICES.md](SECURITY_LOGGING_BEST_PRACTICES.md) for implementation patterns
-3. Ensure logs don't contain secrets or sensitive data
-4. Test that logs provide useful audit trail information
-
-### Formatting
-
-Use Rust's built-in formatter:
-
-```bash
-cargo fmt --all
-```
-
-This is automatically checked in CI. All code must pass `cargo fmt --all --check`.
-
-**Pre-commit tip**: Format before every commit:
-```bash
-cargo fmt --all && git add .
-```
-
-### Linting
-
-Use Clippy to catch common mistakes:
-
-```bash
-cargo clippy --locked -- -D warnings
-```
-
-Fix any warnings before submitting a PR. All code must pass this check in CI.
-
-**Pre-commit tip**: Run locally before pushing:
-```bash
-cargo clippy --locked -- -D warnings
-```
-
-### Code Style Standards
-
-For detailed code style expectations, see [CODE_STYLE_STANDARDS.md](CODE_STYLE_STANDARDS.md). This covers:
-
-- Naming conventions (functions, variables, constants, types)
-- Documentation requirements
-- Error handling patterns
-- Testing expectations
-- Common Clippy violations and how to fix them
-
-### Documentation
-
-- Add doc comments to all public functions and types:
-
-```rust
-/// Brief description of what this function does.
-///
-/// More detailed explanation if needed.
-///
-/// # Arguments
-/// * `arg1` - description
-///
-/// # Returns
-/// Description of return value
-///
-/// # Example
-/// ```
-/// let result = my_function(42);
-/// assert_eq!(result, 43);
-/// ```
-pub fn my_function(arg1: i32) -> i32 {
-    arg1 + 1
-}
-```
-
-- Keep README and other docs up-to-date with your changes
-- Update CHANGELOG if your change is user-facing
-
-### Pre-Commit Validation
-
-Run this before every commit to catch issues early:
-
-```bash
-cargo fmt --all && \
-  cargo build --locked && \
-  cargo test --locked && \
-  cargo clippy --locked -- -D warnings
-```
-
-All of these are checked in CI.
-
----
-
-## Submitting a Pull Request
-
-### Before Submitting
-
-- [ ] Fork and clone the repository
-- [ ] Create a feature branch
-- [ ] Make your changes
-- [ ] Add/update tests
-- [ ] Run `cargo test` and verify all tests pass
-- [ ] Run `cargo fmt --all`
-- [ ] Run `cargo clippy -- -D warnings`
-- [ ] Update relevant documentation
-- [ ] Commit with clear messages
-- [ ] Push to your fork
-
-### Pull Request Checklist
-
-When opening a PR, fill out the template with:
-
-- **Description**: Clear explanation of what changed and why
-- **Type**: feat, fix, docs, refactor, test
-- **Related Issues**: Link to issue(s) being resolved (e.g., `closes #208`)
-- **Tests**: Describe any tests added/modified
-- **Checklist**:
-  - [ ] Code follows style guidelines
-  - [ ] Self-reviewed own code
-  - [ ] Added tests for new functionality
-  - [ ] All tests pass locally (`cargo test`)
-  - [ ] Updated documentation if needed
-  - [ ] No breaking changes (or clearly documented)
-
-### PR Guidelines
-
-- **Keep PRs focused**: One issue per PR when possible
-- **Keep PRs scoped**: Smaller, focused PRs are easier to review and merge faster
-- **Write clear descriptions**: Explain the "why" not just the "what"
-- **Reference issues**: Use `closes #XXX` to automatically link issues
-- **Test thoroughly**: Include test cases for both happy path and edge cases
-- **Update docs**: If your changes affect user-facing behavior, update docs
-
----
-
-## Common Issues & Troubleshooting
-
-For detailed troubleshooting, see [BUILD_TROUBLESHOOTING.md](BUILD_TROUBLESHOOTING.md).
-
-### "rustc version mismatch"
-
-Ensure you're on the correct Rust version:
-
-```bash
-rustup update stable
-rustc --version  # Should be 1.80 or later
-```
-
-### "cargo: command not found"
-
-Rust and Cargo weren't installed correctly. Reinstall using rustup:
-
-```bash
-curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-source $HOME/.cargo/env
-```
-
-### Build fails with "dependency not found"
-
-Clear the build cache and rebuild:
-
-```bash
-cargo clean
-cargo build
-```
-
-### Tests fail with "permission denied"
-
-On macOS/Linux, make scripts executable:
-
-```bash
-chmod +x scripts/e2e-smoke.sh
-```
-
-### "Cannot connect to Horizon API"
-
-Some tests require network access. If tests fail due to network issues:
-
-```bash
-# Run only local tests (no network)
-cargo test --lib
-
-# Run tests with retries
-cargo test -- --test-threads=1
-```
-
-### Wallet tests fail with "STARFORGE_TEST_SECRET_KEY not set"
-
-Some tests require a test secret key. Set it:
-
-```bash
-export STARFORGE_TEST_SECRET_KEY="SXXX..."  # Your test key
-cargo test
-```
-
-### Clippy warnings won't go away
-
-Update Clippy:
-
-```bash
-rustup update stable
-cargo clean
-cargo clippy -- -D warnings
-```
-
-### Build Baseline Status
-
-For a complete verification of the project's build status, see [BUILD_BASELINE_VERIFICATION.md](BUILD_BASELINE_VERIFICATION.md).
-
-This document confirms:
-- ✅ All 22 command handlers are properly implemented
-- ✅ All 24 utility modules are properly declared
-- ✅ Zero unresolved imports across 74 source files
-- ✅ All test files are ready to execute
-- ✅ The baseline is clean and ready for development
-
----
-
-## Questions & Support
-
-- **Documentation**: See [DEVELOPER_GUIDE.md](DEVELOPER_GUIDE.md) for in-depth development topics
-- **Issues**: Open a [GitHub issue](https://github.com/Nanle-code/StarForge/issues) with questions or bugs
-- **Discussions**: Use [GitHub Discussions](https://github.com/Nanle-code/StarForge/discussions) for general questions
-- **Stellar Docs**: See [Stellar Developer Docs](https://developers.stellar.org)
-- **Soroban Docs**: See [Soroban Documentation](https://soroban.stellar.org)
-
----
-
-## Recognition
-
-Contributors are recognized in the project and may participate in the [Stellar Wave Program](https://www.drips.network/wave/stellar) for monetary rewards.
-
-Thank you for contributing to StarForge! 🚀
diff --git a/CONTRIBUTOR_QUICK_REFERENCE.md b/CONTRIBUTOR_QUICK_REFERENCE.md
deleted file mode 100644
index afb49abb..00000000
--- a/CONTRIBUTOR_QUICK_REFERENCE.md
+++ /dev/null
@@ -1,290 +0,0 @@
-# Contributor Quick Reference
-
-Fast lookup guide for common development tasks in StarForge.
-
-## One-Minute Setup
-
-```bash
-# 1. Install Rust (if needed)
-curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-
-# 2. Clone the repo
-git clone https://github.com/Nanle-code/StarForge.git
-cd StarForge
-
-# 3. Build and test
-cargo build
-cargo test
-
-# Done! You're ready to contribute.
-```
-
-## Common Commands
-
-| Task | Command |
-|------|---------|
-| Build (debug) | `cargo build` |
-| Build (release) | `cargo build --release` |
-| Run tests | `cargo test` |
-| Run with output | `cargo test -- --nocapture` |
-| Format code | `cargo fmt --all` |
-| Lint code | `cargo clippy -- -D warnings` |
-| Check security | `cargo deny check` |
-| Create branch | `git checkout -b feat/issue-XXX-description` |
-| Run smoke tests | `cargo test --test cli_smoke` |
-
-## Before Submitting a PR
-
-The CI pipeline checks these things. Verify locally first:
-
-```bash
-# 1. Format your code (required)
-cargo fmt --all
-
-# 2. Run all tests (required)
-cargo test --locked
-
-# 3. Check for linting issues (required)
-cargo clippy --locked -- -D warnings
-
-# 4. Check dependency security (required in CI)
-cargo deny check
-
-# 5. Verify smoke tests pass
-cargo test --test cli_smoke --locked
-
-# 6. Verify the app runs
-cargo run -- --version
-
-# 7. Commit and push
-git add .
-git commit -m "feat: your change"
-git push origin feat/issue-XXX-description
-```
-
-All together (simulates CI):
-```bash
-cargo fmt --all --check && \
-  cargo deny check && \
-  cargo build --locked && \
-  cargo test --locked && \
-  cargo clippy --locked -- -D warnings && \
-  cargo test --test cli_smoke --locked && \
-  echo "✅ All CI checks passed!"
-```
-
-## Project Structure
-
-```
-src/
-├── main.rs              # CLI entry point
-├── commands/            # Command modules
-│   ├── wallet.rs        # Wallet operations
-│   ├── new.rs           # Scaffolding
-│   ├── deploy.rs        # Contract deployment
-│   ├── contract.rs      # Contract inspection
-│   └── ...
-└── utils/               # Utilities
-    ├── config.rs        # Config file handling
-    ├── horizon.rs       # Horizon API client
-    ├── soroban.rs       # Soroban RPC client
-    └── print.rs         # CLI output formatting
-
-tests/                  # Integration tests
-├── cli_smoke.rs
-├── wallet_*.rs
-├── deploy_*.rs
-└── ...
-
-.github/
-├── workflows/
-│   ├── ci.yml          # Main CI pipeline
-│   └── release.yml
-└── pull_request_template.md
-```
-
-## Testing Patterns
-
-### Unit Tests (in src/)
-
-```rust
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_my_function() {
-        let result = my_function(42);
-        assert_eq!(result, 43);
-    }
-}
-```
-
-### Integration Tests (in tests/)
-
-```rust
-// tests/my_test.rs
-#[test]
-fn test_integration() {
-    // Test that requires multiple modules
-}
-```
-
-### Running Tests
-
-```bash
-# All tests
-cargo test
-
-# Specific test
-cargo test test_name
-
-# With output
-cargo test -- --nocapture --test-threads=1
-
-# Integration test file
-cargo test --test cli_smoke
-```
-
-## Git Workflow
-
-```bash
-# 1. Create a branch
-git checkout -b feat/issue-208-contributor-guide
-
-# 2. Make changes
-vim src/commands/wallet.rs
-
-# 3. Commit
-git add src/commands/wallet.rs
-git commit -m "feat: add wallet encryption support"
-
-# 4. Push to your fork
-git push origin feat/issue-208-contributor-guide
-
-# 5. Open PR on GitHub
-```
-
-## Branch Naming Convention
-
-| Type | Pattern | Example |
-|------|---------|---------|
-| Feature | `feat/issue-XXX-description` | `feat/issue-208-contributor-guide` |
-| Bug fix | `fix/issue-XXX-description` | `fix/issue-205-wallet-panic` |
-| Documentation | `docs/description` | `docs/api-reference-update` |
-| Refactor | `refactor/description` | `refactor/config-module` |
-| Tests | `test/description` | `test/wallet-integration` |
-
-## Code Style
-
-### Formatting
-
-```bash
-# Auto-format all code
-cargo fmt --all
-
-# Check format (no changes)
-cargo fmt --all --check
-```
-
-### Documentation Comments
-
-```rust
-/// Brief description (one line).
-///
-/// More detailed explanation (optional).
-///
-/// # Arguments
-/// * `param1` - description
-///
-/// # Returns
-/// Description of return value
-///
-/// # Example
-/// ```
-/// let result = function(42);
-/// ```
-pub fn function(param1: i32) -> i32 {
-    param1 + 1
-}
-```
-
-## Common Issues
-
-| Problem | Solution |
-|---------|----------|
-| `rustc version mismatch` | `rustup update stable` |
-| Build fails | `cargo clean && cargo build` |
-| Tests fail (network) | Some tests need internet; retry or skip |
-| Permission denied on scripts | `chmod +x scripts/*.sh` |
-| Clippy warnings | `cargo clippy --all -- -D warnings` |
-
-## Configuration Files
-
-| File | Purpose |
-|------|---------|
-| `Cargo.toml` | Project manifest and dependencies |
-| `Cargo.lock` | Dependency lock file (commit this) |
-| `.rustfmt.toml` | Code formatting rules |
-| `.github/workflows/ci.yml` | Continuous integration pipeline |
-| `rust-toolchain.toml` | Required Rust version |
-
-## Resources
-
-- **CONTRIBUTING.md** — Full contribution guide
-- **CI_ENFORCEMENT.md** — CI pipeline and code quality enforcement
-- **CODE_STYLE_STANDARDS.md** — Detailed code style and linting rules
-- **BUILD_BASELINE_VERIFICATION.md** — Project build status verification
-- **BUILD_TROUBLESHOOTING.md** — Solutions for build issues
-- **DEVELOPER_GUIDE.md** — In-depth development documentation
-- **README.md** — Project overview
-- **API_REFERENCE.md** — Complete command reference
-- **ARCHITECTURE.md** — System design and architecture
-
-## Getting Help
-
-- Check existing [issues](https://github.com/Nanle-code/StarForge/issues)
-- Search [discussions](https://github.com/Nanle-code/StarForge/discussions)
-- Read DEVELOPER_GUIDE.md for deep dives
-- Ask in a new issue or discussion
-
-## CI Pipeline
-
-The GitHub Actions pipeline runs on every push and PR:
-
-1. **Rustfmt** — Code formatting check
-2. **Cargo Deny** — Dependency security audit
-3. **Build, Test & Clippy** — Compilation, tests, and linting
-4. **CLI Smoke Tests** — End-to-end functionality tests
-
-All must pass for a PR to be mergeable.
-
-## Debugging Tips
-
-### Print debugging
-```bash
-cargo test -- --nocapture  # See println! output
-```
-
-### Run single-threaded
-```bash
-cargo test -- --test-threads=1  # Easier to read output
-```
-
-### Check what changed
-```bash
-git diff              # Unstaged changes
-git diff --cached     # Staged changes
-git log --oneline -5  # Recent commits
-```
-
-### Inspect build
-```bash
-cargo build -v  # Verbose build output
-cargo tree      # Dependency tree
-cargo check     # Fast syntax check (no linking)
-```
-
----
-
-**Ready to contribute?** Start with [CONTRIBUTING.md](CONTRIBUTING.md) for the full guide.
diff --git a/Cargo.lock b/Cargo.lock
index 544183bd..12c70387 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -131,9 +131,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.102"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+checksum = "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3"
 
 [[package]]
 name = "argon2"
@@ -223,7 +223,16 @@ version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
 dependencies = [
- "bit-vec",
+ "bit-vec 0.6.3",
+]
+
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec 0.8.0",
 ]
 
 [[package]]
@@ -232,11 +241,17 @@ version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
 
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
 [[package]]
 name = "bitcoin_hashes"
-version = "0.14.100"
+version = "0.14.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c9901a56e133a1fc86eeb1113e2591f45f4682451ca893bff494d2f88918e3f"
+checksum = "bca4c7abb40c8817d77403c880988cfd484f23ab2365726afb2f798363e2c4a2"
 dependencies = [
  "hex-conservative",
 ]
@@ -980,7 +995,7 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "531e46835a22af56d1e3b66f04844bed63158bc094a628bec1d321d9b4c44bf2"
 dependencies = [
- "bit-set",
+ "bit-set 0.5.3",
  "regex-automata",
  "regex-syntax",
 ]
@@ -1169,7 +1184,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http 0.2.12",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -1188,7 +1203,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "http 1.4.0",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -1232,9 +1247,9 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.16.1"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
 
 [[package]]
 name = "hashlink"
@@ -1603,12 +1618,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.13.0"
+version = "2.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
 dependencies = [
  "equivalent",
- "hashbrown 0.16.1",
+ "hashbrown 0.17.1",
  "serde",
  "serde_core",
 ]
@@ -2155,6 +2170,25 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "proptest"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
+dependencies = [
+ "bit-set 0.8.0",
+ "bit-vec 0.8.0",
+ "bitflags 2.11.0",
+ "num-traits",
+ "rand 0.9.4",
+ "rand_chacha 0.9.0",
+ "rand_xorshift",
+ "regex-syntax",
+ "rusty-fork",
+ "tempfile",
+ "unarray",
+]
+
 [[package]]
 name = "protobuf"
 version = "3.7.2"
@@ -2175,6 +2209,12 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
 [[package]]
 name = "quote"
 version = "1.0.45"
@@ -2265,6 +2305,15 @@ dependencies = [
  "getrandom 0.3.4",
 ]
 
+[[package]]
+name = "rand_xorshift"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
+dependencies = [
+ "rand_core 0.9.5",
+]
+
 [[package]]
 name = "rayon"
 version = "1.12.0"
@@ -2517,6 +2566,18 @@ version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
+[[package]]
+name = "rusty-fork"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2"
+dependencies = [
+ "fnv",
+ "quick-error",
+ "tempfile",
+ "wait-timeout",
+]
+
 [[package]]
 name = "rustyline"
 version = "14.0.0"
@@ -2674,7 +2735,7 @@ dependencies = [
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "schemars 0.9.0",
  "schemars 1.2.1",
  "serde_core",
@@ -2848,6 +2909,7 @@ dependencies = [
  "libloading",
  "mockito",
  "once_cell",
+ "proptest",
  "rand 0.8.6",
  "reqwest",
  "rusqlite",
@@ -2855,6 +2917,7 @@ dependencies = [
  "serde",
  "serde_json",
  "sha2",
+ "similar",
  "stellar-strkey",
  "stellar-xdr",
  "tempfile",
@@ -2869,6 +2932,10 @@ dependencies = [
  "uuid",
  "wasm-bindgen",
  "wasm-bindgen-test",
+ "wasmparser 0.116.1",
+ "wasmprinter",
+ "wat",
+ "zeroize",
  "zip",
  "zxcvbn",
 ]
@@ -2984,6 +3051,15 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -3177,7 +3253,7 @@ version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
 dependencies = [
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
@@ -3303,6 +3379,12 @@ version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
 
+[[package]]
+name = "unarray"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
@@ -3442,6 +3524,15 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "wait-timeout"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -3590,7 +3681,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
 dependencies = [
  "leb128fmt",
- "wasmparser",
+ "wasmparser 0.244.0",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.252.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8185ae345fa5687c054626ff9a50e7089797a343d9904d1dc9820eb4c4d3196f"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.252.0",
 ]
 
 [[package]]
@@ -3600,9 +3701,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
 dependencies = [
  "anyhow",
- "indexmap 2.13.0",
- "wasm-encoder",
- "wasmparser",
+ "indexmap 2.14.0",
+ "wasm-encoder 0.244.0",
+ "wasmparser 0.244.0",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.116.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a58e28b80dd8340cb07b8242ae654756161f6fc8d0038123d679b7b99964fa50"
+dependencies = [
+ "indexmap 2.14.0",
+ "semver",
 ]
 
 [[package]]
@@ -3613,10 +3724,54 @@ checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
 dependencies = [
  "bitflags 2.11.0",
  "hashbrown 0.15.5",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
+ "semver",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.252.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3eb099dcadcde5be9eef55e3a337128efd4e44b4c93122487e4d2e4e1c6627c"
+dependencies = [
+ "bitflags 2.11.0",
+ "indexmap 2.14.0",
  "semver",
 ]
 
+[[package]]
+name = "wasmprinter"
+version = "0.252.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7142797de29b35ab8dbf15c00f55fda75d409da4c423a8ab8bd6b667a785824b"
+dependencies = [
+ "anyhow",
+ "termcolor",
+ "wasmparser 0.252.0",
+]
+
+[[package]]
+name = "wast"
+version = "252.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "942a3449d6a593fccc111a6241c8df52bda168af30e40bf9580d4394d7374c65"
+dependencies = [
+ "bumpalo",
+ "leb128fmt",
+ "memchr",
+ "unicode-width 0.2.2",
+ "wasm-encoder 0.252.0",
+]
+
+[[package]]
+name = "wat"
+version = "1.252.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c72a4ba7088f7bac94cf516e49882bdf97068904a563768cf249efc839ec42cb"
+dependencies = [
+ "wast",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.91"
@@ -3946,7 +4101,7 @@ checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
 dependencies = [
  "anyhow",
  "heck 0.5.0",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "prettyplease",
  "syn",
  "wasm-metadata",
@@ -3977,14 +4132,14 @@ checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
 dependencies = [
  "anyhow",
  "bitflags 2.11.0",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "log",
  "serde",
  "serde_derive",
  "serde_json",
- "wasm-encoder",
+ "wasm-encoder 0.244.0",
  "wasm-metadata",
- "wasmparser",
+ "wasmparser 0.244.0",
  "wit-parser",
 ]
 
@@ -3996,14 +4151,14 @@ checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
 dependencies = [
  "anyhow",
  "id-arena",
- "indexmap 2.13.0",
+ "indexmap 2.14.0",
  "log",
  "semver",
  "serde",
  "serde_derive",
  "serde_json",
  "unicode-xid",
- "wasmparser",
+ "wasmparser 0.244.0",
 ]
 
 [[package]]
@@ -4078,9 +4233,23 @@ dependencies = [
 
 [[package]]
 name = "zeroize"
-version = "1.8.2"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "zerotrie"
diff --git a/Cargo.toml b/Cargo.toml
index 158937d8..b36393f4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -74,10 +74,15 @@ tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "json", "fmt"] }
 tracing-appender = "0.2"
 bip39 = { version = "2", features = ["rand", "std"] }
+wasmparser = "0.116.0"
+wasmprinter = "0.252"
+wat = "1.0"
 hmac = "0.12"
 rustyline = "14.0.0"
 zip = "0.6"
 tempfile = "3.8"
+zeroize = { version = "1.9.0", features = ["derive"] }
+similar = "2.2"
 wasm-bindgen = "0.2"
 rusqlite = { version = "0.32", features = ["bundled"] }
 
@@ -89,6 +94,7 @@ criterion = "0.5.1"
 tempfile = "3.8"
 mockito = "1.2"
 wasm-bindgen-test = "0.3"
+proptest = "1.5"
 
 [[bench]]
 name = "benchmarks"
diff --git a/DEPLOYMENT_PREPARATION_TEST_COVERAGE.md b/DEPLOYMENT_PREPARATION_TEST_COVERAGE.md
deleted file mode 100644
index 735f0f6e..00000000
--- a/DEPLOYMENT_PREPARATION_TEST_COVERAGE.md
+++ /dev/null
@@ -1,362 +0,0 @@
-# Deployment Preparation End-to-End Test Coverage
-
-## Summary
-
-Added comprehensive end-to-end tests for deployment preparation, covering WASM validation, wallet resolution, account checks, and deployment planning with full error handling and edge case coverage.
-
-## Test Files Added
-
-### 1. `tests/deployment_preparation_e2e.rs`
-
-End-to-end integration tests for complete deployment preparation workflows.
-
-**Test Categories:**
-
-#### WASM File Validation Tests (7 tests)
-
-- ✅ `test_wasm_file_exists()` - WASM file existence check
-- ✅ `test_wasm_file_not_found()` - Handle missing WASM file
-- ✅ `test_wasm_hash_generation()` - SHA-256 hash generation
-- ✅ `test_wasm_hash_is_deterministic()` - Hash determinism verification
-- ✅ `test_wasm_size_calculation()` - WASM size in KB calculation
-- ✅ `test_wasm_size_below_limit()` - Size below 128 KB limit
-- ✅ `test_wasm_size_above_limit()` - Size above 128 KB limit
-- ✅ `test_wasm_size_exactly_at_limit()` - Size exactly at 128 KB limit
-
-#### Wallet Resolution Tests (4 tests)
-
-- ✅ `test_resolve_wallet_by_name()` - Resolve wallet by name
-- ✅ `test_resolve_wallet_not_found()` - Handle missing wallet
-- ✅ `test_resolve_wallet_default_to_first()` - Default to first wallet
-- ✅ `test_resolve_wallet_no_wallets_configured()` - Handle no wallets
-
-#### Account Validation Tests (4 tests)
-
-- ✅ `test_account_funded_status_check()` - Check funded status
-- ✅ `test_account_unfunded_status_check()` - Check unfunded status
-- ✅ `test_deployment_fails_with_unfunded_wallet()` - Reject unfunded wallet
-- ✅ `test_account_xlm_balance_check()` - Verify XLM balance
-
-#### Deployment Planning Tests (3 tests)
-
-- ✅ `test_plan_deployment_success()` - Successful deployment plan
-- ✅ `test_plan_deployment_invalid_wasm()` - Reject invalid WASM
-- ✅ `test_plan_deployment_unfunded_wallet()` - Reject unfunded wallet
-
-#### Deployment Warning Tests (4 tests)
-
-- ✅ `test_warning_wasm_size_exceeds_limit()` - Warn on oversized WASM
-- ✅ `test_warning_mainnet_deployment()` - Warn on mainnet deployment
-- ✅ `test_warning_low_xlm_balance()` - Warn on low XLM balance
-- ✅ `test_no_warnings_for_normal_deployment()` - No warnings for normal case
-
-#### Network Validation Tests (2 tests)
-
-- ✅ `test_deployment_on_testnet()` - Testnet deployment
-- ✅ `test_deployment_on_mainnet()` - Mainnet deployment
-
-#### Complete Workflow Tests (2 tests)
-
-- ✅ `test_complete_deployment_preparation_workflow()` - Full workflow: validate → resolve → check → plan
-- ✅ `test_deployment_preparation_with_multiple_warnings()` - Multiple warnings scenario
-
-#### Error Recovery Tests (1 test)
-
-- ✅ `test_deployment_preparation_state_consistency()` - State consistency after errors
-
-**Total: 27 end-to-end tests**
-
-### 2. `tests/deployment_error_handling.rs`
-
-Comprehensive error handling and edge case tests.
-
-**Test Categories:**
-
-#### WASM File Validation Error Tests (4 tests)
-
-- ✅ `test_wasm_file_not_found()` - Handle missing file
-- ✅ `test_wasm_file_empty()` - Reject empty file
-- ✅ `test_wasm_hash_computation_failed()` - Handle hash failure
-- ✅ `test_wasm_file_valid()` - Accept valid file
-
-#### Wallet Validation Error Tests (3 tests)
-
-- ✅ `test_wallet_not_found()` - Handle missing wallet
-- ✅ `test_wallet_not_funded()` - Reject unfunded wallet
-- ✅ `test_wallet_funded()` - Accept funded wallet
-
-#### Public Key Validation Error Tests (5 tests)
-
-- ✅ `test_public_key_invalid_prefix()` - Reject invalid prefix
-- ✅ `test_public_key_too_short()` - Reject short key
-- ✅ `test_public_key_too_long()` - Reject long key
-- ✅ `test_public_key_invalid_characters()` - Reject invalid chars
-- ✅ `test_public_key_valid()` - Accept valid key
-
-#### Network Validation Error Tests (4 tests)
-
-- ✅ `test_network_testnet_valid()` - Accept testnet
-- ✅ `test_network_mainnet_valid()` - Accept mainnet
-- ✅ `test_network_docker_testnet_valid()` - Accept docker-testnet
-- ✅ `test_network_unknown()` - Reject unknown network
-
-#### XLM Balance Validation Error Tests (5 tests)
-
-- ✅ `test_xlm_balance_negative()` - Reject negative balance
-- ✅ `test_xlm_balance_zero()` - Reject zero balance
-- ✅ `test_xlm_balance_insufficient()` - Reject insufficient balance
-- ✅ `test_xlm_balance_sufficient()` - Accept sufficient balance
-- ✅ `test_xlm_balance_high()` - Accept high balance
-
-#### Combined Validation Tests (2 tests)
-
-- ✅ `test_deployment_validation_all_checks_pass()` - All validations pass
-- ✅ `test_deployment_validation_multiple_failures()` - Multiple failures
-
-#### Error Message Clarity Tests (4 tests)
-
-- ✅ `test_error_message_wallet_not_found()` - Clear wallet error
-- ✅ `test_error_message_wallet_not_funded()` - Clear funding error
-- ✅ `test_error_message_public_key_length()` - Clear key length error
-- ✅ `test_error_message_insufficient_balance()` - Clear balance error
-
-#### State Consistency Tests (2 tests)
-
-- ✅ `test_validator_state_unchanged_after_errors()` - State consistency
-- ✅ `test_multiple_error_scenarios_dont_corrupt_state()` - Multiple errors
-
-**Total: 30 error handling tests**
-
-## Test Coverage Summary
-
-### WASM Validation (11 tests)
-
-- File existence and validity
-- Hash generation and determinism
-- Size calculation and limits
-- Empty file detection
-- Hash computation failures
-
-### Wallet Resolution (7 tests)
-
-- Resolve by name
-- Default to first wallet
-- Handle missing wallets
-- Handle no wallets configured
-- Funding status checks
-
-### Account Validation (9 tests)
-
-- Funded status verification
-- Unfunded wallet rejection
-- XLM balance checks
-- Negative balance rejection
-- Insufficient balance detection
-
-### Deployment Planning (5 tests)
-
-- Successful planning
-- Invalid WASM rejection
-- Unfunded wallet rejection
-- Multiple warnings
-- State consistency
-
-### Network Validation (6 tests)
-
-- Testnet support
-- Mainnet support
-- Docker-testnet support
-- Unknown network rejection
-- Network-specific warnings
-
-### Error Handling (15 tests)
-
-- Clear error messages
-- Validation failures
-- State consistency
-- Multiple error scenarios
-- Error recovery
-
-### Total: 57 comprehensive deployment preparation tests
-
-## Acceptance Criteria Met
-
-✅ **Deployment preparation can be validated automatically**
-
-- All major deployment steps tested (WASM validation, wallet resolution, account checks, planning)
-- Real deployment workflows exercised
-- Multiple scenario combinations tested
-- Error paths validated
-
-✅ **The expected output and warnings are stable**
-
-- Warning generation tested (size, mainnet, balance)
-- No warnings for normal cases
-- Multiple warnings combined correctly
-- Error messages are clear and actionable
-
-✅ **No deploy-related regression goes unnoticed**
-
-- Complete workflow tested end-to-end
-- All validation steps covered
-- Error scenarios covered
-- State consistency verified
-- Edge cases covered
-
-## Test Execution
-
-Run all deployment preparation tests:
-
-```bash
-cargo test --test deployment_preparation_e2e
-cargo test --test deployment_error_handling
-```
-
-Run specific test category:
-
-```bash
-# WASM validation tests
-cargo test --test deployment_preparation_e2e test_wasm
-
-# Wallet resolution tests
-cargo test --test deployment_preparation_e2e test_resolve
-
-# Error handling tests
-cargo test --test deployment_error_handling test_validation
-```
-
-Run with output:
-
-```bash
-cargo test --test deployment_preparation_e2e -- --nocapture
-```
-
-## Coverage Areas
-
-### ✅ Fully Covered
-
-- WASM file validation and hash generation
-- WASM size calculation and limit checking
-- Wallet resolution (by name, default, missing)
-- Account funding status verification
-- XLM balance validation
-- Deployment planning with warnings
-- Network validation (testnet, mainnet, docker-testnet)
-- Error handling for all validation steps
-- Error message clarity
-- State consistency after errors
-- Multiple warning scenarios
-- Edge cases (empty files, invalid keys, etc.)
-
-### 🔄 Partially Covered (by existing tests)
-
-- Actual Horizon API calls (mocked in tests)
-- Actual Soroban RPC simulation (mocked in tests)
-- Stellar CLI execution (mocked in tests)
-- WASM optimization (separate test suite)
-
-### 📝 Future Enhancements
-
-- Network failure simulation
-- Horizon timeout handling
-- Soroban RPC error scenarios
-- Stellar CLI not found handling
-- Concurrent deployment attempts
-- Large WASM file handling
-- Transaction fee estimation
-- Contract ID generation
-
-## Key Testing Patterns
-
-### 1. WASM Validation
-
-- File existence and validity
-- Hash generation (SHA-256)
-- Size calculation and limits
-- Empty file detection
-- Hash computation failures
-
-### 2. Wallet Resolution
-
-- Resolve by name
-- Default to first wallet
-- Handle missing wallets
-- Verify funding status
-- Check network compatibility
-
-### 3. Account Validation
-
-- Fetch account from Horizon
-- Verify funding status
-- Check XLM balance
-- Validate public key format
-- Handle account not found
-
-### 4. Deployment Planning
-
-- Validate all inputs
-- Generate warnings
-- Calculate fees
-- Build deployment command
-- Maintain state consistency
-
-### 5. Error Handling
-
-- Clear error messages
-- Graceful failure
-- State consistency
-- Multiple error scenarios
-- Error recovery
-
-## Benefits
-
-1. **Reliability**: Comprehensive tests catch deployment regressions early
-2. **Confidence**: Developers can deploy with confidence
-3. **Documentation**: Tests serve as deployment workflow examples
-4. **Quality**: Broken deployments caught before execution
-5. **Maintainability**: Clear test structure for future changes
-
-## Related Files
-
-- `src/commands/deploy.rs` - Deployment command handler
-- `src/utils/soroban.rs` - Soroban RPC integration
-- `src/utils/optimizer.rs` - WASM optimization
-- `src/utils/horizon.rs` - Horizon integration
-- `src/utils/config.rs` - Configuration and validation
-- `tests/deploy_wasm_hash_test.rs` - WASM hash tests
-
-## Notes
-
-- Tests use mock structures to avoid network dependencies
-- Tests are isolated and can run in any order
-- All tests are deterministic and reproducible
-- No external network calls required
-- Tests run quickly (< 1 second total)
-- Error messages are validated for clarity
-
-## Test Statistics
-
-- **Total Tests**: 57
-- **Test Files**: 2
-- **Coverage Areas**: 5 (WASM, wallet, account, planning, errors)
-- **Error Scenarios**: 30
-- **Edge Cases**: 8
-- **Execution Time**: < 1 second
-- **Lines of Test Code**: ~1200
-
-## Regression Prevention
-
-These tests prevent regressions in:
-
-- WASM file validation
-- WASM hash generation
-- WASM size checking
-- Wallet resolution
-- Account validation
-- XLM balance checking
-- Deployment planning
-- Warning generation
-- Error handling
-- State management
-- Network validation
-- Public key validation
diff --git a/DEVELOPER_GUIDE.md b/DEVELOPER_GUIDE.md
deleted file mode 100644
index 1c075334..00000000
--- a/DEVELOPER_GUIDE.md
+++ /dev/null
@@ -1,1221 +0,0 @@
-# StarForge Developer Guide
-
-Complete guide for developers contributing to or extending StarForge.
-
-## Table of Contents
-
-1. [Plugin Version Compatibility](#plugin-version-compatibility)
-2. [Getting Started](#getting-started)
-3. [Development Setup](#development-setup)
-4. [Project Structure](#project-structure)
-5. [Code Style Guide](#code-style-guide)
-6. [Adding New Features](#adding-new-features)
-7. [Testing](#testing)
-8. [Documentation](#documentation)
-9. [Common Tasks](#common-tasks)
-10. [Debugging](#debugging)
-11. [Release Process](#release-process)
-
----
-
-## Plugin Version Compatibility
-
-StarForge enforces version compatibility when loading plugins to prevent subtle
-runtime failures caused by ABI or API mismatches.
-
-### How it works
-
-Every plugin shared library must export a `PLUGIN_DECLARATION` symbol (provided
-automatically by the `export_plugin!` macro).  When `starforge plugin load` runs,
-the loader checks two fields in that declaration:
-
-| Field | What is checked | Failure behaviour |
-|---|---|---|
-| `rustc_version` | Must match the exact rustc version used to build StarForge | Hard error — load aborted |
-| `core_version` | **Major** version must match StarForge's own `CARGO_PKG_VERSION` | Hard error — load aborted |
-
-The compatibility rule for `core_version` follows semantic versioning:
-
-- `0.x.y` plugins are **only** compatible with a `0.x.y` StarForge core (major `0`).
-- `1.x.y` plugins are **only** compatible with a `1.x.y` StarForge core (major `1`).
-- Minor and patch bumps within the same major are considered backwards-compatible.
-
-### Error messages
-
-When a plugin fails the version check you will see a clear message, for example:
-
-```
-Error: Plugin version incompatibility in 'libmy_plugin.so':
-  Plugin was built for StarForge 0.1.0
-  Running StarForge 1.0.0
-
-  The major version must match. Rebuild the plugin against
-  StarForge 1.0.0 or install a compatible StarForge version.
-  See DEVELOPER_GUIDE.md § "Plugin Version Compatibility" for details.
-```
-
-### Writing a compatible plugin
-
-1. **Pin the StarForge version** in your plugin's `Cargo.toml`:
-
-   ```toml
-   [dependencies]
-   # Use the same major version as the StarForge binary your users will run.
-   starforge = "0.1"
-   ```
-
-2. **Use the `export_plugin!` macro** — it embeds both `rustc_version` and
-   `core_version` automatically at compile time:
-
-   ```rust
-   use starforge::export_plugin;
-
-   export_plugin!(register);
-
-   fn register(registrar: &mut dyn starforge::plugins::PluginRegistrar) {
-       registrar.register_plugin(Box::new(MyPlugin));
-   }
-   ```
-
-3. **Rebuild when StarForge's major version changes.**  Check the running version
-   with `starforge --version` and compare it to the version your plugin was built
-   against (shown in `starforge plugin load` output under "Built for StarForge").
-
-4. **Use the same Rust toolchain** as the StarForge binary.  The easiest way is
-   to keep a `rust-toolchain.toml` in your plugin repo that mirrors the one in
-   the StarForge repo.
-
-### Checking compatibility without loading
-
-```bash
-# See which StarForge version is running
-starforge --version
-
-# See which version each installed plugin was built for
-starforge plugin load
-```
-
-The `load` command prints a "Built for StarForge" line for every successfully
-loaded plugin, and a descriptive error for any that fail the check.
-
----
-
-## Getting Started
-
-### Prerequisites
-
-- **Rust**: 1.80 or higher ([install via rustup](https://rustup.rs))
-- **Git**: For version control
-- **Stellar CLI**: For contract operations (optional)
-- **Docker**: For containerized development (optional)
-
-### Clone and Build
-
-```bash
-# Clone repository
-git clone https://github.com/YOUR_USERNAME/starforge.git
-cd starforge
-
-# Build in debug mode
-cargo build
-
-# Build in release mode
-cargo build --release
-
-# Run tests
-cargo test
-
-# Run with logging
-RUST_LOG=debug cargo run -- wallet list
-```
-
----
-
-## Development Setup
-
-### IDE Configuration
-
-#### VS Code
-
-Recommended extensions:
-
-- `rust-analyzer` - Rust language support
-- `crates` - Cargo.toml dependency management
-- `Better TOML` - TOML syntax highlighting
-- `Error Lens` - Inline error display
-
-`.vscode/settings.json`:
-
-```json
-{
-  "rust-analyzer.checkOnSave.command": "clippy",
-  "rust-analyzer.cargo.features": "all",
-  "editor.formatOnSave": true
-}
-```
-
-#### IntelliJ IDEA / CLion
-
-Install the Rust plugin and configure:
-
-- Enable Clippy for code analysis
-- Set rustfmt as formatter
-- Enable external linter
-
-### Environment Variables
-
-```bash
-# Enable debug logging
-export RUST_LOG=debug
-
-# Disable telemetry during development
-export STARFORGE_TELEMETRY=false
-
-# Use custom config directory
-export STARFORGE_CONFIG_DIR=~/.starforge-dev
-```
-
-### Development Workflow
-
-```bash
-# 1. Create feature branch
-git checkout -b feature/my-feature
-
-# 2. Make changes
-# ... edit files ...
-
-# 3. Run tests
-cargo test
-
-# 4. Check formatting
-cargo fmt --check
-
-# 5. Run clippy
-cargo clippy -- -D warnings
-
-# 6. Build
-cargo build
-
-# 7. Test manually
-cargo run -- <command>
-
-# 8. Run smoke tests (optional but recommended)
-./scripts/e2e-smoke.sh
-
-# 9. Commit
-git add .
-git commit -m "feat: add my feature"
-
-# 10. Push and create PR
-git push origin feature/my-feature
-```
-
----
-
-## Project Structure
-
-### Source Code Organization
-
-```
-src/
-├── main.rs              # Entry point
-├── commands/            # User-facing commands
-│   ├── mod.rs          # Module exports
-│   ├── wallet.rs       # Wallet operations
-│   ├── template.rs     # Template marketplace
-│   └── ...
-├── utils/               # Shared utilities
-│   ├── mod.rs          # Module exports
-│   ├── config.rs       # Configuration
-│   ├── templates.rs    # Template system
-│   └── ...
-└── plugins/             # Plugin system
-    ├── mod.rs          # Module exports
-    ├── interface.rs    # Plugin traits
-    └── ...
-```
-
-### File Naming Conventions
-
-- **Commands**: `<noun>.rs` (e.g., `wallet.rs`, `network.rs`)
-- **Utilities**: `<function>.rs` (e.g., `config.rs`, `crypto.rs`)
-- **Tests**: `<module>_test.rs` or inline `#[cfg(test)] mod tests`
-
-### Module Organization
-
-Each module should follow this structure:
-
-```rust
-// 1. Imports
-use crate::utils::config;
-use anyhow::Result;
-
-// 2. Type definitions
-pub struct MyStruct { /* ... */ }
-pub enum MyEnum { /* ... */ }
-
-// 3. Public API
-pub fn public_function() -> Result<()> { /* ... */ }
-
-// 4. Private helpers
-fn private_helper() { /* ... */ }
-
-// 5. Tests
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_something() { /* ... */ }
-}
-```
-
----
-
-## Code Style Guide
-
-### Rust Style
-
-Follow the [Rust Style Guide](https://doc.rust-lang.org/1.0.0/style/):
-
-```rust
-// ✅ Good
-pub fn create_wallet(name: String, encrypt: bool) -> Result<()> {
-    validate_name(&name)?;
-    let keypair = generate_keypair();
-    save_wallet(name, keypair, encrypt)
-}
-
-// ❌ Bad
-pub fn CreateWallet(Name: String, Encrypt: bool) -> Result<()> {
-    ValidateName(&Name)?;
-    let KeyPair = GenerateKeypair();
-    SaveWallet(Name, KeyPair, Encrypt)
-}
-```
-
-### Naming Conventions
-
-| Type      | Convention             | Example           |
-| --------- | ---------------------- | ----------------- |
-| Functions | `snake_case`           | `fetch_account()` |
-| Types     | `PascalCase`           | `WalletEntry`     |
-| Constants | `SCREAMING_SNAKE_CASE` | `MAX_RETRIES`     |
-| Modules   | `snake_case`           | `hardware_wallet` |
-| Lifetimes | `'lowercase`           | `'a`, `'static`   |
-
-### Error Handling
-
-```rust
-// ✅ Use Result and ? operator
-pub fn operation() -> Result<()> {
-    let data = load_data()?;
-    process_data(data)?;
-    Ok(())
-}
-
-// ✅ Add context to errors
-fs::read_to_string(&path)
-    .with_context(|| format!("Failed to read {}", path.display()))?
-
-// ❌ Don't use unwrap() in production code
-let data = load_data().unwrap(); // Bad!
-
-// ✅ Use expect() with clear message for programmer errors
-let data = load_data()
-    .expect("Config should be initialized in main()");
-```
-
-### Documentation
-
-````rust
-/// Fetches account information from Horizon API.
-///
-/// # Arguments
-///
-/// * `public_key` - The Stellar public key (G...)
-/// * `network` - Network name ("testnet" or "mainnet")
-///
-/// # Returns
-///
-/// Returns `AccountResponse` with balance and sequence information.
-///
-/// # Errors
-///
-/// Returns error if:
-/// - Account doesn't exist on the network
-/// - Network is unreachable
-/// - Response parsing fails
-///
-/// # Example
-///
-/// ```
-/// let account = fetch_account("GABC...", "testnet")?;
-/// println!("Balance: {}", account.balances[0].balance);
-/// ```
-pub fn fetch_account(public_key: &str, network: &str) -> Result<AccountResponse> {
-    // Implementation
-}
-````
-
-### Comments
-
-```rust
-// ✅ Explain WHY, not WHAT
-// Use shallow clone to reduce bandwidth and disk usage
-git_clone(&url, "--depth", "1");
-
-// ❌ Don't state the obvious
-// Clone the repository
-git_clone(&url);
-
-// ✅ TODO comments with context
-// TODO(username): Add retry logic after implementing exponential backoff
-
-// ❌ Vague TODOs
-// TODO: fix this
-```
-
----
-
-## Adding New Features
-
-### 1. Adding a New Command
-
-**Step 1**: Create command file
-
-```bash
-touch src/commands/mycommand.rs
-```
-
-**Step 2**: Define command structure
-
-```rust
-// src/commands/mycommand.rs
-use anyhow::Result;
-use clap::Subcommand;
-use crate::utils::print as p;
-
-#[derive(Subcommand)]
-pub enum MyCommands {
-    /// Do something useful
-    Action {
-        /// Input parameter
-        #[arg(long)]
-        input: String,
-    },
-}
-
-pub fn handle(cmd: MyCommands) -> Result<()> {
-    match cmd {
-        MyCommands::Action { input } => action(input),
-    }
-}
-
-fn action(input: String) -> Result<()> {
-    p::header("My Command");
-    p::kv("Input", &input);
-
-    // Your logic here
-
-    p::success("Done!");
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_action() {
-        // Test your command
-    }
-}
-```
-
-**Step 3**: Register in mod.rs
-
-```rust
-// src/commands/mod.rs
-pub mod mycommand;
-```
-
-**Step 4**: Add to main CLI
-
-```rust
-// src/main.rs
-#[derive(Subcommand)]
-enum Commands {
-    // ... existing commands
-
-    /// My new command
-    #[command(subcommand)]
-    MyCommand(commands::mycommand::MyCommands),
-}
-
-// In main():
-let result = match cli.command {
-    // ... existing matches
-    Commands::MyCommand(cmd) => commands::mycommand::handle(cmd),
-};
-```
-
-**Step 5**: Update documentation
-
-```bash
-# Update README.md with new command
-# Add examples to examples/ directory
-# Update ARCHITECTURE.md if needed
-```
-
-### 2. Adding a New Utility Module
-
-**Step 1**: Create utility file
-
-```bash
-touch src/utils/myutil.rs
-```
-
-**Step 2**: Implement functionality
-
-```rust
-// src/utils/myutil.rs
-use anyhow::Result;
-
-/// Does something useful
-pub fn do_something(input: &str) -> Result<String> {
-    // Implementation
-    Ok(format!("Processed: {}", input))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_do_something() {
-        let result = do_something("test").unwrap();
-        assert_eq!(result, "Processed: test");
-    }
-}
-```
-
-**Step 3**: Register in mod.rs
-
-```rust
-// src/utils/mod.rs
-pub mod myutil;
-```
-
-**Step 4**: Use in commands
-
-```rust
-use crate::utils::myutil;
-
-fn my_command() -> Result<()> {
-    let result = myutil::do_something("input")?;
-    println!("{}", result);
-    Ok(())
-}
-```
-
-### 3. Adding Template Support
-
-**Step 1**: Create template directory
-
-```bash
-mkdir -p templates/examples/my-template/src
-```
-
-**Step 2**: Add template files
-
-```toml
-# templates/examples/my-template/Cargo.toml
-[package]
-name = "{{PROJECT_NAME}}"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-soroban-sdk = "21.0.0"
-```
-
-```rust
-// templates/examples/my-template/src/lib.rs
-#![no_std]
-use soroban_sdk::{contract, contractimpl, Env};
-
-#[contract]
-pub struct {{PROJECT_NAME_PASCAL}};
-
-#[contractimpl]
-impl {{PROJECT_NAME_PASCAL}} {
-    pub fn hello(env: Env) -> String {
-        String::from_str(&env, "Hello from {{PROJECT_NAME}}")
-    }
-}
-```
-
-**Step 3**: Add to registry
-
-```json
-// templates/registry.json
-{
-  "templates": [
-    {
-      "name": "my-template",
-      "version": "1.0.0",
-      "description": "My awesome template",
-      "author": "Your Name",
-      "tags": ["example"],
-      "source": {
-        "type": "local",
-        "path": "templates/examples/my-template"
-      },
-      "created_at": "2025-01-01T00:00:00Z",
-      "updated_at": "2025-01-01T00:00:00Z",
-      "downloads": 0,
-      "verified": false
-    }
-  ]
-}
-```
-
----
-
-## Testing
-
-### Unit Tests
-
-```rust
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_basic_functionality() {
-        let result = my_function("input");
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "expected");
-    }
-
-    #[test]
-    fn test_error_case() {
-        let result = my_function("");
-        assert!(result.is_err());
-    }
-
-    #[test]
-    #[should_panic(expected = "Invalid input")]
-    fn test_panic() {
-        panic_function();
-    }
-}
-```
-
-### Integration Tests
-
-```rust
-// tests/integration_test.rs
-use starforge::utils::config;
-use tempfile::TempDir;
-
-#[test]
-fn test_config_lifecycle() {
-    let temp = TempDir::new().unwrap();
-    let config_path = temp.path().join("config.toml");
-
-    // Test save
-    let config = config::Config::default();
-    config::save(&config).unwrap();
-
-    // Test load
-    let loaded = config::load().unwrap();
-    assert_eq!(loaded.version, config.version);
-}
-```
-
-### CLI smoke tests
-
-Fast regression checks for core commands live in `tests/cli_smoke.rs` and
-`scripts/e2e-smoke.sh`. CI runs both after every build:
-
-```bash
-cargo test --test cli_smoke
-./scripts/e2e-smoke.sh
-STARFORGE_E2E=1 ./scripts/e2e-smoke.sh   # optional network checks
-```
-
-### Running Tests
-
-```bash
-# Run all tests
-cargo test
-
-# Run specific test
-cargo test test_name
-
-# Run tests with output
-cargo test -- --nocapture
-
-# Run tests in specific module
-cargo test config::tests
-
-# Run integration tests only
-cargo test --test integration_test
-
-# Run with coverage (requires tarpaulin)
-cargo tarpaulin --out Html
-```
-
-### End-to-End Smoke Tests
-
-StarForge includes an end-to-end smoke test script that verifies basic functionality across all major commands.
-
-**Location**: `scripts/e2e-smoke.sh`
-
-**Running Smoke Tests**:
-
-```bash
-# Build the project first
-cargo build --release
-
-# Run smoke tests (without network tests)
-./scripts/e2e-smoke.sh
-
-# Run smoke tests with network tests (requires internet)
-STARFORGE_E2E=1 ./scripts/e2e-smoke.sh
-```
-
-**What the smoke test covers**:
-
-1. **Basic Commands**
-   - `starforge info` - System information
-   - `starforge --version` - Version display
-   - `starforge --help` - Help text
-
-2. **Wallet Operations**
-   - `wallet create` - Create test wallet
-   - `wallet list` - List wallets
-   - `wallet show` - Display wallet details
-
-3. **Network Operations**
-   - `network show` - Display network configuration
-   - `network test` - Test network connectivity (requires `STARFORGE_E2E=1`)
-   - `wallet fund` - Fund testnet wallet (requires `STARFORGE_E2E=1`)
-
-4. **Template Operations**
-   - `template list` - List available templates
-   - `template search` - Search templates
-
-5. **Other Commands**
-   - `completions` - Generate shell completions
-
-**Network Test Gating**:
-
-Network tests are gated behind the `STARFORGE_E2E=1` environment variable because they:
-- Require internet connectivity
-- Depend on external services (Stellar testnet, Friendbot)
-- May be slow or flaky in CI environments
-- Can hit rate limits
-
-To skip network tests in CI:
-
-```yaml
-# .github/workflows/ci.yml
-- name: Run smoke tests
-  run: ./scripts/e2e-smoke.sh  # Skips network tests by default
-```
-
-To run full tests locally:
-
-```bash
-STARFORGE_E2E=1 ./scripts/e2e-smoke.sh
-```
-
-**Exit Codes**:
-- `0` - All tests passed
-- `1` - One or more tests failed
-
-**Cleanup**:
-
-The smoke test automatically cleans up test wallets on exit. If cleanup fails, you may need to manually remove test wallets:
-
-```bash
-# List wallets to find test wallets
-starforge wallet list
-
-# Remove test wallet (when delete command is implemented)
-# starforge wallet delete smoke-test-<timestamp>
-```
-
-### Test Organization
-
-```
-tests/
-├── integration_test.rs      # Integration tests
-├── template_test.rs          # Template-specific tests
-└── common/
-    └── mod.rs               # Shared test utilities
-```
-
----
-
-## Documentation
-
-### Code Documentation
-
-```rust
-/// Module-level documentation
-///
-/// This module handles wallet operations including creation,
-/// listing, and management of Stellar keypairs.
-
-/// Function documentation
-///
-/// Creates a new wallet with the given name.
-///
-/// # Arguments
-///
-/// * `name` - Wallet identifier
-/// * `encrypt` - Whether to encrypt the secret key
-///
-/// # Returns
-///
-/// Returns `Ok(())` on success, or an error if:
-/// - Wallet name already exists
-/// - Keypair generation fails
-/// - Config save fails
-pub fn create_wallet(name: String, encrypt: bool) -> Result<()> {
-    // Implementation
-}
-```
-
-### User Documentation
-
-Update these files when adding features:
-
-1. **README.md** - Main documentation, usage examples
-2. **ARCHITECTURE.md** - Architecture and design decisions
-3. **DEVELOPER_GUIDE.md** - This file
-4. **Feature-specific docs** - Detailed feature documentation
-
-### Documentation Standards
-
-- Use clear, concise language
-- Include code examples
-- Explain WHY, not just WHAT
-- Keep examples up-to-date
-- Add diagrams for complex flows
-- Update [docs/COMMAND_REFERENCE.md](docs/COMMAND_REFERENCE.md) when adding or renaming CLI subcommands
-
----
-
-## Common Tasks
-
-### Adding a Dependency
-
-```bash
-# Add to Cargo.toml
-cargo add <crate-name>
-
-# Add with specific version
-cargo add <crate-name>@1.0.0
-
-# Add with features
-cargo add <crate-name> --features feature1,feature2
-
-# Add as dev dependency
-cargo add --dev <crate-name>
-```
-
-### Updating Dependencies
-
-```bash
-# Update all dependencies
-cargo update
-
-# Update specific dependency
-cargo update <crate-name>
-
-# Check for outdated dependencies
-cargo outdated
-```
-
-### Running Clippy
-
-```bash
-# Run clippy
-cargo clippy
-
-# Deny all warnings
-cargo clippy -- -D warnings
-
-# Fix automatically (when possible)
-cargo clippy --fix
-```
-
-### Formatting Code
-
-```bash
-# Format all code
-cargo fmt
-
-# Check formatting without changing
-cargo fmt --check
-
-# Format specific file
-rustfmt src/main.rs
-```
-
-### Regenerating Shell Completions
-
-Shell completion scripts are generated by `build.rs` into the `completions/` directory.
-
-```bash
-# Regenerate completions (bash/zsh/fish)
-cargo build
-```
-
-### Building Documentation
-
-```bash
-# Build docs
-cargo doc
-
-# Build and open in browser
-cargo doc --open
-
-# Include private items
-cargo doc --document-private-items
-```
-
-### Benchmarking
-
-```bash
-# Run benchmarks
-cargo bench
-
-# Run specific benchmark
-cargo bench benchmark_name
-
-# Save baseline
-cargo bench -- --save-baseline my-baseline
-
-# Compare to baseline
-cargo bench -- --baseline my-baseline
-```
-
-### Running with Docker Soroban Sandbox
-
-The `shell` command supports connecting to a local Soroban sandbox via Docker:
-
-```bash
-# Start the interactive shell against a local Docker Soroban sandbox
-starforge shell --contract ./target/wasm32-unknown-unknown/release/my_contract.wasm --network docker-testnet
-```
-
-When `--network docker-testnet` is used, StarForge:
-1. Ensures the Docker containers defined in `docker-compose.yml` are running (includes `stellar-testnet` and `soroban-rpc`)
-2. Runs contract invocations inside the Docker network where the Soroban RPC is available at `http://soroban-rpc:8000`
-3. Routes all RPC calls through the local sandbox instead of Stellar testnet
-
-The `docker-compose.yml` at the project root defines:
-- **stellar-testnet**: A full Stellar + Soroban RPC node on `localhost:8000`
-- **soroban-rpc**: Dedicated Soroban RPC endpoint on `localhost:8001`
-
-Prerequisites:
-- Docker and docker-compose installed
-- Docker daemon running
-
----
-
-## Debugging
-
-### Debug Logging
-
-```rust
-// Add to Cargo.toml
-[dependencies]
-log = "0.4"
-env_logger = "0.10"
-
-// In main.rs
-env_logger::init();
-
-// In code
-use log::{debug, info, warn, error};
-
-debug!("Debug message: {:?}", value);
-info!("Info message");
-warn!("Warning message");
-error!("Error message");
-```
-
-### Running with Debug Output
-
-```bash
-# Enable all debug logs
-RUST_LOG=debug cargo run -- wallet list
-
-# Enable specific module
-RUST_LOG=starforge::commands::wallet=debug cargo run -- wallet list
-
-# Multiple modules
-RUST_LOG=starforge::commands=debug,starforge::utils=info cargo run
-```
-
-### Using rust-gdb
-
-```bash
-# Build with debug symbols
-cargo build
-
-# Run with gdb
-rust-gdb target/debug/starforge
-
-# Set breakpoint
-(gdb) break src/main.rs:42
-
-# Run
-(gdb) run wallet list
-
-# Step through
-(gdb) step
-(gdb) next
-
-# Print variable
-(gdb) print variable_name
-```
-
-### Common Issues
-
-**Issue**: Compilation errors after updating dependencies
-
-```bash
-# Solution: Clean and rebuild
-cargo clean
-cargo build
-```
-
-**Issue**: Tests failing intermittently
-
-```bash
-# Solution: Run tests serially
-cargo test -- --test-threads=1
-```
-
-**Issue**: Slow compilation
-
-```bash
-# Solution: Use sccache
-cargo install sccache
-export RUSTC_WRAPPER=sccache
-```
-
----
-
-## Release Process
-
-### Version Bumping
-
-1. Update version in `Cargo.toml`
-2. Update version in `src/main.rs` (if hardcoded)
-3. Update CHANGELOG.md
-4. Commit: `git commit -m "chore: bump version to X.Y.Z"`
-
-### Creating a Release
-
-```bash
-# 1. Tag the release
-git tag -a v0.2.0 -m "Release v0.2.0"
-
-# 2. Push tag
-git push origin v0.2.0
-
-# 3. Build release binaries
-cargo build --release
-
-# 4. Create GitHub release
-# - Go to GitHub releases
-# - Create new release from tag
-# - Upload binaries
-# - Add release notes
-```
-
-### Release Checklist
-
-- [ ] All tests passing
-- [ ] Documentation updated
-- [ ] CHANGELOG.md updated
-- [ ] Version bumped
-- [ ] Release notes prepared
-- [ ] Binaries built for all platforms
-- [ ] GitHub release created
-- [ ] Announcement posted
-
----
-
-## Best Practices
-
-### 1. Error Handling
-
-```rust
-// ✅ Use Result for fallible operations
-pub fn operation() -> Result<()> {
-    let data = load_data()?;
-    process(data)?;
-    Ok(())
-}
-
-// ✅ Add context to errors
-load_data()
-    .with_context(|| "Failed to load configuration")?
-
-// ✅ Create custom error types for complex cases
-#[derive(Debug, thiserror::Error)]
-pub enum MyError {
-    #[error("Invalid input: {0}")]
-    InvalidInput(String),
-    #[error("Network error")]
-    Network(#[from] ureq::Error),
-}
-```
-
-### 2. Configuration Management
-
-```rust
-// ✅ Load config once, pass as reference
-let config = config::load()?;
-process_with_config(&config)?;
-
-// ❌ Don't reload config repeatedly
-fn process() {
-    let config = config::load().unwrap(); // Bad!
-    // ...
-}
-```
-
-### 3. User Feedback
-
-```rust
-// ✅ Provide progress indicators
-p::step(1, 3, "Loading configuration...");
-p::step(2, 3, "Processing data...");
-p::step(3, 3, "Saving results...");
-
-// ✅ Show helpful error messages
-anyhow::bail!(
-    "Wallet '{}' not found.\n\nTry: starforge wallet list",
-    name
-);
-```
-
-### 4. Testing
-
-```rust
-// ✅ Test edge cases
-#[test]
-fn test_empty_input() { /* ... */ }
-
-#[test]
-fn test_invalid_input() { /* ... */ }
-
-#[test]
-fn test_boundary_conditions() { /* ... */ }
-
-// ✅ Use descriptive test names
-#[test]
-fn creates_wallet_with_encrypted_key_when_encrypt_flag_is_true() {
-    // ...
-}
-```
-
----
-
-## Contributing Guidelines
-
-### Pull Request Process
-
-1. **Fork** the repository
-2. **Create** a feature branch
-3. **Make** your changes
-4. **Test** thoroughly
-5. **Document** your changes
-6. **Submit** a pull request
-
-### PR Checklist
-
-- [ ] Code follows style guide
-- [ ] Tests added/updated
-- [ ] Documentation updated
-- [ ] Commit messages follow convention
-- [ ] No merge conflicts
-- [ ] CI passes
-
-### Commit Message Convention
-
-```
-<type>(<scope>): <subject>
-
-<body>
-
-<footer>
-```
-
-Types:
-
-- `feat`: New feature
-- `fix`: Bug fix
-- `docs`: Documentation
-- `style`: Formatting
-- `refactor`: Code restructuring
-- `test`: Adding tests
-- `chore`: Maintenance
-
-Examples:
-
-```
-feat(wallet): add hardware wallet support
-
-Implements Ledger and Trezor integration for secure key storage.
-
-Closes #123
-```
-
----
-
-## Resources
-
-### Documentation
-
-- [Rust Book](https://doc.rust-lang.org/book/)
-- [Rust API Guidelines](https://rust-lang.github.io/api-guidelines/)
-- [Stellar Documentation](https://developers.stellar.org/)
-- [Soroban Documentation](https://soroban.stellar.org/)
-
-### Tools
-
-- [rust-analyzer](https://rust-analyzer.github.io/) - IDE support
-- [clippy](https://github.com/rust-lang/rust-clippy) - Linter
-- [rustfmt](https://github.com/rust-lang/rustfmt) - Formatter
-- [cargo-edit](https://github.com/killercup/cargo-edit) - Dependency management
-
-### Community
-
-- [Stellar Discord](https://discord.gg/stellar)
-- [Rust Users Forum](https://users.rust-lang.org/)
-- [GitHub Discussions](https://github.com/YOUR_USERNAME/starforge/discussions)
-
----
-
-## Getting Help
-
-- **Issues**: [GitHub Issues](https://github.com/YOUR_USERNAME/starforge/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/YOUR_USERNAME/starforge/discussions)
-- **Discord**: Join the Stellar Discord
-- **Email**: maintainer@example.com
-
----
-
-**Happy Coding! 🚀**
diff --git a/DEVELOPMENT_WORKFLOW.md b/DEVELOPMENT_WORKFLOW.md
deleted file mode 100644
index 7c6d392c..00000000
--- a/DEVELOPMENT_WORKFLOW.md
+++ /dev/null
@@ -1,776 +0,0 @@
-# Development Workflow: Formatting and Linting Guide
-
-This document provides comprehensive guidance on the formatting and linting requirements for contributing to StarForge. Following these practices ensures code quality, consistency, and smooth CI/CD pipeline execution.
-
-## Table of Contents
-
-- [Overview](#overview)
-- [Code Formatting](#code-formatting)
-- [Running Clippy Checks](#running-clippy-checks)
-- [CI/CD Enforcement](#cicd-enforcement)
-- [Common Issues and Fixes](#common-issues-and-fixes)
-- [Integration with CONTRIBUTING.md](#integration-with-contributingmd)
-- [Best Practices](#best-practices)
-- [Quick Reference](#quick-reference)
-
----
-
-## Overview
-
-StarForge uses industry-standard Rust tools to maintain code quality:
-
-- **rustfmt**: Automatic code formatting (enforces consistent style)
-- **clippy**: Linter for catching common mistakes and improving code quality
-- **cargo-deny**: Dependency security verification
-
-All three are **required to pass** before pull requests can be merged. This document explains how to run these checks locally and fix any issues.
-
-### Why These Tools Matter
-
-- **Consistency**: All code follows the same style, making it easier to read and review
-- **Quality**: Clippy catches bugs and suggests improvements automatically
-- **Security**: Cargo-deny prevents vulnerable dependencies from entering the codebase
-- **CI Reliability**: Running checks locally saves time by catching issues before pushing
-
----
-
-## Code Formatting
-
-### What is rustfmt?
-
-`rustfmt` is the Rust community's standard code formatter. It automatically reformats code to follow Rust style guidelines (RFC 1440). Using it ensures all code in StarForge follows the same conventions.
-
-### Formatting Locally (Before Committing)
-
-**Format all code:**
-
-```bash
-cargo fmt --all
-```
-
-This command:
-- Formats all Rust files in the project
-- Modifies files in-place
-- Follows Rust's standard style guide
-- Takes approximately 1-2 seconds
-
-**Check formatting without modifying files:**
-
-```bash
-cargo fmt --all --check
-```
-
-This is useful if you want to see what would be changed without applying changes. Output shows which files need formatting.
-
-### When to Format
-
-Format your code **before every commit**:
-
-```bash
-# Make changes to your code
-vim src/commands/wallet.rs
-
-# Format the code
-cargo fmt --all
-
-# Stage and commit
-git add .
-git commit -m "feat: add wallet encryption support"
-```
-
-### Configuration
-
-StarForge uses rustfmt's default configuration. If you want to customize rustfmt behavior locally for development, create a `.rustfmt.toml` file in the project root. However, the CI pipeline uses the default configuration, so ensure your local settings don't conflict with standard Rust style.
-
-### Common Formatting Issues
-
-**Issue: Lines are too long or indentation seems wrong**
-
-Solution: Run `cargo fmt --all` - it will automatically fix these issues.
-
-**Issue: I made many formatting changes when I just wanted to fix a bug**
-
-Prevention: Always run formatting as a separate commit step. If this happens, you can unstage the formatting changes and create separate commits:
-
-```bash
-# If you haven't committed yet:
-git diff --name-only | xargs rustfmt --check
-# Then commit formatting separately from logic changes
-```
-
-**Issue: My IDE reformatted code differently than rustfmt**
-
-Solution: Always run `cargo fmt --all` before committing. Most IDEs have rustfmt integration:
-- **VS Code**: Install "rust-analyzer" extension, which uses rustfmt
-- **IntelliJ**: Settings → Languages & Frameworks → Rust → Rustfmt
-- **Vim/Neovim**: Use `rust.vim` or configure with rust-analyzer
-
----
-
-## Running Clippy Checks
-
-### What is Clippy?
-
-Clippy is a Rust linter that catches common mistakes, improves code quality, and suggests better patterns. It analyzes code for:
-
-- Performance issues
-- Unnecessary allocations
-- Incorrect use of standard library functions
-- Code style improvements
-- Potential bugs
-
-### Clippy Checks Locally
-
-**Run Clippy with warnings treated as errors:**
-
-```bash
-cargo clippy -- -D warnings
-```
-
-The `-D warnings` flag converts all Clippy warnings into errors, matching the CI behavior. If Clippy finds any issues, the command will fail and list them.
-
-**Run Clippy in verbose mode (see detailed explanations):**
-
-```bash
-cargo clippy --verbose -- -D warnings
-```
-
-**Fix Clippy warnings (when applicable):**
-
-Some Clippy suggestions can be automatically fixed:
-
-```bash
-cargo clippy --fix -- -D warnings
-```
-
-This will attempt to automatically fix issues. Always review the changes:
-
-```bash
-git diff
-```
-
-**Run Clippy on specific modules:**
-
-```bash
-# Check a single crate
-cargo clippy -p starforge -- -D warnings
-
-# Check with specific features
-cargo clippy --all-features -- -D warnings
-```
-
-### When to Run Clippy
-
-Run Clippy **before every commit**:
-
-```bash
-# Make changes to your code
-vim src/utils/config.rs
-
-# Run Clippy checks
-cargo clippy -- -D warnings
-
-# If there are warnings, fix them or suppress intentionally
-# Then commit
-git add .
-git commit -m "fix: improve config loading error handling"
-```
-
-### Suppressing Clippy Warnings (When Necessary)
-
-Sometimes, a Clippy suggestion isn't applicable. You can suppress warnings with the `#[allow(...)]` attribute:
-
-```rust
-// Suppress a specific warning for a function
-#[allow(clippy::too_many_arguments)]
-pub fn complex_function(arg1: i32, arg2: String, arg3: bool, /* ... */) {
-    // Implementation
-}
-```
-
-Or for a whole module:
-
-```rust
-#![allow(clippy::module_name_repetitions)]
-
-// Module code follows
-```
-
-**Important**: Always add a comment explaining why the warning is being suppressed:
-
-```rust
-// SAFETY: This unsafe block is necessary for interop with C library.
-// We validate all inputs before passing to C functions.
-#[allow(unsafe_code)]
-unsafe fn ffi_call(ptr: *const u8) {
-    // Implementation
-}
-```
-
-### Common Clippy Issues and Fixes
-
-**Issue: "this argument is passed by value, but by reference would be cheaper"**
-
-```rust
-// Clippy warning:
-pub fn process_data(data: Vec<u8>) {
-    println!("{:?}", data);
-}
-
-// Fix:
-pub fn process_data(data: &[u8]) {
-    println!("{:?}", data);
-}
-```
-
-**Issue: "use of `clone` on copy type"**
-
-```rust
-// Clippy warning:
-let x = 5_i32;
-let y = x.clone(); // i32 implements Copy
-
-// Fix:
-let x = 5_i32;
-let y = x; // Just assign it
-```
-
-**Issue: "this function is never used"**
-
-If the function is intentionally public (e.g., part of a library API), suppress with:
-
-```rust
-#[allow(dead_code)]
-pub fn library_function() {
-    // Implementation
-}
-```
-
-**Issue: "needless borrow"**
-
-```rust
-// Clippy warning:
-let x = vec![1, 2, 3];
-let y = &x; // Unnecessary borrow in some contexts
-
-// Fix (depends on context):
-let y = &x; // Keep if intentional
-// Or pass x directly if y doesn't need to be a reference
-```
-
----
-
-## CI/CD Enforcement
-
-### GitHub Actions Workflow
-
-StarForge uses GitHub Actions to enforce code quality. The CI pipeline is defined in `.github/workflows/ci.yml` and runs on every push and pull request.
-
-### CI Jobs and What They Check
-
-#### 1. **Rustfmt Job** (`fmt`)
-- **Runs**: On every push and PR
-- **Command**: `cargo fmt --all --check`
-- **Status**: MUST PASS before merge
-- **What it does**: Verifies all code is properly formatted
-- **Failure**: If any files are not formatted, the job fails and lists the files
-- **How to fix**: Run `cargo fmt --all` locally and push changes
-
-#### 2. **Clippy Job** (`test` - includes Clippy)
-- **Runs**: On every push and PR
-- **Command**: `cargo clippy --locked -- -D warnings`
-- **Status**: MUST PASS before merge
-- **What it does**: Runs linter to catch bugs and quality issues
-- **Failure**: If Clippy finds warnings, the job fails with details
-- **How to fix**: Fix issues locally with `cargo clippy -- -D warnings`, suppress if necessary, and push
-
-#### 3. **Cargo Deny Job** (`deny`)
-- **Runs**: On every push and PR
-- **Command**: Checks dependencies for security vulnerabilities
-- **Status**: MUST PASS before merge
-- **What it does**: Scans all dependencies for known security issues
-- **Failure**: If vulnerable dependencies are detected, the job fails
-- **How to fix**: Update vulnerable dependencies in `Cargo.toml`
-
-#### 4. **Build and Test Job** (`test`)
-- **Runs**: On every push and PR
-- **Command**: `cargo build --locked` and `cargo test --locked`
-- **Status**: MUST PASS before merge
-- **What it does**: Compiles code and runs all tests
-- **Failure**: If code doesn't compile or tests fail
-- **How to fix**: Fix compilation errors or failing tests locally
-
-#### 5. **Smoke Tests Job** (`smoke`)
-- **Runs**: On every push and PR
-- **Command**: Runs CLI smoke tests and shell integration tests
-- **Status**: MUST PASS before merge
-- **What it does**: Verifies the CLI works end-to-end
-- **Failure**: If CLI functionality is broken
-- **How to fix**: Test CLI locally with `cargo test --test cli_smoke`
-
-### Workflow Summary
-
-```
-┌─────────────────────────────────────────┐
-│  You: Push Code to GitHub               │
-└──────────────────┬──────────────────────┘
-                   │
-                   ▼
-        ┌─────────────────────────────┐
-        │  CI Pipeline Starts         │
-        └─────────────────────────────┘
-                   │
-        ┌──────────┼──────────┬──────────┬───────────┐
-        │          │          │          │           │
-        ▼          ▼          ▼          ▼           ▼
-    ┌────────┐ ┌───────┐ ┌──────────┐ ┌──────┐  ┌───────┐
-    │rustfmt│ │clippy │ │cargo-deny│ │build │  │ smoke │
-    └────────┘ └───────┘ └──────────┘ └──────┘  └───────┘
-        │          │          │          │           │
-        └──────────┼──────────┼──────────┼───────────┘
-                   │
-                   ▼
-        ┌─────────────────────────────┐
-        │  All Jobs Passed?           │
-        └──────────┬──────────────────┘
-                   │
-        ┌──────────┴──────────┐
-        │                     │
-    YES │                 NO  │
-        │                     │
-        ▼                     ▼
-    ┌───────────┐      ┌────────────────┐
-    │  Approved │      │ Fix Issues &   │
-    │  for Merge│      │ Push Again      │
-    └───────────┘      └────────────────┘
-```
-
-### How to View CI Status
-
-1. **On GitHub**: Go to your PR and scroll to "Checks" section
-2. **View Details**: Click "Details" on any failed check to see the error message
-3. **Re-run Jobs**: After fixing issues, push again - CI runs automatically
-4. **Local Preview**: Run all checks locally before pushing (see Quick Reference)
-
----
-
-## Common Issues and Fixes
-
-### Issue: Formatting Check Fails in CI
-
-**Error in CI**: `cargo fmt --all --check` fails
-
-**Local Reproduction**:
-```bash
-cargo fmt --all --check
-```
-
-**Fix**:
-```bash
-# Apply formatting
-cargo fmt --all
-
-# Verify it's fixed
-cargo fmt --all --check
-
-# Commit the changes
-git add .
-git commit -m "style: apply rustfmt formatting"
-git push
-```
-
-### Issue: Clippy Warnings in CI
-
-**Error in CI**: `cargo clippy -- -D warnings` reports warnings
-
-**Local Reproduction**:
-```bash
-cargo clippy -- -D warnings
-```
-
-**Fix Option 1: Improve the code**
-```bash
-# Review the warning and understand it
-# Fix the issue in the code
-cargo clippy -- -D warnings  # Verify it passes
-git add .
-git commit -m "fix: address clippy warning about X"
-```
-
-**Fix Option 2: Suppress if intentional**
-```rust
-#[allow(clippy::specific_warning_name)]
-// Your code that triggers the warning
-```
-
-Then document why:
-```bash
-git add .
-git commit -m "refactor: suppress clippy warning with explanation"
-```
-
-### Issue: Inconsistent Formatting Between Local and CI
-
-**Problem**: Your code passes `cargo fmt --all --check` locally but fails in CI
-
-**Cause**: Different rustfmt version or corrupted local cache
-
-**Fix**:
-```bash
-# Update Rust toolchain
-rustup update
-
-# Clean build cache
-cargo clean
-
-# Run format check again
-cargo fmt --all --check
-```
-
-### Issue: Clippy Suggests Conflicting Fixes
-
-**Problem**: Two Clippy warnings suggest contradictory changes
-
-**Fix**:
-1. Run `cargo clippy --fix -- -D warnings` to auto-fix
-2. Review the changes carefully: `git diff`
-3. If conflicts exist, manually resolve by choosing the better option
-4. Add comments explaining the decision
-5. Run Clippy again to verify
-
-### Issue: Changes to Cargo.lock Break CI
-
-**Problem**: CI fails with "dependency not found" or similar
-
-**Cause**: `Cargo.lock` was modified or is out of sync
-
-**Fix**:
-```bash
-# Ensure Cargo.lock is in sync
-cargo update
-
-# Or, if you're supposed to use --locked:
-cargo build --locked
-cargo test --locked
-
-# Commit the updated lock file
-git add Cargo.lock
-git commit -m "chore: update Cargo.lock"
-```
-
----
-
-## Integration with CONTRIBUTING.md
-
-This document is a detailed supplement to the **Code Quality** section in [CONTRIBUTING.md](CONTRIBUTING.md).
-
-### Key Points from CONTRIBUTING.md
-
-The main contribution guide mentions:
-
-1. **Formatting** (Line 295):
-   ```
-   ## Code Quality
-   
-   ### Formatting
-   
-   Use Rust's built-in formatter:
-   
-   cargo fmt --all
-   
-   This is automatically checked in CI.
-   ```
-
-2. **Linting** (Line 309):
-   ```
-   ### Linting
-   
-   Use Clippy to catch common mistakes:
-   
-   cargo clippy -- -D warnings
-   
-   Fix any warnings before submitting a PR.
-   ```
-
-3. **Before Submitting a PR** (Line 350):
-   - [ ] Run `cargo fmt --all`
-   - [ ] Run `cargo clippy -- -D warnings`
-
-### How This Document Extends CONTRIBUTING.md
-
-| Topic | CONTRIBUTING.md | DEVELOPMENT_WORKFLOW.md |
-|-------|-----------------|------------------------|
-| Basic commands | ✓ | ✓ + detailed examples |
-| When to run | ✓ | ✓ + integration steps |
-| How to fix issues | ✓ | ✓ + specific examples |
-| CI/CD details | - | ✓ comprehensive |
-| Suppressing warnings | - | ✓ how and why |
-| IDE integration | - | ✓ setup guides |
-| Troubleshooting | - | ✓ common problems |
-
-### The Complete Workflow
-
-1. **Before Coding**: See CONTRIBUTING.md for setup and prerequisites
-2. **During Development**: Use this document to run checks regularly
-3. **Before Commit**: Run formatting and Clippy checks (this doc)
-4. **Before Push**: Run full test suite (CONTRIBUTING.md)
-5. **Submit PR**: Follow checklist in CONTRIBUTING.md
-6. **CI Verification**: Monitor checks (this doc)
-
----
-
-## Best Practices
-
-### 1. **Format Early, Format Often**
-
-Don't wait until the last minute to format. Run `cargo fmt --all` after every significant change:
-
-```bash
-# After implementing a feature
-cargo fmt --all
-
-# Before moving to the next feature
-cargo fmt --all
-```
-
-### 2. **Use Pre-commit Hooks (Optional)**
-
-Automatically format and check code before committing:
-
-```bash
-# Create a pre-commit hook
-cat > .git/hooks/pre-commit << 'EOF'
-#!/bin/bash
-set -e
-
-echo "Running format check..."
-cargo fmt --all --check
-
-echo "Running Clippy..."
-cargo clippy -- -D warnings
-
-echo "All checks passed!"
-EOF
-
-chmod +x .git/hooks/pre-commit
-```
-
-Now, before every commit, these checks run automatically.
-
-### 3. **Read Clippy's Explanations**
-
-Clippy doesn't just report warnings - it explains them:
-
-```bash
-cargo clippy -- -D warnings 2>&1 | head -50
-```
-
-Take time to understand the warnings. They're usually teaching you something about Rust best practices.
-
-### 4. **Keep Your Local Toolchain Updated**
-
-Clippy and rustfmt improve over time:
-
-```bash
-rustup update stable
-```
-
-Run this monthly to stay current.
-
-### 5. **Separate Formatting from Logic Changes**
-
-Create separate commits for formatting and logic:
-
-```bash
-# Commit 1: Add feature
-git commit -m "feat: add wallet encryption"
-
-# Commit 2: Fix formatting (if needed)
-git commit -m "style: apply rustfmt formatting"
-```
-
-This makes code review easier and git history clearer.
-
-### 6. **Comment Your Suppressions**
-
-If you suppress a Clippy warning, always explain why:
-
-```rust
-// SAFETY: This is safe because we validate inputs in the caller.
-// The caller ensures `ptr` is a valid, aligned pointer to initialized data.
-#[allow(unsafe_code)]
-unsafe fn deserialize(ptr: *const u8) {
-    // ...
-}
-```
-
-### 7. **Test After Clippy --fix**
-
-Auto-fixes are usually good but not always perfect:
-
-```bash
-cargo clippy --fix -- -D warnings
-cargo test  # Verify the fixes don't break anything
-git diff    # Review the changes carefully
-```
-
----
-
-## Quick Reference
-
-### One-Liner Before Every Commit
-
-```bash
-cargo fmt --all && cargo clippy -- -D warnings && cargo test
-```
-
-This command:
-1. Formats all code
-2. Runs linter checks
-3. Runs tests
-
-Stop after the first error so you can fix it.
-
-### Pre-PR Checklist (Copy-Paste Ready)
-
-```bash
-# 1. Format code
-cargo fmt --all
-
-# 2. Run Clippy
-cargo clippy -- -D warnings
-
-# 3. Run tests
-cargo test
-
-# 4. Run smoke tests
-cargo test --test cli_smoke
-
-# 5. Check formatting is correct
-cargo fmt --all --check
-
-# 6. Check Clippy passes
-cargo clippy -- -D warnings
-
-echo "✓ All checks passed! Ready to push."
-```
-
-### Debug Check Failures
-
-```bash
-# See exactly what rustfmt would change
-cargo fmt --all --check -v
-
-# See detailed Clippy output
-cargo clippy -- -D warnings --message-format=json
-
-# Run specific test to debug
-cargo test --lib wallet -- --nocapture
-```
-
-### Useful Cargo Flags
-
-| Flag | Meaning |
-|------|---------|
-| `--all` | All packages in workspace |
-| `--locked` | Use exact versions from Cargo.lock |
-| `--check` | Don't modify, just check |
-| `-D warnings` | Treat warnings as errors |
-| `--fix` | Auto-fix issues (when available) |
-| `--verbose` | Show detailed output |
-| `-- -D warnings` | Clippy-specific options |
-
-### IDE Setup
-
-**VS Code (Recommended)**:
-1. Install "rust-analyzer" extension
-2. Settings → Extensions → Rust-analyzer → Formatting enabled ✓
-3. Format on Save: Enable in settings.json
-
-**IntelliJ IDEA**:
-1. Settings → Languages & Frameworks → Rust → Rustfmt
-2. Run rustfmt on Save ✓
-
-**Vim/Neovim**:
-```vim
-" Add to init.vim or init.lua
-autocmd BufWritePost *.rs silent !cargo fmt %
-autocmd BufRead,BufNewFile *.rs :set tabstop=4 softtabstop=4 shiftwidth=4
-```
-
----
-
-## Troubleshooting
-
-### Q: How often should I format my code?
-
-**A**: Before every commit. You can:
-- Run manually: `cargo fmt --all`
-- Set up pre-commit hook (see Best Practices)
-- Configure your IDE to format on save
-
-### Q: Can I ignore a Clippy warning?
-
-**A**: Only if necessary, and only with:
-```rust
-#[allow(clippy::warning_name)]  // Add comment explaining why
-```
-
-Don't just disable all warnings.
-
-### Q: My editor formatted code differently than rustfmt. What do I do?
-
-**A**: Always run `cargo fmt --all` before committing. This ensures consistency across all developer machines.
-
-### Q: Does Clippy have performance impact on my code?
-
-**A**: No. Clippy only analyzes your code; it doesn't change runtime behavior unless you accept its suggestions.
-
-### Q: Can I run formatting in my IDE instead of command line?
-
-**A**: Yes! Most IDEs support rustfmt integration. But always run `cargo fmt --all --check` locally before pushing to ensure consistency.
-
-### Q: What if CI fails for formatting but I didn't change that code?
-
-**A**: If formatting issues exist in the base branch:
-1. Run `cargo fmt --all` on the feature branch
-2. This fixes all formatting issues
-3. The formatting commit should be separate from your feature work
-
-### Q: How do I suppress a warning for an entire file?
-
-**A**: Add at the top of the file:
-```rust
-#![allow(clippy::warning_name)]
-
-// Rest of file
-```
-
-But use sparingly.
-
----
-
-## Resources
-
-- [Rustfmt Documentation](https://rust-lang.github.io/rustfmt/)
-- [Clippy Documentation](https://doc.rust-lang.org/clippy/)
-- [Rust API Guidelines](https://rust-lang.github.io/api-guidelines/)
-- [StarForge CONTRIBUTING.md](CONTRIBUTING.md)
-- [StarForge DEVELOPER_GUIDE.md](DEVELOPER_GUIDE.md)
-
----
-
-## Summary
-
-| Step | Command | When |
-|------|---------|------|
-| Format code | `cargo fmt --all` | After each feature |
-| Check format | `cargo fmt --all --check` | Before commit |
-| Run Clippy | `cargo clippy -- -D warnings` | Before commit |
-| Auto-fix Clippy | `cargo clippy --fix -- -D warnings` | When applicable |
-| Run tests | `cargo test` | Before push |
-| Check all | All of above | Before opening PR |
-| Monitor CI | GitHub Actions | After push |
-| Fix CI failures | Run locally and push | Immediately |
-
-Follow this workflow to ensure smooth contribution to StarForge!
diff --git a/DOCKER_SETUP.md b/DOCKER_SETUP.md
deleted file mode 100644
index 6427d98c..00000000
--- a/DOCKER_SETUP.md
+++ /dev/null
@@ -1,211 +0,0 @@
-# Docker Setup Guide
-
-StarForge provides Docker and Docker Compose configurations for reproducible development and testing environments.
-
-## Quick Start
-
-### Prerequisites
-- Docker 20.10+
-- Docker Compose 2.0+ (for multi-container workflows)
-
-### Running StarForge with Docker
-
-**Execute a single command:**
-```bash
-docker run --rm ghcr.io/nanle-code/starforge:latest <command>
-```
-
-**Example: Get version**
-```bash
-docker run --rm ghcr.io/nanle-code/starforge:latest --version
-```
-
-**Example: Deploy a contract**
-```bash
-docker run --rm -v $(pwd):/workspace ghcr.io/nanle-code/starforge:latest deploy --wasm ./contract.wasm --network testnet
-```
-
-## Development Setup
-
-### Building Locally
-
-**Build production image:**
-```bash
-docker build -t starforge:local .
-```
-
-**Build development image:**
-```bash
-docker build -f Dockerfile.dev -t starforge:dev .
-```
-
-### Using Docker Compose
-
-Docker Compose sets up StarForge with a local Stellar + Soroban environment.
-
-**Start all services:**
-```bash
-docker-compose up -d
-```
-
-This brings up:
-- `stellar-testnet`: Local Stellar/Soroban instance on `http://localhost:8000`
-- `soroban-rpc`: Dedicated Soroban RPC on `http://localhost:8001`
-- `starforge`: Development container with live editing
-
-**Run commands:**
-```bash
-# Execute a command in the starforge container
-docker-compose run --rm starforge starforge deploy --wasm ./token.wasm --network docker-testnet
-
-# Interactive shell
-docker-compose run --rm starforge bash
-
-# Live development (edits to code auto-reload)
-docker-compose run --rm starforge cargo run -- <command>
-```
-
-**Stop services:**
-```bash
-docker-compose down
-```
-
-### Development Workflow
-
-1. **Start containers:**
-   ```bash
-   docker-compose up -d
-   ```
-
-2. **Edit code** (changes reflect immediately due to volume mount)
-
-3. **Test in container:**
-   ```bash
-   docker-compose run --rm starforge cargo test
-   ```
-
-4. **Debug with hot-reload:**
-   ```bash
-   docker-compose run --rm starforge cargo run -- wallet list
-   ```
-
-5. **Stop when done:**
-   ```bash
-   docker-compose down
-   ```
-
-## Image Variants
-
-### Production Image (`Dockerfile`)
-- **Size**: ~100MB (optimized with multi-stage build)
-- **Base**: `debian:bookworm-slim`
-- **Includes**: Binary only, Stellar CLI
-- **Use case**: Running deployed versions, CI/CD pipelines
-- **Command**: `starforge <args>` (default entrypoint)
-
-### Development Image (`Dockerfile.dev`)
-- **Size**: ~2GB (includes Rust toolchain)
-- **Base**: `rust:1-bookworm`
-- **Includes**: Full build environment, cargo
-- **Use case**: Development, testing, contributions
-- **Command**: `cargo run -- <args>`
-
-## Environment Variables
-
-All StarForge environment variables are supported in containers:
-
-```bash
-# Example with custom RPC URL
-docker run \
-  -e STELLAR_RPC_URL=http://soroban-rpc:8000 \
-  -e STELLAR_NETWORK=local \
-  starforge:local deploy --wasm ./contract.wasm
-```
-
-## Common Workflows
-
-### Deploy to Local Network
-```bash
-docker-compose run --rm starforge \
-  starforge deploy \
-  --wasm ./target/wasm32-unknown-unknown/release/contract.wasm \
-  --network docker-testnet
-```
-
-### Run Test Suite in Container
-```bash
-docker-compose run --rm starforge cargo test --locked
-```
-
-### Create a Plugin
-```bash
-docker-compose run --rm starforge \
-  starforge plugin create my-plugin
-```
-
-### Hardware Wallet Testing (Ledger)
-```bash
-# Note: USB passthrough required
-docker run \
-  --device /dev/bus/usb \
-  -e STELLAR_HARDWARE_WALLET=ledger \
-  starforge:local wallet import --hardware ledger
-```
-
-## Troubleshooting
-
-### Build fails with "SSL error"
-Ensure you're connected to the internet. The Dockerfile installs Stellar CLI via a remote script.
-
-### Cargo cache not persisting
-Volume `cargo-cache` is defined in `docker-compose.yml` for cache persistence. Clean it if needed:
-```bash
-docker volume rm starforge_cargo-cache
-```
-
-### Permission denied on mounted volumes
-Use `--user` flag when needed:
-```bash
-docker-compose run --rm --user root starforge bash
-```
-
-### Network connectivity in containers
-Services communicate via hostnames defined in `docker-compose.yml`:
-- StarForge → Soroban RPC: `http://soroban-rpc:8000`
-- Soroban RPC → Stellar: Uses internal Stellar quickstart networking
-
-### Container exits immediately
-Check logs:
-```bash
-docker-compose logs starforge
-```
-
-## Best Practices
-
-1. **Use `--rm` flag**: Automatically removes containers after execution
-2. **Mount volumes correctly**: `-v $(pwd):/workspace` ensures file access
-3. **Use `docker-compose`**: Provides consistent multi-container environment
-4. **Cache dependencies**: Dev image pre-builds dependencies to speed up iterations
-5. **Pin versions**: Use specific image tags in production (avoid `:latest`)
-
-## Contributing
-
-When contributing, use the development image and Docker Compose:
-
-```bash
-# Build from your branch
-docker build -f Dockerfile.dev -t starforge:dev-branch .
-
-# Test changes
-docker-compose run --rm starforge cargo test
-
-# Run linter and formatter checks
-docker-compose run --rm starforge cargo fmt --all --check
-docker-compose run --rm starforge cargo clippy --locked
-```
-
-## See Also
-
-- [DEVELOPER_GUIDE.md](DEVELOPER_GUIDE.md) - Full development setup
-- [README.md](README.md) - General project information
-- [docker-compose.yml](docker-compose.yml) - Service configuration
diff --git a/Documentation.md b/Documentation.md
deleted file mode 100644
index 8eda8a40..00000000
--- a/Documentation.md
+++ /dev/null
@@ -1,323 +0,0 @@
-# ⚡ StarForge Documentation
-
-> Complete documentation for StarForge - A developer productivity CLI for Stellar and Soroban workflows built in Rust.
-
-## Documentation Index
-
-This is the main documentation hub for StarForge. For specific topics, see:
-
-- **[README.md](README.md)** - Quick start and basic usage
-- **[ARCHITECTURE.md](ARCHITECTURE.md)** - System architecture and design
-- **[DEVELOPER_GUIDE.md](DEVELOPER_GUIDE.md)** - Contributing and development guide
-- **[API_REFERENCE.md](API_REFERENCE.md)** - Complete command reference
-- **[docs/COMMAND_REFERENCE.md](docs/COMMAND_REFERENCE.md)** - Navigable CLI command index with examples
-- **[TEMPLATE_MARKETPLACE.md](TEMPLATE_MARKETPLACE.md)** - Template marketplace feature
-- **[QUICK_START_TEMPLATES.md](QUICK_START_TEMPLATES.md)** - Template quick start
-- **[IMPLEMENTATION_SUMMARY.md](IMPLEMENTATION_SUMMARY.md)** - Recent implementation details
-
----
-
-# ⚡ StarForge Overview
-
-> A developer productivity CLI for Stellar and Soroban workflows — built in Rust.
-
-![License: MIT](https://img.shields.io/badge/License-MIT-cyan.svg)
-![Language: Rust](https://img.shields.io/badge/Language-Rust-orange.svg)
-![Network: Stellar](https://img.shields.io/badge/Network-Stellar-blue.svg)
-![Status: Active](https://img.shields.io/badge/Status-Active-green.svg)
-![Stellar Wave](https://img.shields.io/badge/Stellar-Wave%20Program-blueviolet.svg)
-
----
-
-## Architecture Overview
-
-StarForge is built with a modular architecture that separates concerns into distinct layers:
-
-### System Layers
-
-```
-┌─────────────────────────────────────────┐
-│         User Interface (CLI)            │
-│         - Command parsing               │
-│         - Output formatting             │
-└──────────────┬──────────────────────────┘
-               │
-┌──────────────▼──────────────────────────┐
-│         Command Layer                   │
-│         - Business logic                │
-│         - Input validation              │
-│         - Command orchestration         │
-└──────────────┬──────────────────────────┘
-               │
-┌──────────────▼──────────────────────────┐
-│         Utility Layer                   │
-│         - Configuration management      │
-│         - API clients (Horizon/Soroban) │
-│         - Cryptography                  │
-│         - Template system               │
-└──────────────┬──────────────────────────┘
-               │
-┌──────────────▼──────────────────────────┐
-│         External Systems                │
-│         - Stellar Horizon API           │
-│         - Soroban RPC                   │
-│         - File System                   │
-│         - Hardware Wallets              │
-└─────────────────────────────────────────┘
-```
-
-For detailed architecture documentation, see [ARCHITECTURE.md](ARCHITECTURE.md).
-
----
-
-## Overview
-
-**starforge** is a free, open-source command-line toolkit for developers building on the Stellar network. It brings together the most common Stellar and Soroban developer workflows — wallet management, project scaffolding, and contract deployment — into a single fast, ergonomic CLI.
-
-Think of it as the "Hardhat or Foundry" experience for the Stellar ecosystem, built in Rust for speed and reliability.
-
-This project is actively maintained and participates in the [Stellar Wave Program](https://www.drips.network/wave/stellar) on Drips — a monthly open-source contribution sprint where contributors earn rewards for merged pull requests.
-
----
-
-## Features
-
-### 🔑 Wallet Management
-Create and manage Stellar keypairs locally. Fund testnet accounts via Friendbot, list all saved wallets, inspect live on-chain balances, and securely store keys in `~/.starforge/config.toml`.
-
-### ◻ Project Scaffolding
-Scaffold new Soroban smart contract projects from battle-tested templates with one command. Available templates: `hello-world`, `token`, `nft`, and `voting`. Also scaffolds full Stellar dApp frontends (Vite + React).
-
-### 🚀 Contract Deployment
-Validate, size-check, and deploy compiled Soroban `.wasm` files to Testnet or Mainnet. Verifies account balance on-chain, calculates WASM hash, and generates the exact `stellar contract deploy` command to complete the deployment.
-
----
-
-## Installation
-
-### Prerequisites
-
-- Rust ≥ 1.80 ([install via rustup](https://rustup.rs))
-
-### Build from source
-
-```bash
-git clone https://github.com/YOUR_USERNAME/starforge.git
-cd starforge
-cargo build --release
-
-# Move the binary to your PATH
-cp target/release/starforge ~/.local/bin/
-# or on macOS:
-cp target/release/starforge /usr/local/bin/
-```
-
-### Verify installation
-
-```bash
-starforge --version
-# starforge 0.1.0
-
-starforge info
-```
-
----
-
-## Usage
-
-### Wallet commands
-
-```bash
-# Create a new keypair
-starforge wallet create alice
-
-# Create and fund immediately (testnet only)
-starforge wallet create deployer --fund
-
-# List all saved wallets
-starforge wallet list
-
-# Show wallet details + live balance
-starforge wallet show alice
-
-# Reveal secret key
-starforge wallet show alice --reveal
-
-# Fund an existing wallet via Friendbot
-starforge wallet fund alice
-
-# Remove a wallet
-starforge wallet remove alice
-```
-
-### Scaffold commands
-
-```bash
-# Scaffold a Soroban contract (hello-world template)
-starforge new contract my-contract
-
-# Scaffold with a specific template
-starforge new contract my-token --template token
-starforge new contract my-nft --template nft
-starforge new contract my-vote --template voting
-
-# Scaffold a Stellar dApp frontend (Vite + React)
-starforge new dapp my-dapp
-```
-
-### Deploy commands
-
-```bash
-# Deploy a compiled contract
-starforge deploy --wasm target/wasm32-unknown-unknown/release/my_contract.wasm
-
-# Deploy to mainnet using a specific wallet
-starforge deploy \
-  --wasm target/wasm32-unknown-unknown/release/my_contract.wasm \
-  --network mainnet \
-  --wallet deployer
-
-# Skip confirmation prompt (for CI)
-starforge deploy --wasm ./my_contract.wasm --yes
-```
-
-### Contract commands
-
-```bash
-# Inspect a deployed contract instance
-starforge contract inspect CCPYZFKEAXHHS5VVW5J45TOU7S2EODJ7TZNJIA5LKDVL3PESCES6FNCI
-
-# Inspect on a specific network
-starforge contract inspect CCPYZFKEAXHHS5VVW5J45TOU7S2EODJ7TZNJIA5LKDVL3PESCES6FNCI --network mainnet
-```
-
-### Environment info
-
-```bash
-starforge info
-```
-
----
-
-## Project Structure
-
-```
-starforge/
-├── Cargo.toml
-└── src/
-    ├── main.rs                  # CLI entry point + banner
-    ├── commands/
-    │   ├── mod.rs
-    │   ├── wallet.rs            # wallet create/list/show/fund/remove
-    │   ├── new.rs               # project scaffolding + templates
-    │   ├── contract.rs          # contract inspect + invoke
-    │   ├── deploy.rs            # contract deployment
-    │   └── info.rs              # environment info
-    └── utils/
-        ├── mod.rs
-        ├── config.rs            # ~/.starforge/config.toml read/write
-        ├── horizon.rs           # Horizon API + Friendbot HTTP calls
-        ├── soroban.rs           # Soroban RPC helpers
-        └── print.rs             # Consistent CLI output helpers
-```
-
----
-
-## Configuration
-
-starforge stores all data in `~/.starforge/config.toml`:
-
-```toml
-network = "testnet"
-
-[[wallets]]
-name = "alice"
-public_key = "GABC...XYZ"
-secret_key = "SABC...XYZ"
-network = "testnet"
-created_at = "2025-01-01T00:00:00Z"
-funded = true
-```
-
-> ⚠️ Secret keys are stored in plaintext. Do not use wallets containing real mainnet funds for development purposes.
-
----
-
-## Contract Templates
-
-| Template | Description |
-|----------|-------------|
-| `hello-world` | Basic contract with a `hello(to)` function. Great starting point. |
-| `token` | Fungible token scaffold with `initialize`, `mint`, `balance`, `transfer`. |
-| `nft` | Non-fungible token scaffold with `mint`, `owner_of`, `transfer`. |
-| `voting` | Proposal and voting contract with `create_proposal`, `vote`, `results`. |
-
-All templates include a working test suite and a README with build/deploy instructions.
-
----
-
-## Contributing
-
-This project participates in the **[Stellar Wave Program](https://www.drips.network/wave/stellar)** on Drips. Contributors who resolve issues during an active Wave earn Points that translate to real USDC rewards.
-
-**Read the [Terms & Rules](https://docs.drips.network/wave/terms-and-rules) before contributing.**
-
-### How to contribute
-
-1. Fork the repository
-2. Create a branch: `git checkout -b feat/your-feature`
-3. Make your changes and commit: `git commit -m "feat: description"`
-4. Push and open a Pull Request against `main`
-
-Please keep PRs scoped to a single issue and include a clear description of what changed and why.
-
----
-
-## Open Issues
-
-Issues labeled `Stellar Wave` are available for contributors during an active sprint.
-
-### 🟢 Trivial 
-
-- [ ] Add `--network` flag to `wallet create` to override the global default
-- [ ] Add `starforge wallet rename <old> <new>` command
-- [ ] Validate public key format before saving a wallet
-- [ ] Show wallet count and config path in `starforge wallet list`
-- [ ] Add `--quiet` flag to suppress the ASCII banner
-
-### 🟡 Medium 
-
-- [ ] Add `starforge network switch <testnet|mainnet>` command to update global config
-- [ ] Add `starforge wallet export` to output a wallet's public key as a QR code in the terminal
-- [ ] Encrypt secret keys at rest in config.toml using a user-provided passphrase
-- [ ] Add `starforge tx history <public-key>` to display recent transactions in the terminal
-
-### 🔴 High
-
-- [ ] Add `starforge contract invoke` to call a deployed Soroban contract function from the CLI
-- [ ] Add `starforge tx send` to build and submit a payment transaction
-- [ ] Add `starforge new contract` template generator — interactive prompts for custom contract scaffolding
-- [ ] Add shell completion support (`starforge completions bash|zsh|fish`)
-
----
-
-## Roadmap
-
-- **v0.1** — Wallet management, project scaffolding (4 templates), deploy flow ✅
-- **v0.2** — Network switch command, contract inspect, stronger wallet primitives
-- **v0.3** — Contract invocation, payment transactions, key encryption
-- **v1.0** — Full Soroban developer toolkit with interactive contract CLI
-
----
-
-## License
-
-MIT © 2025 — See [LICENSE](./LICENSE) for details.
-
----
-
-## Acknowledgements
-
-Built for the Stellar ecosystem.
-Participates in the [Stellar Wave Program](https://www.drips.network/wave/stellar) via [Drips](https://www.drips.network).
-Powered by the [Stellar Horizon API](https://developers.stellar.org/api/horizon) and [Soroban](https://soroban.stellar.org).
diff --git a/FUZZING_GUIDE.md b/FUZZING_GUIDE.md
new file mode 100644
index 00000000..5239943c
--- /dev/null
+++ b/FUZZING_GUIDE.md
@@ -0,0 +1,156 @@
+# Contract Fuzzing & Property-Based Testing Guide
+
+StarForge ships a built-in fuzzing engine plus `proptest` and `cargo-fuzz`
+integration for discovering edge cases and vulnerabilities in Soroban
+contracts.
+
+There are two complementary layers:
+
+1. **In-process engine** (`starforge fuzz ...`) — runs on stable Rust, no extra
+   tooling. Great for fast feedback and CI.
+2. **Guided fuzzing** (`cargo-fuzz` / libFuzzer) — coverage-guided, runs on
+   nightly. Lives in [`fuzz/`](fuzz/README.md).
+
+---
+
+## 1. Property-based testing
+
+Express an invariant; let the engine search for a counterexample and shrink it
+to a minimal reproducer.
+
+```bash
+# Run the built-in token-model suite (supply conservation, no underflow):
+starforge fuzz property --iterations 5000 --seed 42
+```
+
+Output on success:
+
+```
+Property-Based Testing
+  Suite                token transfer model (supply conservation)
+  Iterations           5000
+  Cases run            5000
+✓ All properties held across every generated input
+```
+
+When a property fails, the **minimal counterexample** and shrink-step count are
+printed so you can reproduce deterministically with the same `--seed`.
+
+### Writing your own properties
+
+`proptest`-based examples live in
+[`tests/contract_property_tests.rs`](tests/contract_property_tests.rs):
+
+```rust
+use proptest::prelude::*;
+use starforge::utils::fuzzing::TokenModel;
+
+proptest! {
+    #[test]
+    fn transfer_conserves_supply(from in 0u64..1_000_000, to in 0u64..1_000_000, amount in 0u64..2_000_000) {
+        let model = TokenModel { from_balance: from, to_balance: to };
+        let before = model.total();
+        if let Ok(after) = model.transfer(amount) {
+            prop_assert_eq!(after.total(), before);
+        }
+    }
+}
+```
+
+The engine's own API (`run_property`, `ArgSpec`, `FuzzType`, `FuzzValue`) is
+public and can drive properties over typed `ScVal`-style inputs with shrinking.
+
+---
+
+## 2. WASM validator fuzzing
+
+Byte-mutate a real contract binary and confirm the validator rejects malformed
+input gracefully (never panics):
+
+```bash
+starforge fuzz wasm --wasm target/contract.wasm --iterations 5000 --seed 7
+```
+
+```
+  Rejected (graceful)  4983
+  Accepted             17
+  Crashes (panics)     0
+✓ Validator handled every mutated input gracefully
+```
+
+A non-zero crash count exits non-zero and prints crash-input prefixes for
+triage.
+
+---
+
+## 3. Mutation testing
+
+Generate source mutants (flipped operators, dropped `require_auth`, …) and
+report which would survive a well-written test suite — surviving mutants point
+at untested logic.
+
+```bash
+starforge fuzz mutate --source src/lib.rs
+starforge fuzz mutate --source src/lib.rs --json   # machine-readable
+```
+
+```
+Mutation Testing
+  Mutants generated    24
+  Mutation score       79.2%
+  Killed               19
+  Survived             5
+⚠ Surviving mutants indicate untested logic:
+  L48 [boundary] replace `<` with `<=`
+  ...
+```
+
+---
+
+## 4. Coverage reporting
+
+The fuzzing engine surfaces coverage signals through:
+
+- **Property pass/fail ratios** and shrink depth (`starforge fuzz property`).
+- **Accept/reject/crash counts** for validator fuzzing (`starforge fuzz wasm`).
+- **Mutation score** as a proxy for test-suite coverage (`starforge fuzz mutate`).
+
+For line/branch coverage of the fuzz harnesses themselves, use the standard
+toolchain, e.g. `cargo +nightly fuzz coverage fuzz_wasm_validator` or
+`cargo llvm-cov`.
+
+---
+
+## 5. Corpus management
+
+Interesting inputs are persisted under `~/.starforge/fuzz/`:
+
+```bash
+starforge fuzz corpus --list
+starforge fuzz corpus --show wasm-crashes
+```
+
+---
+
+## 6. Guided fuzzing (cargo-fuzz)
+
+See [`fuzz/README.md`](fuzz/README.md). Quick start:
+
+```bash
+cargo install cargo-fuzz
+cargo +nightly fuzz run fuzz_wasm_validator -- -max_total_time=60
+cargo +nightly fuzz run fuzz_state_diff     -- -max_total_time=60
+```
+
+---
+
+## 7. CI pipeline
+
+[`.github/workflows/fuzz.yml`](.github/workflows/fuzz.yml) runs:
+
+- **`property`** (blocking) — property-based + engine tests on stable.
+- **`cargo-fuzz`** (non-blocking, nightly + scheduled) — time-boxed guided
+  fuzzing of each target.
+
+This keeps fast, deterministic checks gating PRs while running deeper guided
+fuzzing on a schedule.
diff --git a/PLUGIN_TRUST.md b/PLUGIN_TRUST.md
deleted file mode 100644
index f1db51d5..00000000
--- a/PLUGIN_TRUST.md
+++ /dev/null
@@ -1,156 +0,0 @@
-# Plugin Trust Model and Lifecycle
-
-StarForge supports third-party plugins through a shared-library extension
-system. This document describes the trust model, compatibility requirements,
-and the full plugin lifecycle.
-
----
-
-## Trust levels
-
-Every installed plugin is assigned one of three trust levels at install time:
-
-| Level     | When assigned                                 | StarForge behaviour                                  |
-| --------- | --------------------------------------------- | ---------------------------------------------------- |
-| `local`   | Plugin installed via `--path` (no source URL) | Always loaded without warnings                       |
-| `trusted` | Source URL matches a known trusted prefix     | Loaded without warnings                              |
-| `unknown` | Source URL provided but not in the allow-list | Warning shown on load; `--force` required to install |
-
-### Trusted sources
-
-Trusted sources are defined in the StarForge configuration (`~/.starforge/config.toml`). By default, it includes:
-
-- `https://github.com/Nanle-code/starforge-*`
-- `https://github.com/StarForge-Labs/*`
-- `https://crates.io/crates/starforge-plugin-*`
-
-Any other source is `unknown` unless explicitly added to the `plugin_trust.trusted_sources` list in your configuration.
-
----
-
-## Compatibility requirements
-
-Plugins are native shared libraries loaded at runtime via `libloading`.
-Two compatibility checks run before a plugin is executed:
-
-1. **rustc ABI check** — the plugin must be compiled with the same Rust
-   toolchain version as StarForge. Mismatches cause undefined behaviour
-   and are rejected immediately.
-
-2. **Core version check** — the plugin's declared `core_version` major
-   number must match the running StarForge major version. A plugin built
-   for StarForge `0.x.y` is incompatible with StarForge `1.x.y`.
-
-Both checks produce actionable error messages that tell you exactly what
-to rebuild.
-
----
-
-## Plugin lifecycle
-
-### Install
-
-```bash
-# From a local path (always trusted)
-starforge plugin install my-plugin --path ./libstarforge_my_plugin.so
-
-# From a trusted source URL
-starforge plugin install my-plugin --source https://github.com/Nanle-code/starforge-my-plugin
-
-# From an unknown source (requires --force)
-starforge plugin install my-plugin \
-    --path ./libstarforge_my_plugin.so \
-    --source https://example.com/my-plugin \
-    --force
-```
-
-### List
-
-```bash
-starforge plugin list
-```
-
-Shows all installed plugins with their path, trust level, and source.
-
-### Load and execute
-
-```bash
-starforge plugin load          # loads and reports all installed plugins
-starforge my-plugin <args>     # execute a loaded plugin as an external subcommand
-```
-
-### Verify
-
-```bash
-starforge plugin verify              # verify all installed plugins
-starforge plugin verify my-plugin    # verify a specific plugin
-```
-
-Checks:
-
-- Library file exists on disk at the registered path
-- Trust level is `local` or `trusted`
-
-### Uninstall
-
-```bash
-starforge plugin uninstall my-plugin
-```
-
-Removes the plugin from the registry. The library file on disk is **not**
-deleted — remove it manually if desired.
-
----
-
-## Building a plugin
-
-Use the `starforge-plugin-sdk` crate:
-
-```toml
-# Cargo.toml
-[dependencies]
-starforge-plugin-sdk = { path = "crates/starforge-plugin-sdk" }
-
-[lib]
-crate-type = ["cdylib"]
-```
-
-```rust
-use starforge_plugin_sdk::{export_plugin, Plugin, PluginRegistrar};
-
-struct MyPlugin;
-
-impl Plugin for MyPlugin {
-    fn name(&self) -> &'static str { "my-plugin" }
-    fn version(&self) -> &'static str { "0.1.0" }
-    fn description(&self) -> &'static str { "My StarForge plugin" }
-    fn execute(&self, args: &[String]) -> Result<(), String> {
-        println!("Hello from my-plugin! args={:?}", args);
-        Ok(())
-    }
-}
-
-fn register(registrar: &mut dyn PluginRegistrar) {
-    registrar.register_plugin(Box::new(MyPlugin));
-}
-
-export_plugin!(register);
-```
-
-Build with the **same** Rust toolchain used to build StarForge:
-
-```bash
-cargo build --release
-```
-
----
-
-## Security considerations
-
-- Never load plugins from sources you do not control.
-- Prefer `--path` installs from artifacts you have reviewed.
-- The `--force` flag bypasses the source trust warning but does **not**
-  bypass the ABI/version compatibility checks — those run unconditionally.
-- There is no code-signing verification beyond source classification.
-  Use OS-level file integrity tools (e.g., `sha256sum`) if you need
-  cryptographic assurance.
diff --git a/QUICK_START_TEMPLATES.md b/QUICK_START_TEMPLATES.md
deleted file mode 100644
index 321f194b..00000000
--- a/QUICK_START_TEMPLATES.md
+++ /dev/null
@@ -1,209 +0,0 @@
-# Quick Start: Template Marketplace
-
-Get started with the StarForge Template Marketplace in 5 minutes.
-
-## Installation
-
-```bash
-# Build StarForge with the new feature
-cargo build --release
-
-# Add to PATH (optional)
-cp target/release/starforge ~/.local/bin/
-```
-
-## 1. Initialize (First Time Only)
-
-```bash
-starforge template init
-```
-
-This adds example templates to your local registry.
-
-## 2. Discover Templates
-
-### Search
-```bash
-# Search by keyword
-starforge template search defi
-
-# Search with tags
-starforge template search dex --tags amm
-```
-
-### List All
-```bash
-starforge template list
-```
-
-### View Details
-```bash
-starforge template show uniswap-v2
-```
-
-## 3. Use a Template
-
-```bash
-# Create project from marketplace template
-starforge new contract my-dex --template uniswap-v2 --from marketplace
-
-# Navigate and build
-cd my-dex
-stellar contract build
-```
-
-## 4. Create Your Own Template
-
-### Step 1: Create a Contract
-```bash
-starforge new contract my-template
-cd my-template
-```
-
-### Step 2: Add Placeholders
-
-Edit `Cargo.toml`:
-```toml
-[package]
-name = "{{PROJECT_NAME}}"
-```
-
-Edit `src/lib.rs`:
-```rust
-#[contract]
-pub struct {{PROJECT_NAME_PASCAL}};
-```
-
-### Step 3: Test It
-```bash
-cargo test
-stellar contract build
-```
-
-### Step 4: Publish
-```bash
-cd ..
-starforge template publish ./my-template \
-  --name my-awesome-template \
-  --description "Does something awesome" \
-  --author "Your Name" \
-  --tags "defi,awesome"
-```
-
-## 5. Share with Others
-
-```bash
-# Others can now use your template
-starforge new contract test-project \
-  --template my-awesome-template \
-  --from marketplace
-```
-
-## Available Placeholders
-
-| Placeholder | Input: "my-project" | Output |
-|-------------|---------------------|--------|
-| `{{PROJECT_NAME}}` | my-project | my-project |
-| `{{PROJECT_NAME_SNAKE}}` | my-project | my_project |
-| `{{PROJECT_NAME_PASCAL}}` | my-project | MyProject |
-
-## Common Commands
-
-```bash
-# Search
-starforge template search <query>
-starforge template search <query> --tags <tag1,tag2>
-
-# List
-starforge template list
-
-# Show
-starforge template show <name>
-
-# Use
-starforge new contract <name> --template <template> --from marketplace
-
-# Publish
-starforge template publish <path> [options]
-
-# Remove
-starforge template remove <name>
-
-# Initialize
-starforge template init
-```
-
-## Example Workflow
-
-```bash
-# 1. Find a template
-starforge template search lending
-
-# 2. Check it out
-starforge template show lending-pool
-
-# 3. Use it
-starforge new contract my-lending --template lending-pool --from marketplace
-
-# 4. Build and deploy
-cd my-lending
-stellar contract build
-starforge deploy --wasm target/wasm32-unknown-unknown/release/my_lending.wasm
-```
-
-## Tips
-
-✅ **Use verified templates** - Look for the ✓ badge
-✅ **Review code first** - Always check template source
-✅ **Test locally** - Try templates in a safe environment
-✅ **Add good tags** - Make your templates discoverable
-✅ **Document well** - Include a comprehensive README
-
-## Troubleshooting
-
-**Template not found?**
-```bash
-starforge template list  # Check available templates
-```
-
-**Invalid structure?**
-```bash
-# Ensure your template has:
-# - Cargo.toml
-# - src/lib.rs
-# - src/ directory
-```
-
-**Git clone failed?**
-```bash
-# Check if git is installed
-git --version
-
-# Verify template source URL
-starforge template show <template-name>
-```
-
-## Built-in Templates
-
-These templates are available without initializing the marketplace:
-
-| Template | Command | Description |
-|----------|---------|-------------|
-| `hello-world` | `starforge new contract my-contract` | Basic contract with optional storage |
-| `token` | `starforge new contract my-token --template token` | Fungible token with mint/burn/transfer |
-| `nft` | `starforge new contract my-nft --template nft` | Non-fungible token with URI metadata |
-| `voting` | `starforge new contract my-vote --template voting` | DAO proposal and voting contract |
-| `stablecoin` | `starforge new contract my-stable --template stablecoin` | Pegged stablecoin with mint/burn |
-| `escrow` | `starforge new contract my-escrow --template escrow` | Three-party escrow with arbiter release/refund |
-
-## Next Steps
-
-- Read the [full documentation](TEMPLATE_MARKETPLACE.md)
-- Check out [usage examples](examples/template_marketplace_usage.md)
-- Explore [example templates](templates/examples/)
-- Join the community and share your templates!
-
-## Support
-
-- GitHub Issues: https://github.com/YOUR_USERNAME/starforge/issues
-- Documentation: https://github.com/YOUR_USERNAME/starforge
diff --git a/README.md b/README.md
index c6e673f6..9b7cad04 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,6 @@
 ![Language: Rust](https://img.shields.io/badge/Language-Rust-orange.svg)
 ![Network: Stellar](https://img.shields.io/badge/Network-Stellar-blue.svg)
 ![Status: Active](https://img.shields.io/badge/Status-Active-green.svg)
-![Stellar Wave](https://img.shields.io/badge/Stellar-Wave%20Program-blueviolet.svg)
 
 ---
 
@@ -16,7 +15,7 @@
 
 Think of it as the "Hardhat or Foundry" experience for the Stellar ecosystem, built in Rust for speed and reliability.
 
-This project is actively maintained and participates in the [Stellar Wave Program](https://www.drips.network/wave/stellar) on Drips — a monthly open-source contribution sprint where contributors earn rewards for merged pull requests.
+This project is actively maintained and open to community contributions.
 
 ---
 
@@ -162,8 +161,29 @@ starforge config get network
 # Set a configuration value
 starforge config set telemetry false
 starforge config set network mainnet
+
+# Migrate an older config file to the latest schema version
+starforge config migrate --dry-run   # preview the changes without writing
+starforge config migrate             # apply migrations (backs up config.toml.bak first)
 ```
 
+#### Config schema migrations
+
+StarForge versions its config file (`~/.starforge/config.toml`) with a `version`
+field. When the CLI is upgraded and the config schema changes, the file is read
+into a schema-agnostic value, its version is detected, and a sequence of
+migrations (`v1 → v2 → …`) reshapes it **before** it is deserialized into the
+current `Config`. This prevents the most dangerous class of upgrade bug —
+silently dropping wallet entries when a field is renamed or restructured.
+
+- A backup (`config.toml.bak`) is written before any migration overwrites the
+  file, plus a timestamped copy for recoverability.
+- `starforge config migrate --dry-run` shows exactly what would change without
+  modifying anything.
+- Reads (`config show`, telemetry, etc.) migrate in memory only and never
+  rewrite the file; persistence happens on an explicit `config migrate` or the
+  next `save`.
+
 Common settings:
 - **telemetry**: Enable/disable anonymous usage telemetry (`true` or `false`)
 - **network**: Set the default network (`testnet`, `mainnet`, or custom network name)
@@ -410,7 +430,7 @@ export STARFORGE_TELEMETRY=0
 
 **What's NOT collected**: Wallet addresses, secret keys, contract code, configuration values, error messages, or personal information.
 
-For detailed information, see [TELEMETRY_PRIVACY.md](./TELEMETRY_PRIVACY.md).
+See [Privacy & Telemetry](#privacy--telemetry) for opt-out options.
 
 ---
 
@@ -427,35 +447,21 @@ All templates include a working test suite and a README with build/deploy instru
 
 ## Contributing
 
-We welcome contributions from developers of all experience levels! Whether you're fixing a bug, adding a feature, or improving documentation, your work helps the Stellar ecosystem.
-
-**New contributor?** Start here: [CONTRIBUTING.md](CONTRIBUTING.md) has everything you need to get set up and submit your first PR.
-
-**Need a quick reference?** Check out [CONTRIBUTOR_QUICK_REFERENCE.md](CONTRIBUTOR_QUICK_REFERENCE.md) for common commands and patterns.
-
-### Key Contribution Resources
-
-| Resource | What it covers |
-|----------|---|
-| [CONTRIBUTING.md](CONTRIBUTING.md) | **Full contributor guide** — setup, building, testing, PR process |
-| [CONTRIBUTOR_QUICK_REFERENCE.md](CONTRIBUTOR_QUICK_REFERENCE.md) | **Quick lookup** — common commands, project structure, troubleshooting |
-| [CI_ENFORCEMENT.md](CI_ENFORCEMENT.md) | **CI pipeline** — formatting, linting, security, and test requirements |
-| [CODE_STYLE_STANDARDS.md](CODE_STYLE_STANDARDS.md) | **Code style** — naming, documentation, linting rules, IDE setup |
-| [DEVELOPER_GUIDE.md](DEVELOPER_GUIDE.md) | **Deep dive** — architecture, adding features, release process |
+We welcome contributions from developers of all experience levels!
 
 ### Quick Start
 
 1. Fork and clone the repository
-2. Follow [CONTRIBUTING.md](CONTRIBUTING.md) to set up Rust and the project
-3. Create a branch: `git checkout -b feat/issue-XXX-description`
-4. Make your changes and run `cargo test`
-5. Push and open a Pull Request with a clear description
-
-### Rewards
-
-This project participates in the **[Stellar Wave Program](https://www.drips.network/wave/stellar)** on Drips. Contributors who resolve issues during an active Wave earn Points that translate to real USDC rewards.
-
-**Read the [Terms & Rules](https://docs.drips.network/wave/terms-and-rules) before contributing.**
+2. Install Rust 1.80+ via [rustup](https://rustup.rs)
+3. Build and test: `cargo build && cargo test --locked`
+4. Create a branch: `git checkout -b feat/issue-XXX-description`
+5. Before pushing, run:
+   ```bash
+   cargo fmt --all
+   cargo clippy --all-targets --all-features --locked -- -D warnings
+   cargo test --locked
+   ```
+6. Push and open a Pull Request with a clear description
 
 ---
 ## License
@@ -467,42 +473,4 @@ MIT © 2025 — See [LICENSE](./LICENSE) for details.
 ## Acknowledgements
 
 Built for the Stellar ecosystem.
-Participates in the [Stellar Wave Program](https://www.drips.network/wave/stellar) via [Drips](https://www.drips.network).
 Powered by the [Stellar Horizon API](https://developers.stellar.org/api/horizon) and [Soroban](https://soroban.stellar.org).
-
----
-
-## Documentation
-
-StarForge has comprehensive documentation covering all aspects of the project:
-
-### ?? Core Documentation
-- **[README.md](README.md)** - This file, quick start and overview
-- **[Documentation.md](Documentation.md)** - Extended documentation with architecture overview
-- **[ARCHITECTURE.md](ARCHITECTURE.md)** - Complete system architecture and design
-- **[DEVELOPER_GUIDE.md](DEVELOPER_GUIDE.md)** - Contributing and development guide
-- **[API_REFERENCE.md](API_REFERENCE.md)** - Complete command reference
-- **[docs/COMMAND_REFERENCE.md](docs/COMMAND_REFERENCE.md)** - Navigable CLI command index
-
-### ?? Feature Documentation
-- **[TEMPLATE_MARKETPLACE.md](TEMPLATE_MARKETPLACE.md)** - Template marketplace feature
-- **[QUICK_START_TEMPLATES.md](QUICK_START_TEMPLATES.md)** - Template quick start guide
-
-### ?? Navigation
-- **[DOCUMENTATION_INDEX.md](DOCUMENTATION_INDEX.md)** - Complete documentation index
-- **[DOCUMENTATION_SUMMARY.md](DOCUMENTATION_SUMMARY.md)** - Documentation overview
-
-### ?? Examples
-- **[examples/template_marketplace_usage.md](examples/template_marketplace_usage.md)** - Practical examples
-- **[tutorials/hello-world/](tutorials/hello-world/)** - Beginner tutorial
-
-**Total**: 17 documentation files with 7,700+ lines covering architecture, development, API reference, and examples.
-
-For a complete overview, see [DOCUMENTATION_INDEX.md](DOCUMENTATION_INDEX.md).
-
-
-# Remove a template
-starforge template remove my-template
-
-# Remove template + delete all local files
-starforge template remove my-template --purge
\ No newline at end of file
diff --git a/SECURITY_LOGGING_AUDIT.md b/SECURITY_LOGGING_AUDIT.md
deleted file mode 100644
index b30bb76e..00000000
--- a/SECURITY_LOGGING_AUDIT.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# Security Logging Audit
-
-This audit ensures that secret material is never emitted at info level in the command handlers and logging helpers.
-
-## Sensitive data categories
-
-- Secret keys
-- Passphrases
-- Signed XDR envelopes or transactions
-
-## Grep-based checks
-
-Use these commands from the repository root to validate the audit:
-
-```bash
-grep -R --line-number -E 'p::info\(|tracing::info!|info!\(' src/commands/wallet.rs src/commands/deploy.rs
-grep -R --line-number -E 'Secret Key|passphrase|transaction_xdr|signed_xdr|XDR' src/commands/wallet.rs src/commands/deploy.rs
-```
-
-## Implementation notes
-
-- `src/utils/logging.rs` now exposes helpers for redacting sensitive log data:
-  - `redact_public_key(public_key, level)` hides public keys in info-level logs but preserves them in debug and trace logs.
-  - `redact_secret_value(_)` always returns `"[REDACTED]"` for secret keys and passphrases.
-  - `redact_signed_xdr(_)` always returns `"[REDACTED]"` for signed XDR payloads.
-
-- `tests/security_logging_audit.rs` contains a grep-based regression test that scans `src/commands/wallet.rs` and `src/commands/deploy.rs` for suspicious info-level patterns.
-
-## Running the audit
-
-```bash
-cargo test --test security_logging_audit
-```
diff --git a/SECURITY_LOGGING_BEST_PRACTICES.md b/SECURITY_LOGGING_BEST_PRACTICES.md
deleted file mode 100644
index e79a49d4..00000000
--- a/SECURITY_LOGGING_BEST_PRACTICES.md
+++ /dev/null
@@ -1,661 +0,0 @@
-# Security Logging Best Practices
-
-This document provides practical implementation patterns for adding security logging to StarForge operations.
-
-## Table of Contents
-
-1. [Core Principles](#core-principles)
-2. [Wallet Logging Patterns](#wallet-logging-patterns)
-3. [Plugin Logging Patterns](#plugin-logging-patterns)
-4. [Deployment Logging Patterns](#deployment-logging-patterns)
-5. [Error and Exception Logging](#error-and-exception-logging)
-6. [Testing Security Logging](#testing-security-logging)
-7. [Code Review Checklist](#code-review-checklist)
-8. [Common Mistakes](#common-mistakes)
-
----
-
-## Core Principles
-
-### 1. Never Log Secrets
-
-```rust
-// ❌ WRONG
-error!("Failed to decrypt: passphrase={}", passphrase);
-
-// ✅ CORRECT
-error!("Failed to decrypt wallet - wrong passphrase provided");
-```
-
-### 2. Always Log Operation Outcomes
-
-```rust
-// ❌ WRONG - no indication of success or failure
-fn create_wallet(name: &str) -> Result<Wallet> {
-    Wallet::new(name)
-}
-
-// ✅ CORRECT - logs the outcome
-fn create_wallet(name: &str) -> Result<Wallet> {
-    match Wallet::new(name) {
-        Ok(wallet) => {
-            info!(wallet = name, status = "success", "Wallet created");
-            Ok(wallet)
-        }
-        Err(e) => {
-            error!(wallet = name, error = %e, status = "failed", "Wallet creation failed");
-            Err(e)
-        }
-    }
-}
-```
-
-### 3. Include Timing Information
-
-```rust
-// ❌ WRONG - no timing info
-info!(operation = "encrypt", "Encryption complete");
-
-// ✅ CORRECT - includes duration
-let start = std::time::Instant::now();
-perform_encryption()?;
-let duration_ms = start.elapsed().as_millis() as u64;
-info!(operation = "encrypt", duration_ms = duration_ms, "Encryption complete");
-```
-
-### 4. Use Structured Logging
-
-```rust
-use tracing::info;
-
-// ❌ WRONG - unstructured message
-info!("Wallet alice on testnet encrypted with aes-256-gcm");
-
-// ✅ CORRECT - structured fields
-info!(
-    wallet = "alice",
-    network = "testnet",
-    algorithm = "aes-256-gcm",
-    "Wallet encrypted"
-);
-```
-
-### 5. Provide Debugging Context
-
-```rust
-// ❌ WRONG - generic error
-error!("Operation failed");
-
-// ✅ CORRECT - specific context
-error!(
-    operation = "fund_wallet",
-    wallet = "alice",
-    network = "testnet",
-    requested_amount = 1000,
-    error_type = "InsufficientFunds",
-    "Failed to fund wallet - faucet has insufficient balance"
-);
-```
-
----
-
-## Wallet Logging Patterns
-
-### Wallet Creation Logging
-
-```rust
-use tracing::info;
-use std::time::Instant;
-
-pub fn handle_create(cmd: CreateCommand) -> Result<()> {
-    let start = Instant::now();
-    
-    // Create wallet
-    let wallet = Wallet::new(&cmd.name, &cmd.network)?;
-    
-    // Encrypt if requested
-    if cmd.encrypt {
-        wallet.encrypt(&cmd.passphrase)?;
-    }
-    
-    let duration_ms = start.elapsed().as_millis() as u64;
-    
-    // Log creation
-    info!(
-        wallet = &cmd.name,
-        network = &cmd.network,
-        encrypted = cmd.encrypt,
-        duration_ms = duration_ms,
-        status = "success",
-        "Wallet created successfully"
-    );
-    
-    Ok(())
-}
-```
-
-### Wallet Access Logging
-
-```rust
-use tracing::info;
-use crate::utils::logging::redact_public_key;
-use tracing::Level;
-
-pub fn handle_show(cmd: ShowCommand) -> Result<()> {
-    let wallet = load_wallet(&cmd.name)?;
-    
-    if cmd.reveal {
-        // Log sensitive operation
-        info!(
-            wallet = &cmd.name,
-            reveal_requested = true,
-            decryption_status = "success",
-            status = "success",
-            "Secret key revealed for wallet"
-        );
-    }
-    
-    // Log balance query
-    let public_key = wallet.public_key();
-    let balance = query_balance(&public_key)?;
-    
-    info!(
-        wallet = &cmd.name,
-        public_key = %redact_public_key(public_key, Level::INFO),
-        balance = balance,
-        status = "success",
-        "Wallet details retrieved"
-    );
-    
-    Ok(())
-}
-```
-
-### Wallet Encryption Logging
-
-```rust
-use tracing::info;
-use std::time::Instant;
-
-pub fn handle_encrypt(cmd: EncryptCommand) -> Result<()> {
-    let start = Instant::now();
-    
-    let wallet = load_wallet(&cmd.name)?;
-    
-    // Perform encryption
-    wallet.encrypt(&cmd.passphrase)?;
-    
-    let duration_ms = start.elapsed().as_millis() as u64;
-    
-    // Log encryption operation
-    info!(
-        wallet = &cmd.name,
-        algorithm = "aes-256-gcm",
-        kdf_algorithm = "argon2",
-        kdf_iterations = 100000,  // Parameter size, not the actual value
-        duration_ms = duration_ms,
-        status = "success",
-        "Wallet encrypted with strong encryption"
-    );
-    
-    Ok(())
-}
-```
-
----
-
-## Plugin Logging Patterns
-
-### Plugin Load Logging
-
-```rust
-use tracing::info;
-
-pub fn load_plugin(path: &str, name: &str) -> Result<Plugin> {
-    let plugin = unsafe {
-        pm.load_plugin(path)
-            .context("Failed to load plugin")?
-    };
-    
-    let plugin_version = plugin.version();
-    let starforge_version = env!("CARGO_PKG_VERSION");
-    
-    // Verify compatibility
-    let compatible = verify_compatibility(plugin_version, starforge_version);
-    
-    if !compatible {
-        error!(
-            plugin = name,
-            plugin_version = plugin_version,
-            starforge_version = starforge_version,
-            compatible = false,
-            status = "failed",
-            "Plugin version incompatible with StarForge"
-        );
-        return Err(anyhow::anyhow!("Version incompatibility"));
-    }
-    
-    // Log successful load
-    info!(
-        plugin = name,
-        plugin_version = plugin_version,
-        starforge_version = starforge_version,
-        compatible = true,
-        source_path = path,
-        status = "success",
-        "Plugin loaded successfully"
-    );
-    
-    Ok(plugin)
-}
-```
-
-### Plugin Execution Logging
-
-```rust
-use tracing::info;
-use std::time::Instant;
-
-pub fn execute_plugin(plugin: &Plugin, args: &[String]) -> Result<()> {
-    let start = Instant::now();
-    
-    // Execute with sanitized arguments
-    let sanitized_args = sanitize_args(args);
-    
-    let result = plugin.execute(&sanitized_args)?;
-    
-    let duration_ms = start.elapsed().as_millis() as u64;
-    
-    // Log execution
-    info!(
-        plugin = plugin.name(),
-        command = "execute",
-        arg_count = args.len(),  // Number of args, not the args themselves
-        duration_ms = duration_ms,
-        exit_code = result.exit_code,
-        status = "success",
-        "Plugin executed successfully"
-    );
-    
-    Ok(())
-}
-```
-
----
-
-## Deployment Logging Patterns
-
-### Contract Validation Logging
-
-```rust
-use tracing::info;
-
-pub fn handle_validate(cmd: ValidateCommand) -> Result<()> {
-    let wasm_data = std::fs::read(&cmd.wasm_path)?;
-    let file_size = wasm_data.len();
-    
-    let result = validate_contract(&wasm_data)?;
-    
-    info!(
-        operation = "contract_validate",
-        file_path = &cmd.wasm_path,
-        file_size = file_size,
-        validation_result = "success",
-        warning_count = result.warnings.len(),
-        error_count = result.errors.len(),
-        status = "success",
-        "Contract validated"
-    );
-    
-    Ok(())
-}
-```
-
-### Contract Deployment Logging
-
-```rust
-use tracing::info;
-use crate::utils::logging::redact_public_key;
-use tracing::Level;
-
-pub fn handle_deploy(cmd: DeployCommand) -> Result<()> {
-    // Validate contract
-    validate_contract(&cmd.wasm_path)?;
-    
-    // Calculate WASM hash
-    let wasm_hash = calculate_wasm_hash(&cmd.wasm_path)?;
-    
-    // Perform deployment
-    let result = deploy_contract(
-        &cmd.wasm_path,
-        &cmd.network,
-        &cmd.account,
-    )?;
-    
-    // Log deployment
-    info!(
-        operation = "contract_deploy",
-        network = &cmd.network,
-        account = %redact_public_key(&cmd.account, Level::INFO),
-        wasm_hash = %wasm_hash,
-        contract_address = %result.address,
-        gas_used = result.gas_used,
-        transaction_hash = %result.tx_hash,
-        status = "success",
-        "Contract deployed successfully"
-    );
-    
-    Ok(())
-}
-```
-
----
-
-## Error and Exception Logging
-
-### Safe Error Logging
-
-```rust
-use tracing::error;
-
-// ✅ CORRECT - specific error type without exposing secrets
-match wallet.decrypt(passphrase) {
-    Ok(decrypted) => {
-        info!(wallet = name, "Wallet decrypted");
-        Ok(decrypted)
-    }
-    Err(e) => {
-        error!(
-            wallet = name,
-            error_type = "DecryptionFailed",
-            attempt = 1,
-            status = "failed",
-            "Failed to decrypt wallet"
-        );
-        Err(e)
-    }
-}
-```
-
-### Error Context Without Secrets
-
-```rust
-use tracing::error;
-
-// ❌ WRONG - includes sensitive information
-error!(
-    wallet = name,
-    error = format!("Decryption failed: {}", e),
-    status = "failed"
-);
-
-// ✅ CORRECT - sanitized error message
-error!(
-    wallet = name,
-    error_type = "DecryptionFailed",
-    error_cause = "InvalidKeyDerivation",
-    status = "failed"
-);
-```
-
-### Retry Logic Logging
-
-```rust
-use tracing::{warn, error};
-
-fn fund_with_retry(wallet: &str, amount: u64, max_retries: usize) -> Result<()> {
-    for attempt in 1..=max_retries {
-        match request_funds(wallet, amount) {
-            Ok(tx_hash) => {
-                info!(
-                    wallet = wallet,
-                    attempt = attempt,
-                    status = "success",
-                    "Wallet funded successfully"
-                );
-                return Ok(());
-            }
-            Err(e) if attempt < max_retries => {
-                warn!(
-                    wallet = wallet,
-                    attempt = attempt,
-                    error_type = format!("{:?}", e),
-                    will_retry = true,
-                    "Funding attempt failed, will retry"
-                );
-            }
-            Err(e) => {
-                error!(
-                    wallet = wallet,
-                    attempt = attempt,
-                    error_type = format!("{:?}", e),
-                    will_retry = false,
-                    status = "failed",
-                    "Funding failed after {} attempts",
-                    max_retries
-                );
-                return Err(e);
-            }
-        }
-    }
-    Ok(())
-}
-```
-
----
-
-## Testing Security Logging
-
-### Unit Test for Logging
-
-```rust
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use tracing::Level;
-    use tracing_subscriber::EnvFilter;
-
-    #[test]
-    fn test_wallet_creation_logs() {
-        // Setup logging capture
-        let subscriber = tracing_subscriber::fmt()
-            .with_max_level(Level::DEBUG)
-            .with_env_filter(EnvFilter::new("debug"))
-            .finish();
-
-        let _guard = tracing::subscriber::set_default(subscriber);
-
-        // Perform operation
-        let result = create_wallet("test", "testnet", false);
-        assert!(result.is_ok());
-
-        // Verify operation completed (logs would be captured by subscriber)
-    }
-
-    #[test]
-    fn test_no_secret_keys_in_logs() {
-        // This test ensures secret keys are never logged
-        let secret_key = "SBZJ3SHRVGPXDT3XNQDRT5PHZFSF6OKOPECJ...";
-        
-        // Create wallet
-        let wallet = Wallet::with_key(secret_key).unwrap();
-        
-        // Attempt to log wallet (should NOT contain secret)
-        let log_output = format!("{:?}", wallet);
-        assert!(!log_output.contains("SBZJ3SHRVGPXDT3XNQDRT5PHZFSF6OKO"));
-    }
-}
-```
-
-### Integration Test for Audit Trails
-
-```rust
-#[test]
-fn test_wallet_operations_create_audit_trail() {
-    // Create temporary log file
-    let log_dir = tempfile::tempdir().unwrap();
-    
-    // Initialize with JSON logging
-    let config = LogConfig {
-        format: LogFormat::Json,
-        log_dir: Some(log_dir.path().to_path_buf()),
-        ..Default::default()
-    };
-    let _ = logging::init(config);
-    
-    // Perform wallet operations
-    create_wallet("alice", "testnet", false).unwrap();
-    fund_wallet("alice", "testnet", 1000).unwrap();
-    
-    // Verify logs were written
-    let log_files = std::fs::read_dir(log_dir.path()).unwrap();
-    assert!(log_files.count() > 0, "Logs should have been written");
-    
-    // Parse and verify log content
-    let log_content = std::fs::read_to_string(
-        log_dir.path().join("starforge.log")
-    ).unwrap();
-    
-    assert!(log_content.contains("wallet_create"));
-    assert!(log_content.contains("wallet_fund"));
-    assert!(!log_content.contains("secret"));
-}
-```
-
----
-
-## Code Review Checklist
-
-When reviewing code for security logging, verify:
-
-- [ ] **No secrets logged** - Secret keys, passphrases, or derived keys never appear
-- [ ] **Operation outcome logged** - Success and failure both recorded
-- [ ] **Timing included** - Duration for security operations tracked
-- [ ] **Structured fields** - Using `info!(field = value, ...)` format
-- [ ] **Consistent naming** - Field names match audit trail spec
-- [ ] **Error details safe** - Error messages don't expose sensitive data
-- [ ] **Appropriate log level** - INFO for operations, DEBUG for detailed info
-- [ ] **Context sufficient** - Logs can be understood in isolation
-- [ ] **No performance impact** - Logging doesn't slow down operations
-- [ ] **Tests included** - Logging behavior verified in tests
-
----
-
-## Common Mistakes
-
-### Mistake 1: Logging Passphrases
-
-```rust
-// ❌ WRONG
-let passphrase = prompt_for_passphrase();
-info!("User provided passphrase: {}", passphrase);  // NEVER DO THIS
-
-// ✅ CORRECT
-let passphrase = prompt_for_passphrase();
-info!("Passphrase accepted");  // Just log that it was provided
-```
-
-### Mistake 2: Logging Function Entry/Exit for Everything
-
-```rust
-// ❌ WRONG - too verbose
-fn process_item(item: &Item) -> Result<()> {
-    trace!("Entering process_item()");
-    
-    for sub_item in &item.sub_items {
-        trace!("Processing sub_item: {:?}", sub_item);  // Way too verbose
-    }
-    
-    trace!("Exiting process_item()");
-    Ok(())
-}
-
-// ✅ CORRECT - log only security-relevant operations
-fn process_item(item: &Item) -> Result<()> {
-    let result = perform_operation(item)?;
-    info!(operation = "process_item", status = "success");
-    Ok(result)
-}
-```
-
-### Mistake 3: Inconsistent Field Names
-
-```rust
-// ❌ WRONG - inconsistent naming
-info!(
-    wallet = "alice",       // "wallet" name here
-    account = "alice",      // but "account" here
-    operation = "create",   // "operation" here
-    cmd = "create",         // and "cmd" here
-);
-
-// ✅ CORRECT - consistent field names
-info!(
-    wallet = "alice",
-    operation = "create",
-    network = "testnet",
-    status = "success",
-);
-```
-
-### Mistake 4: Redacting When Not Needed
-
-```rust
-// ❌ WRONG - redacting non-sensitive public key
-info!(
-    wallet = "alice",
-    public_key = %redact_public_key(key, Level::INFO),  // Unnecessary
-);
-
-// ✅ CORRECT - public keys are safe to log at INFO level
-info!(
-    wallet = "alice",
-    public_key = %key,  // Safe to log
-);
-```
-
-### Mistake 5: Not Logging Failures
-
-```rust
-// ❌ WRONG - only logs success
-fn deploy_contract(path: &str) -> Result<()> {
-    let result = execute_deploy(path)?;
-    info!(contract = path, status = "success");
-    Ok(())
-}
-
-// ✅ CORRECT - logs both success and failure
-fn deploy_contract(path: &str) -> Result<()> {
-    match execute_deploy(path) {
-        Ok(result) => {
-            info!(
-                contract = path,
-                address = %result.address,
-                status = "success",
-            );
-            Ok(())
-        }
-        Err(e) => {
-            error!(
-                contract = path,
-                error_type = format!("{:?}", e),
-                status = "failed",
-            );
-            Err(e)
-        }
-    }
-}
-```
-
----
-
-## Further Reading
-
-- [SECURITY_LOGGING_GUIDE.md](SECURITY_LOGGING_GUIDE.md) - Complete security logging guide
-- [AUDIT_TRAIL_DOCUMENTATION.md](AUDIT_TRAIL_DOCUMENTATION.md) - Audit trail setup and review
-- [src/utils/logging.rs](src/utils/logging.rs) - Logging infrastructure implementation
-
----
-
-*Last updated: 2026-06-01*  
-*Issue #223: Improve security logging and auditability*
diff --git a/SECURITY_LOGGING_GUIDE.md b/SECURITY_LOGGING_GUIDE.md
deleted file mode 100644
index d8dc34b5..00000000
--- a/SECURITY_LOGGING_GUIDE.md
+++ /dev/null
@@ -1,555 +0,0 @@
-# Security Logging and Audit Guide
-
-This guide explains how to properly log security-relevant operations in StarForge to maintain reliable audit trails and debugging capabilities.
-
-## Table of Contents
-
-1. [Philosophy](#philosophy)
-2. [Sensitivity Levels](#sensitivity-levels)
-3. [What to Log](#what-to-log)
-4. [What NOT to Log](#what-not-to-log)
-5. [Structured Logging Format](#structured-logging-format)
-6. [Security-Relevant Operations](#security-relevant-operations)
-7. [Audit Trail Requirements](#audit-trail-requirements)
-8. [Code Examples](#code-examples)
-9. [Verification and Testing](#verification-and-testing)
-
----
-
-## Philosophy
-
-Security and auditability are critical in blockchain tooling where users interact with real assets and sensitive keys. Every security-relevant operation should:
-
-1. **Be logged** - Operations that affect security state must be recorded
-2. **Be traceable** - Include enough context to understand what happened
-3. **Be sanitized** - Remove sensitive data from logs
-4. **Be useful** - Provide actionable information for debugging and auditing
-
-StarForge uses **structured logging** (JSON format available) with the `tracing` crate to ensure logs are machine-parseable and can be aggregated for analysis.
-
----
-
-## Sensitivity Levels
-
-### Public Information
-Safe to log in all contexts:
-- User-provided wallet/contract names
-- Public keys (Stellar G-accounts)
-- Network names (testnet, mainnet)
-- Operation types (create, deploy, inspect)
-- Success/failure status
-- Timestamps
-
-Example:
-```json
-{
-  "timestamp": "2024-01-15T10:30:45Z",
-  "operation": "wallet_create",
-  "wallet_name": "alice",
-  "network": "testnet",
-  "encrypted": true,
-  "success": true
-}
-```
-
-### Private Information
-Log only at DEBUG/TRACE level or never:
-- Account addresses in some contexts
-- Gas costs and fees (operational)
-- Algorithm parameters (KDF iterations, salt size)
-- Error messages with technical details
-
-Example (only at DEBUG level):
-```rust
-debug!(address = %redact_public_key(addr, Level::DEBUG), "Account balance query");
-```
-
-### Sensitive Information
-**NEVER log under any circumstances:**
-- Private keys / secret keys
-- Passphrases
-- Encryption keys or derived keys
-- Signed transactions or XDR payloads
-- Wallet backup data
-- Plugin source code or binaries
-- Authentication tokens
-
----
-
-## What to Log
-
-### For Every Security-Relevant Operation
-
-1. **Operation Type** - What is being done (create, encrypt, deploy, load, execute)
-2. **Operation Status** - Success or failure
-3. **Operation Context** - Who/what triggered it, which account/resource
-4. **Timestamp** - When it happened
-5. **Duration** - How long it took (important for crypto operations)
-6. **Error Details** - If failed, what went wrong (without revealing secrets)
-
-Example structure:
-```rust
-info!(
-    operation = "wallet_encrypt",
-    wallet = "alice",
-    status = "success",
-    duration_ms = 245,
-    "Wallet encryption completed"
-);
-```
-
-### Specific Operation Categories
-
-#### Wallet Operations
-```
-Operation: wallet_create
-Logs:
-  - wallet name, network, encryption enabled, success
-  
-Operation: wallet_encrypt
-Logs:
-  - wallet name, encryption algorithm, KDF iterations, success
-  
-Operation: wallet_fund
-Logs:
-  - wallet name, network, requested amount, balance after, success
-  
-Operation: wallet_remove
-Logs:
-  - wallet name, network, confirmation status, success
-  
-Operation: wallet_show
-Logs:
-  - wallet name, reveal_requested, balance_query_status
-```
-
-#### Plugin Operations
-```
-Operation: plugin_load
-Logs:
-  - plugin name, plugin version, source path, compatibility check result
-  
-Operation: plugin_execute
-Logs:
-  - plugin name, command args (sanitized), execution status, duration
-  
-Operation: plugin_unload
-Logs:
-  - plugin name, cleanup status, success
-```
-
-#### Deployment Operations
-```
-Operation: contract_deploy
-Logs:
-  - contract path, network, account, wasm hash, deployment status, gas
-  
-Operation: contract_validate
-Logs:
-  - contract path, validation status, file size, warnings/errors
-  
-Operation: contract_inspect
-Logs:
-  - contract address, network, inspection status, metadata retrieved
-```
-
-#### Network Operations
-```
-Operation: network_switch
-Logs:
-  - from_network, to_network, connectivity_check_status
-  
-Operation: network_test
-Logs:
-  - network name, horizon_status, soroban_status, latency
-```
-
----
-
-## What NOT to Log
-
-### Absolutely Never Log
-
-```rust
-// ❌ WRONG - Never log secret keys
-warn!("Secret key: {}", secret_key);
-
-// ❌ WRONG - Never log passphrases
-info!("User entered passphrase: {}", passphrase);
-
-// ❌ WRONG - Never log private/sensitive material
-debug!("Encryption key: {}", derived_key);
-
-// ❌ WRONG - Never log full XDR payloads
-trace!("Signed transaction: {}", xdr_envelope);
-```
-
-### Avoid Logging
-
-```rust
-// ❌ Unnecessary - Don't log function entry/exit for every function
-trace!("Entering validate_key()");
-
-// ❌ Noisy - Don't log every iteration
-for item in items {
-    trace!("Processing: {:?}", item);  // Too verbose
-}
-
-// ❌ Sensitive context - Don't log full error messages with context
-error!("Failed to decrypt wallet {} with passphrase {}: {}", name, pass, err);
-```
-
-### Safe to Log (with Redaction)
-
-```rust
-// ✅ Redact public keys at INFO level
-info!(key = %redact_public_key(addr, Level::INFO), "Account queried");
-
-// ✅ Never redact error messages (no secrets)
-error!("Network connection failed: {}", err);
-
-// ✅ Log operation metadata
-info!(
-    wallet = "alice",
-    network = "testnet",
-    operation = "fund",
-    status = "success"
-);
-```
-
----
-
-## Structured Logging Format
-
-StarForge uses structured logging for machine-parseability. Each log entry includes:
-
-### Human-Readable Format
-```
-2024-01-15T10:30:45.123Z [INFO] starforge::commands::wallet: Wallet encrypted
-    wallet: alice
-    algorithm: aes-256-gcm
-    iterations: 100000
-    duration_ms: 245
-```
-
-### JSON Format
-```json
-{
-  "timestamp": "2024-01-15T10:30:45.123Z",
-  "level": "INFO",
-  "target": "starforge::commands::wallet",
-  "message": "Wallet encrypted",
-  "fields": {
-    "wallet": "alice",
-    "algorithm": "aes-256-gcm",
-    "iterations": 100000,
-    "duration_ms": 245
-  }
-}
-```
-
-### Key Guidelines
-
-1. **Use structured fields** - Not free-text messages
-2. **Use consistent names** - `wallet`, `network`, `operation`, `status`
-3. **Use appropriate types** - Timestamps as ISO-8601, durations as milliseconds
-4. **Be specific** - `status: "success"` not `message: "OK"`
-
----
-
-## Security-Relevant Operations
-
-### Wallet Management
-
-| Operation | Logs | Sensitivity |
-|-----------|------|-------------|
-| Create | name, network, encryption enabled, result | Public |
-| Encrypt | name, algorithm, KDF params (size, not value) | Public |
-| Decrypt | name, attempt status | Public |
-| Fund | name, network, amount, balance after | Public |
-| Show | name, reveal_requested, balance_status | Public |
-| Remove | name, confirmation, result | Public |
-| Rotate | name, new_account_created, result | Public |
-
-**Never log:** Secret keys, passphrases, private key material
-
-### Plugin Management
-
-| Operation | Logs | Sensitivity |
-|-----------|------|-------------|
-| Load | name, version, source_path, verify status | Public |
-| Execute | name, args (sanitized), duration, result | Public |
-| Unload | name, cleanup_status | Public |
-| Compatibility Check | name, starforge_version, plugin_version, compatible | Public |
-
-**Never log:** Plugin source code, loaded binaries, execution results with sensitive data
-
-### Contract Operations
-
-| Operation | Logs | Sensitivity |
-|-----------|------|-------------|
-| Validate | file_path, file_size, validation_result | Public |
-| Deploy | network, account (redacted), hash, gas, result | Public |
-| Inspect | address (redacted), network, inspection_result | Public |
-| Invoke | address (redacted), function, param_count, result | Public |
-
-**Never log:** Private contract state, function arguments with secrets, signed XDR
-
-### Network Operations
-
-| Operation | Logs | Sensitivity |
-|-----------|------|-------------|
-| Switch | from_network, to_network, verify_status | Public |
-| Test | network, endpoint_status, latency_ms | Public |
-| Add Custom | network_name, urls (redacted), result | Public |
-
-**Never log:** API keys for custom networks
-
----
-
-## Audit Trail Requirements
-
-### Timestamp Precision
-
-All security operations must include precise timestamps for audit correlation:
-
-```rust
-use chrono::Utc;
-
-info!(
-    timestamp = %Utc::now(),
-    operation = "wallet_create",
-    "New wallet created"
-);
-```
-
-### Contextual Information
-
-Each security operation should include enough context to understand the full flow:
-
-```rust
-info!(
-    session_id = uuid,
-    user_action = "import_wallet",
-    wallet_name = "alice",
-    network = "testnet",
-    encrypted = true,
-    duration_ms = 150,
-    status = "success",
-    "Wallet import completed"
-);
-```
-
-### Error Details Without Secrets
-
-When logging errors, include diagnostic information but not sensitive data:
-
-```rust
-// ✅ Good - Specific error type without secrets
-error!(
-    wallet = "alice",
-    error_type = "DecryptionFailed",
-    error_code = "ERR_WRONG_PASSPHRASE",
-    attempts = 3,
-    "Failed to decrypt wallet"
-);
-
-// ❌ Bad - Too specific about secrets
-error!(
-    wallet = "alice",
-    error = "Failed to decrypt with provided passphrase",
-    passphrase_length = 8,
-    "Decryption failed"
-);
-```
-
-### Result Summaries
-
-Always log the result of security operations:
-
-```rust
-info!(
-    operation = "deploy",
-    account = redact_public_key(addr, Level::INFO),
-    network = "testnet",
-    wasm_hash = hash,
-    gas_used = 12345,
-    result = "success",
-    "Contract deployed"
-);
-```
-
----
-
-## Code Examples
-
-### Logging a Wallet Creation
-
-```rust
-use tracing::info;
-
-fn create_wallet(name: &str, network: &str, encrypt: bool) -> Result<Wallet> {
-    let start = std::time::Instant::now();
-    
-    let wallet = Wallet::new(name, network)?;
-    
-    if encrypt {
-        wallet.encrypt(passphrase)?;
-    }
-    
-    let duration_ms = start.elapsed().as_millis() as u64;
-    
-    info!(
-        wallet = name,
-        network = network,
-        encrypted = encrypt,
-        duration_ms = duration_ms,
-        status = "success",
-        "Wallet created"
-    );
-    
-    Ok(wallet)
-}
-```
-
-### Logging a Plugin Load
-
-```rust
-use tracing::info;
-
-fn load_plugin(plugin_path: &str, name: &str) -> Result<Plugin> {
-    let plugin = unsafe { pm.load_plugin(plugin_path)? };
-    
-    let plugin_version = plugin.version();
-    let starforge_version = env!("CARGO_PKG_VERSION");
-    
-    info!(
-        plugin_name = name,
-        plugin_version = plugin_version,
-        starforge_version = starforge_version,
-        source = plugin_path,
-        status = "success",
-        "Plugin loaded"
-    );
-    
-    Ok(plugin)
-}
-```
-
-### Logging a Contract Deployment
-
-```rust
-use tracing::info;
-
-fn deploy_contract(wasm_path: &str, network: &str, account: &str) -> Result<String> {
-    let wasm_hash = calculate_wasm_hash(wasm_path)?;
-    
-    let result = execute_deployment(wasm_path, network, account)?;
-    
-    info!(
-        wasm_hash = %wasm_hash,
-        network = network,
-        account = %redact_public_key(account, Level::INFO),
-        contract_address = %result.address,
-        gas_used = result.gas_used,
-        status = "success",
-        "Contract deployed"
-    );
-    
-    Ok(result.address)
-}
-```
-
-### Logging with Error Handling
-
-```rust
-use tracing::{info, error};
-
-fn fund_wallet(wallet: &str, network: &str, amount: u64) -> Result<()> {
-    match request_funds(wallet, network, amount) {
-        Ok(tx_hash) => {
-            info!(
-                wallet = wallet,
-                network = network,
-                amount = amount,
-                transaction_hash = tx_hash,
-                status = "success",
-                "Wallet funded"
-            );
-            Ok(())
-        }
-        Err(e) => {
-            error!(
-                wallet = wallet,
-                network = network,
-                error_type = "FundingFailed",
-                error_message = %e,
-                status = "failed",
-                "Failed to fund wallet"
-            );
-            Err(e)
-        }
-    }
-}
-```
-
----
-
-## Verification and Testing
-
-### Testing Security Logging
-
-Always test that security operations log correctly:
-
-```rust
-#[test]
-fn test_wallet_creation_is_logged() {
-    // Setup logging capture
-    let subscriber = tracing_subscriber::fmt()
-        .with_max_level(Level::INFO)
-        .finish();
-    
-    let _guard = tracing::subscriber::set_default(subscriber);
-    
-    // Perform security operation
-    let wallet = Wallet::new("test", "testnet").unwrap();
-    
-    // Verify logs were emitted (integration test would check log output)
-    assert_eq!(wallet.name, "test");
-}
-```
-
-### Checking Logs in CI
-
-Enable JSON logging in CI for better parsing:
-
-```bash
-# In CI environment
-cargo test --log-format json --log-dir ./logs
-
-# Verify logs contain required fields
-jq '.fields | has("wallet") and has("status")' logs/*.log | grep true
-```
-
-### Log Audit Review
-
-Regular review of security logs:
-
-1. **Weekly** - Check for failed authentication attempts
-2. **On deployment** - Verify deployment logs are complete
-3. **On incidents** - Full log trace of affected operations
-4. **On access** - Who accessed sensitive operations and when
-
----
-
-## Further Reading
-
-- [AUDIT_TRAIL_DOCUMENTATION.md](AUDIT_TRAIL_DOCUMENTATION.md) - Detailed audit trail setup
-- [SECURITY_LOGGING_BEST_PRACTICES.md](SECURITY_LOGGING_BEST_PRACTICES.md) - Implementation patterns
-- [src/utils/logging.rs](src/utils/logging.rs) - Logging infrastructure
-- [tracing crate](https://docs.rs/tracing/) - Official tracing documentation
-
----
-
-*Last updated: 2026-06-01*  
-*Issue #223: Improve security logging and auditability*
diff --git a/SHELL_COMPLETIONS.md b/SHELL_COMPLETIONS.md
deleted file mode 100644
index 143accb1..00000000
--- a/SHELL_COMPLETIONS.md
+++ /dev/null
@@ -1,151 +0,0 @@
-# Shell Completion for StarForge
-
-StarForge ships pre-generated completion scripts for **bash**, **zsh**, and
-**fish** in the `completions/` directory and can also generate them on-demand
-via the `starforge completions` subcommand.
-
----
-
-## Quick install
-
-### Bash
-
-```bash
-# One-time — generate and install to the user completion directory
-mkdir -p ~/.local/share/bash-completion/completions
-starforge completions bash > ~/.local/share/bash-completion/completions/starforge
-
-# Or source it directly from your shell profile
-echo 'source <(starforge completions bash)' >> ~/.bashrc
-source ~/.bashrc
-```
-
-### Zsh
-
-```zsh
-# Ensure a completions directory is on your $fpath, then install
-mkdir -p ~/.zsh/completions
-starforge completions zsh > ~/.zsh/completions/_starforge
-
-# Add the directory to $fpath in ~/.zshrc (if not already present)
-echo 'fpath=(~/.zsh/completions $fpath)' >> ~/.zshrc
-echo 'autoload -Uz compinit && compinit' >> ~/.zshrc
-source ~/.zshrc
-```
-
-### Fish
-
-```fish
-starforge completions fish > ~/.config/fish/completions/starforge.fish
-```
-
-Changes take effect in new shell sessions (or after `source`-ing the file).
-
----
-
-## Using the pre-generated scripts
-
-The `completions/` directory in the repository contains scripts generated from
-the current CLI definition:
-
-| File | Shell |
-|---|---|
-| `completions/starforge.bash` | bash |
-| `completions/_starforge` | zsh |
-| `completions/starforge.fish` | fish |
-
-Copy the relevant file to the location shown above instead of running
-`starforge completions <shell>`.
-
----
-
-## Supported shells
-
-| Shell | Status |
-|---|---|
-| bash | Fully supported |
-| zsh | Fully supported |
-| fish | Fully supported |
-
-PowerShell completion is not currently supported.
-
----
-
-## Verifying your installation
-
-After installing, open a **new** terminal session and type:
-
-```
-starforge <TAB>
-```
-
-You should see a list of available subcommands. Press `<TAB>` again after
-typing a subcommand prefix to narrow the choices.
-
-### Bash
-
-```bash
-$ starforge w<TAB>
-wallet
-```
-
-### Zsh
-
-```zsh
-$ starforge <TAB>
-wallet     -- Manage test wallets (create, list, fund, show, remove)
-new        -- Generate Soroban project boilerplate
-deploy     -- Deploy a compiled Soroban contract (.wasm)
-...
-```
-
-### Fish
-
-```fish
-$ starforge <TAB>
-wallet   (Manage test wallets)
-new      (Generate Soroban project boilerplate)
-...
-```
-
----
-
-## Troubleshooting
-
-**Completions not working after install**
-
-1. Open a *new* terminal window — changes are not applied to running sessions.
-2. Verify the file is in the correct location:
-   - bash: `~/.local/share/bash-completion/completions/starforge`
-   - zsh: a directory on your `$fpath`, e.g. `~/.zsh/completions/_starforge`
-   - fish: `~/.config/fish/completions/starforge.fish`
-3. Check that `bash-completion` (bash) or `compinit` (zsh) is active in your
-   shell profile.
-
-**Completions are stale after upgrading StarForge**
-
-Re-run the install command to regenerate:
-
-```bash
-starforge completions bash > ~/.local/share/bash-completion/completions/starforge
-```
-
-**Zsh: `command not found: compdef`**
-
-Add the following lines to `~/.zshrc` before the `fpath` entry:
-
-```zsh
-autoload -Uz compinit
-compinit
-```
-
----
-
-## Keeping completions up to date
-
-Completion scripts are generated from the live CLI definition, so they always
-reflect the current set of commands and flags. Re-generate after any StarForge
-upgrade to pick up new subcommands.
-
-The `completions/` scripts in the repository are regenerated automatically as
-part of the release process.
diff --git a/TELEMETRY_PRIVACY.md b/TELEMETRY_PRIVACY.md
deleted file mode 100644
index 51b5f749..00000000
--- a/TELEMETRY_PRIVACY.md
+++ /dev/null
@@ -1,153 +0,0 @@
-# Telemetry & Privacy
-
-StarForge collects telemetry data to help us understand usage patterns and improve the CLI. This document explains exactly what is collected, how to disable it, and what we do with the data.
-
-## Privacy-First Design
-
-- **Opt-out by default**: Telemetry is enabled by default but can be easily disabled
-- **No personal data**: We never collect personal information, credentials, or sensitive data
-- **Anonymous ID**: Usage is tracked with a random UUID, not tied to your identity
-- **Local-first**: Telemetry is stored locally in your machine and only sent with explicit consent (future versions)
-- **Transparent**: Full source code is available for audit
-
-## What Data is Collected
-
-For each CLI command executed, StarForge collects:
-
-- **Command name**: Which command was run (e.g., `wallet`, `deploy`, `new`)
-- **Timestamp**: When the command was executed
-- **Success/Failure**: Whether the command completed successfully
-- **Duration**: How long the command took in milliseconds
-- **Anonymous ID**: A random UUID generated once per machine
-
-### Example Telemetry Event
-
-```json
-{
-  "timestamp": "2025-01-15T10:30:45Z",
-  "event": "deploy",
-  "properties": {
-    "success": true,
-    "duration_ms": 2500
-  },
-  "anonymous_id": "550e8400-e29b-41d4-a716-446655440000"
-}
-```
-
-### What We Do NOT Collect
-
-- ❌ Wallet addresses or secret keys
-- ❌ Contract code or source files
-- ❌ Configuration values (network URLs, custom networks)
-- ❌ Error messages or stack traces
-- ❌ User identity, email, or personal information
-- ❌ File paths or local system information
-
-## How to Disable Telemetry
-
-### Option 1: Configuration Command (Recommended)
-
-Disable telemetry permanently using the `config` command:
-
-```bash
-starforge config set telemetry false
-```
-
-View your current telemetry setting:
-
-```bash
-starforge config show
-# or
-starforge config get telemetry
-```
-
-Re-enable telemetry:
-
-```bash
-starforge config set telemetry true
-```
-
-### Option 2: Environment Variable
-
-Disable telemetry for a single command or session:
-
-```bash
-# Disable for a single command
-STARFORGE_TELEMETRY=0 starforge deploy --wasm my_contract.wasm
-
-# Disable for the entire shell session
-export STARFORGE_TELEMETRY=0
-starforge wallet list
-starforge deploy --wasm my_contract.wasm
-```
-
-Accepted values to disable telemetry:
-- `0`, `false`, `off`, `disabled`, `no`
-
-### Option 3: CI/CD Pipelines
-
-For automated environments, set the environment variable:
-
-```bash
-# In GitHub Actions
-env:
-  STARFORGE_TELEMETRY: "0"
-
-# In GitLab CI
-script:
-  - export STARFORGE_TELEMETRY=0
-  - starforge deploy --wasm my_contract.wasm
-```
-
-## Configuration Storage
-
-Your telemetry preference is stored in:
-
-```
-~/.starforge/config.toml
-```
-
-Example:
-
-```toml
-network = "testnet"
-telemetry_enabled = false
-
-[[wallets]]
-name = "deployer"
-public_key = "GABC...XYZ"
-# ...
-```
-
-Telemetry logs are stored in:
-
-```
-~/.starforge/data/telemetry.log
-~/.starforge/data/anonymous_id
-```
-
-These files are created only if telemetry is enabled.
-
-## Future: Remote Telemetry
-
-In future versions, StarForge may offer opt-in remote telemetry (sending anonymous data to a analytics service). This will be:
-
-- **Completely optional**: Requires explicit opt-in, never enabled by default
-- **Aggregated**: Only high-level statistics are sent (e.g., "10 deployments per day", not individual events)
-- **Auditable**: Full details published on what is collected and where it goes
-- **Respectable**: Always respects `STARFORGE_TELEMETRY=0` and config settings
-
-## Questions or Concerns?
-
-If you have privacy concerns or questions about telemetry:
-
-1. **Review the code**: Full source available at https://github.com/Josetic224/StarForge
-2. **Check the logs**: Inspect `~/.starforge/data/telemetry.log` to see what was collected
-3. **Disable it**: Use `starforge config set telemetry false` if you prefer not to participate
-4. **Report issues**: Open an issue on GitHub with any privacy concerns
-
-## Additional Privacy Resources
-
-- [PRIVACY_POLICY.md](./PRIVACY_POLICY.md) - Full privacy policy
-- [SECURITY_LOGGING_AUDIT.md](./SECURITY_LOGGING_AUDIT.md) - Security logging details
-- [GitHub Repository](https://github.com/Josetic224/StarForge) - Open source, fully auditable
diff --git a/TEMPLATE_MARKETPLACE.md b/TEMPLATE_MARKETPLACE.md
deleted file mode 100644
index 302dc891..00000000
--- a/TEMPLATE_MARKETPLACE.md
+++ /dev/null
@@ -1,467 +0,0 @@
-# Template Marketplace Feature
-
-## Overview
-
-The Template Marketplace feature enables community-contributed Soroban smart contract templates with versioning, discovery, and easy scaffolding. This allows developers to quickly bootstrap projects using battle-tested templates from the community.
-
-## Features
-
-### 1. Template Discovery
-Search and browse available templates by name, description, or tags:
-
-```bash
-# Search for DeFi templates
-starforge template search defi
-
-# Search with tag filtering
-starforge new contract --search defi --tags dex,amm
-
-# List all available templates
-starforge template list
-
-# View detailed information about a template
-starforge template show uniswap-v2
-```
-
-#### Relevance ranking, filters and explanations
-
-Search ranks results by **text relevance** first (name matches outweigh tag
-matches, which outweigh description matches), then by quality score, then by
-downloads. Each result explains *why* it matched so the list is easy to scan.
-
-```bash
-# Rank by relevance to the query
-starforge template search token
-
-# Require specific tags (a template must have all of them)
-starforge template search "" --tags defi,dex
-
-# Only verified templates
-starforge template search wallet --verified
-
-# Only high-quality templates (score 0-100)
-starforge template search defi --min-quality 70
-
-# List everything ranked by quality (empty query)
-starforge template search
-```
-
-Each result shows the matched fields and a relevance value, e.g.:
-
-```
-   1. uniswap-v2@1.0.0  [quality 92/100]  ✓ Verified  📖 Documented  ★ Popular (1240 downloads)
-      Matched: name, tag: defi (relevance 70)
-```
-
-### 2. Template Usage
-Scaffold new projects using marketplace templates:
-
-```bash
-# Use a marketplace template
-starforge new contract my-dex --template uniswap-v2 --from marketplace
-
-# Search and use in one workflow
-starforge new contract --search lending
-# Then use the found template
-starforge new contract my-lending --template lending-pool --from marketplace
-```
-
-### 3. Template Publishing
-Share your templates with the community:
-
-```bash
-# Publish a template
-starforge template publish ./my-template \
-  --name my-awesome-template \
-  --description "An awesome Soroban contract" \
-  --author "Your Name" \
-  --tags "defi,custom" \
-  --version "1.0.0"
-
-# Interactive publishing (prompts for missing info)
-starforge template publish ./my-template
-```
-
-### 4. Template Management
-Manage your local template registry:
-
-```bash
-# Initialize registry with example templates
-starforge template init
-
-# Remove a template
-starforge template remove my-template
-```
-
-## Template Structure
-
-### Required Files
-Every template must contain:
-- `Cargo.toml` - Rust package manifest
-- `src/` directory - Source code
-- `src/lib.rs` - Main contract file
-
-### Optional Files
-- `README.md` - Documentation
-- `.cargo/config.toml` - Cargo configuration
-- `tests/` - Test files
-
-### Template Placeholders
-Templates support automatic variable substitution:
-
-| Placeholder | Example Input | Example Output |
-|-------------|---------------|----------------|
-| `{{PROJECT_NAME}}` | my-project | my-project |
-| `{{PROJECT_NAME_SNAKE}}` | my-project | my_project |
-| `{{PROJECT_NAME_PASCAL}}` | my-project | MyProject |
-
-Example usage in `Cargo.toml`:
-```toml
-[package]
-name = "{{PROJECT_NAME}}"
-version = "0.1.0"
-```
-
-Example usage in `src/lib.rs`:
-```rust
-#[contract]
-pub struct {{PROJECT_NAME_PASCAL}};
-```
-
-## Template Sources
-
-Templates can be sourced from three locations:
-
-### 1. Git Repository
-```json
-{
-  "source": {
-    "type": "git",
-    "url": "https://github.com/user/repo",
-    "branch": "main"
-  }
-}
-```
-
-### 2. Local Path
-```json
-{
-  "source": {
-    "type": "local",
-    "path": "/path/to/template"
-  }
-}
-```
-
-### 3. Built-in
-```json
-{
-  "source": {
-    "type": "builtin",
-    "id": "hello-world"
-  }
-}
-```
-
-## Registry Format
-
-The template registry is stored in `~/.starforge/templates/registry.json`:
-
-```json
-{
-  "version": "1",
-  "templates": [
-    {
-      "name": "uniswap-v2",
-      "version": "1.0.0",
-      "description": "Uniswap V2 style AMM DEX",
-      "author": "Stellar Community",
-      "tags": ["defi", "dex", "amm"],
-      "source": {
-        "type": "git",
-        "url": "https://github.com/stellar/soroban-examples",
-        "branch": "main"
-      },
-      "created_at": "2025-01-01T00:00:00Z",
-      "updated_at": "2025-01-01T00:00:00Z",
-      "downloads": 42,
-      "verified": true
-    }
-  ]
-}
-```
-
-## Template Verification
-
-Templates can be marked as `verified: true` by maintainers. Verified templates:
-- Have been reviewed for security and quality
-- Follow Soroban best practices
-- Include proper documentation
-- Have working tests
-
-Verified templates appear first in search results with a ✓ badge.
-
-## Example Workflow
-
-### For Template Users
-
-1. **Discover templates:**
-   ```bash
-   starforge template search defi
-   ```
-
-2. **View template details:**
-   ```bash
-   starforge template show uniswap-v2
-   ```
-
-3. **Create project from template:**
-   ```bash
-   starforge new contract my-dex --template uniswap-v2 --from marketplace
-   ```
-
-4. **Build and deploy:**
-   ```bash
-   cd my-dex
-   stellar contract build
-   starforge deploy --wasm target/wasm32-unknown-unknown/release/my_dex.wasm
-   ```
-
-### For Template Authors
-
-1. **Create your template:**
-   ```bash
-   # Create a new contract as usual
-   starforge new contract my-template
-   cd my-template
-   
-   # Add your custom logic
-   # Replace hardcoded names with placeholders
-   ```
-
-2. **Add placeholders:**
-   ```rust
-   // In src/lib.rs
-   #[contract]
-   pub struct {{PROJECT_NAME_PASCAL}};
-   ```
-
-3. **Test the template:**
-   ```bash
-   cargo test
-   stellar contract build
-   ```
-
-4. **Publish to marketplace:**
-   ```bash
-   cd ..
-   starforge template publish ./my-template \
-     --name my-awesome-template \
-     --description "Does something awesome" \
-     --author "Your Name" \
-     --tags "defi,awesome" \
-     --version "1.0.0"
-   ```
-
-5. **Share with others:**
-   ```bash
-   # Others can now use it
-   starforge new contract test-project --template my-awesome-template --from marketplace
-   ```
-
-## Built-in Example Templates
-
-The marketplace includes several example templates:
-
-1. **uniswap-v2** - AMM DEX implementation
-2. **lending-pool** - Lending and borrowing protocol
-3. **governance** - DAO governance with voting
-4. **multisig-wallet** - Multi-signature wallet
-
-Initialize these with:
-```bash
-starforge template init
-```
-
-## Implementation Details
-
-### File Structure
-```
-src/
-├── commands/
-│   ├── new.rs          # Extended with marketplace support
-│   └── template.rs     # New template management commands
-├── utils/
-│   └── templates.rs    # Template registry and operations
-templates/
-├── registry.json       # Default template registry
-├── README.md          # Template documentation
-└── examples/
-    └── simple-counter/ # Example template
-```
-
-### Key Functions
-
-**Template Discovery:**
-- `search_templates(query, tags)` - Search with filtering
-- `get_template(name)` - Get specific template
-- `load_registry()` - Load template registry
-
-**Template Operations:**
-- `fetch_template(entry, dest)` - Download/copy template
-- `validate_template_structure(path)` - Validate template
-- `publish_template(...)` - Publish new template
-
-**Registry Management:**
-- `add_template(entry)` - Add to registry
-- `remove_template(name)` - Remove from registry
-- `save_registry(registry)` - Persist changes
-
-## Future Enhancements
-
-Potential improvements for future versions:
-
-1. **Remote Registry** - Central registry server for global template sharing
-2. **Template Versioning** - Support multiple versions of the same template
-3. **Template Updates** - Update existing templates to newer versions
-4. **Template Dependencies** - Templates that depend on other templates
-5. **Template Categories** - Organize templates into categories
-6. **Template Ratings** - Community ratings and reviews
-7. **Template Analytics** - Usage statistics and popularity metrics
-8. **Template CI/CD** - Automated testing and verification
-9. **Template Marketplace UI** - Web interface for browsing templates
-
-## Security Considerations
-
-When using templates from the marketplace:
-
-1. **Review Code** - Always review template code before using
-2. **Verify Source** - Check the template source (Git URL, author)
-3. **Use Verified** - Prefer verified templates when available
-4. **Test Thoroughly** - Test templates in a safe environment first
-5. **Update Dependencies** - Keep template dependencies up to date
-
-## Contributing
-
-To contribute templates to the official registry:
-
-1. Create a high-quality template following best practices
-2. Test thoroughly with multiple project names
-3. Add comprehensive documentation
-4. Submit a PR adding your template to `templates/registry.json`
-5. Include examples and usage instructions
-
-## Template Cache
-
-Marketplace templates are cloned with `--depth 1` (shallow clone) and stored in
-`~/.starforge/template-cache/<name>/`.  On subsequent runs the cached copy is
-reused, so no network round-trip occurs.
-
-### Cache location
-
-```
-~/.starforge/template-cache/
-├── token-standard/     ← cached after first use
-├── lending-pool/
-└── uniswap-v2/
-```
-
-### Force-refresh
-
-Pass `--force-refresh` to delete the cached copy and re-clone:
-
-```bash
-starforge new contract my-token --template token-standard --force-refresh
-```
-
-This is useful when the upstream template has been updated and you want the
-latest version.
-
-### How it works
-
-1. `fetch_template_cached` checks `~/.starforge/template-cache/<name>/`.
-2. If the directory exists and `--force-refresh` is not set, it is used as-is.
-3. If `--force-refresh` is set (or the directory does not exist), the old cache
-   is removed and the template is re-cloned with `git clone --depth 1`.
-4. `template_source_content` reads `src/lib.rs` from the cached directory and
-   returns it to the scaffolding step.
-
-## Quality Signals & Trust Indicators
-
-To help users identify dependable templates in a growing community catalog,
-each template carries lightweight quality metadata that is surfaced across the
-`list`, `search` and `show` commands.
-
-### Metadata fields
-
-| Field         | Meaning                                                        |
-|---------------|----------------------------------------------------------------|
-| `verified`    | Template has been vetted by maintainers                        |
-| `documented`  | Template ships user-facing documentation (e.g. a README)       |
-| `maintenance` | Maintenance state: `active`, `maintained`, `deprecated`, `unknown` |
-| `downloads`   | Usage metadata used as a proxy for community confidence        |
-
-Example registry entry:
-
-```json
-{
-  "name": "uniswap-v2",
-  "version": "1.0.0",
-  "verified": true,
-  "documented": true,
-  "maintenance": "active",
-  "downloads": 1240
-}
-```
-
-### Quality score
-
-Each template is assigned a `0-100` quality score blending the signals above:
-
-- Verified: `+40`
-- Documented: `+20`
-- Usage: up to `+30` (scaled by downloads, capped)
-- Maintenance: `active +10`, `maintained +5`, `deprecated -25`
-
-The score drives ranking in `starforge template search` (highest quality
-first, with raw downloads breaking ties) and is shown alongside trust badges
-such as `✓ Verified`, `📖 Documented`, `🟢 Actively maintained` and
-`★ Popular`. This makes trusted, well-documented and well-maintained templates
-easier to discover.
-
-## Installation Progress & Recovery
-
-Installing a marketplace template runs through three visible steps, each shown
-with a spinner that resolves to a check mark:
-
-```
-✓ Fetched template 'uniswap-v2'
-✓ Template structure is valid
-✓ Installed into 'my-dex'
-```
-
-### Safe rollback
-
-Installation is **atomic from the user's point of view**: if any step fails the
-partially-written files are removed automatically, so you never end up with a
-half-installed project directory.
-
-- The download is staged in a temporary directory that is always cleaned up.
-- The target project directory is only kept once every step succeeds; on
-  failure it is rolled back.
-
-### Actionable errors
-
-When a step fails, the error explains what went wrong and how to recover, e.g.:
-
-```
-Failed to fetch template 'uniswap-v2' from git:https://github.com/...
-  • Check your network connection and that `git` is installed.
-  • The partial download was rolled back automatically.
-```
-
-## Support
-
-For issues or questions:
-- GitHub Issues: https://github.com/YOUR_USERNAME/starforge/issues
-- Documentation: https://github.com/YOUR_USERNAME/starforge/blob/main/README.md
diff --git a/TEMPLATE_MARKETPLACE_TEST_COVERAGE.md b/TEMPLATE_MARKETPLACE_TEST_COVERAGE.md
deleted file mode 100644
index d96dffa5..00000000
--- a/TEMPLATE_MARKETPLACE_TEST_COVERAGE.md
+++ /dev/null
@@ -1,288 +0,0 @@
-# Template Marketplace Test Coverage Improvements
-
-## Summary
-
-Added comprehensive test coverage for the template marketplace feature, covering discovery, publishing, installation, and metadata handling workflows.
-
-## Test Files Added
-
-### 1. `tests/template_marketplace_comprehensive.rs`
-
-Comprehensive unit tests covering all aspects of template marketplace functionality.
-
-**Test Categories:**
-
-#### Discovery Tests (6 tests)
-
-- ✅ `test_search_by_exact_name_match()` - Exact template name matching
-- ✅ `test_search_by_tag_filtering()` - Single tag filtering
-- ✅ `test_search_by_multiple_tags()` - Multi-tag filtering (AND logic)
-- ✅ `test_search_verified_only_filter()` - Verified-only filtering
-- ✅ `test_search_quality_score_filtering()` - Quality score threshold filtering
-- ✅ `test_search_empty_query_lists_all()` - Empty query returns all templates
-
-#### Metadata Validation Tests (5 tests)
-
-- ✅ `test_validate_required_metadata_fields()` - Required fields present
-- ✅ `test_reject_template_with_missing_name()` - Reject empty name
-- ✅ `test_reject_template_with_invalid_version()` - Reject invalid semver
-- ✅ `test_validate_template_tags()` - Tags validation (non-empty, lowercase)
-- ✅ `test_validate_maintenance_status()` - Maintenance status labels
-
-#### Quality Score Tests (5 tests)
-
-- ✅ `test_quality_score_verified_bonus()` - Verified templates score higher (+40)
-- ✅ `test_quality_score_documented_bonus()` - Documented templates score higher (+20)
-- ✅ `test_quality_score_maintenance_status()` - Maintenance status affects score
-- ✅ `test_quality_score_capped_at_100()` - Score never exceeds 100
-
-#### Template Source Handling Tests (4 tests)
-
-- ✅ `test_git_source_with_branch()` - Git source with branch
-- ✅ `test_git_source_without_branch()` - Git source without branch
-- ✅ `test_local_source()` - Local path source
-- ✅ `test_builtin_source()` - Built-in template source
-
-#### Placeholder Substitution Tests (4 tests)
-
-- ✅ `test_placeholder_project_name()` - {{PROJECT_NAME}} substitution
-- ✅ `test_placeholder_project_name_snake()` - {{PROJECT_NAME_SNAKE}} substitution
-- ✅ `test_placeholder_project_name_pascal()` - {{PROJECT_NAME_PASCAL}} substitution
-- ✅ `test_multiple_placeholder_substitutions()` - Multiple placeholders in one file
-
-#### Installation Flow Tests (2 tests)
-
-- ✅ `test_installation_steps_order()` - Installation steps in correct order
-- ✅ `test_download_count_increment()` - Download count tracking
-
-#### Edge Case Tests (6 tests)
-
-- ✅ `test_search_with_special_characters_in_query()` - Special characters in search
-- ✅ `test_search_case_insensitive()` - Case-insensitive search
-- ✅ `test_empty_tags_list()` - Templates with no tags
-- ✅ `test_very_long_description()` - Very long descriptions (1000+ chars)
-- ✅ `test_zero_downloads()` - New templates with zero downloads
-- ✅ `test_very_high_download_count()` - Very high download counts (u32::MAX)
-
-**Total: 32 comprehensive unit tests**
-
-### 2. `tests/template_marketplace_workflows.rs`
-
-Integration tests for complete marketplace workflows.
-
-**Test Categories:**
-
-#### Publish Workflow Tests (5 tests)
-
-- ✅ `test_publish_new_template_success()` - Successful template publication
-- ✅ `test_publish_template_with_empty_name_fails()` - Reject empty name
-- ✅ `test_publish_template_with_empty_version_fails()` - Reject empty version
-- ✅ `test_publish_template_with_empty_description_fails()` - Reject empty description
-- ✅ `test_publish_duplicate_template_fails()` - Reject duplicate names
-
-#### Search Workflow Tests (5 tests)
-
-- ✅ `test_search_after_publish()` - Search finds published templates
-- ✅ `test_search_by_description()` - Search by description text
-- ✅ `test_search_by_tag()` - Search by tag
-- ✅ `test_search_no_results()` - Empty results for non-matching query
-- ✅ `test_search_multiple_results()` - Multiple results for broad query
-
-#### Install Workflow Tests (3 tests)
-
-- ✅ `test_get_template_for_installation()` - Retrieve template for installation
-- ✅ `test_get_nonexistent_template_fails()` - Fail gracefully for missing template
-- ✅ `test_increment_download_count_on_install()` - Track downloads on installation
-
-#### Complete Workflow Tests (2 tests)
-
-- ✅ `test_publish_search_install_workflow()` - End-to-end: publish → search → install
-- ✅ `test_multiple_templates_workflow()` - Multiple templates with different tags
-
-#### Removal Workflow Tests (3 tests)
-
-- ✅ `test_remove_template()` - Remove existing template
-- ✅ `test_remove_nonexistent_template_fails()` - Fail gracefully for missing template
-- ✅ `test_remove_and_republish()` - Remove and republish with new version
-
-#### Error Recovery Tests (2 tests)
-
-- ✅ `test_invalid_metadata_prevents_publication()` - Invalid metadata blocks publication
-- ✅ `test_registry_consistency_after_failed_operations()` - Registry stays consistent after errors
-
-**Total: 20 integration workflow tests**
-
-## Test Coverage Summary
-
-### Discovery & Search (11 tests)
-
-- Exact name matching
-- Tag-based filtering (single and multiple)
-- Verified-only filtering
-- Quality score filtering
-- Empty query handling
-- Case-insensitive search
-- Special character handling
-- Search after publish
-- Search by description
-- Search by tag
-- Multiple results
-
-### Publishing (5 tests)
-
-- Successful publication
-- Metadata validation (name, version, description)
-- Duplicate prevention
-- Invalid metadata rejection
-- Registry consistency
-
-### Installation (4 tests)
-
-- Template retrieval
-- Download count tracking
-- Missing template handling
-- Complete install workflow
-
-### Metadata Handling (10 tests)
-
-- Required fields validation
-- Version format validation
-- Tag validation
-- Maintenance status validation
-- Quality score calculation
-- Placeholder substitution (3 types)
-- Source type handling (Git, Local, Builtin)
-
-### Edge Cases (8 tests)
-
-- Special characters
-- Case sensitivity
-- Empty tags
-- Very long descriptions
-- Zero downloads
-- Very high download counts
-- Invalid metadata
-- Registry consistency after errors
-
-## Acceptance Criteria Met
-
-✅ **Template workflows are covered by automated tests**
-
-- 52 total tests covering all major workflows
-- Discovery, publishing, installation, and removal flows tested
-- End-to-end integration tests verify complete workflows
-
-✅ **Broken marketplace metadata is caught early**
-
-- Metadata validation tests catch missing/invalid fields
-- Quality score tests ensure proper scoring
-- Error recovery tests verify graceful failure handling
-- Registry consistency tests prevent corruption
-
-✅ **Installation and search behavior are reliable**
-
-- Search tests verify correct filtering and ranking
-- Installation tests verify download tracking
-- Workflow tests verify end-to-end reliability
-- Edge case tests verify robustness
-
-## Test Execution
-
-Run all marketplace tests:
-
-```bash
-cargo test --test template_marketplace_comprehensive
-cargo test --test template_marketplace_workflows
-```
-
-Run specific test category:
-
-```bash
-# Discovery tests
-cargo test --test template_marketplace_comprehensive test_search
-
-# Publishing tests
-cargo test --test template_marketplace_workflows test_publish
-
-# Installation tests
-cargo test --test template_marketplace_workflows test_install
-```
-
-## Coverage Areas
-
-### ✅ Covered
-
-- Template discovery and search
-- Tag-based filtering
-- Quality scoring
-- Metadata validation
-- Placeholder substitution
-- Template publishing
-- Template installation
-- Download tracking
-- Error handling
-- Edge cases
-- Complete workflows
-
-### 🔄 Partially Covered (by existing tests)
-
-- Git clone operations (existing CLI smoke tests)
-- Template structure validation (existing tests)
-- Registry JSON parsing (existing tests)
-- Caching behavior (documented but not tested)
-
-### 📝 Future Enhancements
-
-- Network failure scenarios
-- Concurrent operations
-- Registry corruption recovery
-- Large template downloads
-- Cache expiration
-- Permission errors
-- Disk space exhaustion
-
-## Key Testing Patterns
-
-### 1. Metadata Validation
-
-Tests ensure all required fields are present and valid before publication.
-
-### 2. Search Ranking
-
-Tests verify templates are ranked by relevance, quality, and downloads.
-
-### 3. Error Prevention
-
-Tests ensure invalid operations fail gracefully without corrupting registry.
-
-### 4. Workflow Completeness
-
-Integration tests verify end-to-end workflows work correctly.
-
-### 5. Edge Case Handling
-
-Tests cover special characters, very long strings, extreme values, etc.
-
-## Benefits
-
-1. **Reliability**: Comprehensive tests catch regressions early
-2. **Confidence**: Developers can refactor with confidence
-3. **Documentation**: Tests serve as usage examples
-4. **Quality**: Broken metadata is caught before affecting users
-5. **Maintainability**: Clear test structure makes future changes easier
-
-## Related Files
-
-- `src/utils/templates.rs` - Template registry implementation
-- `src/commands/template.rs` - Template command handlers
-- `src/commands/new.rs` - Template scaffolding
-- `templates/registry.json` - Template registry data
-- `TEMPLATE_MARKETPLACE.md` - Feature documentation
-
-## Notes
-
-- Tests use mock structures to avoid filesystem dependencies
-- Tests are isolated and can run in any order
-- All tests are deterministic and reproducible
-- No external network calls required
-- Tests run quickly (< 1 second total)
diff --git a/WALLET_ENCRYPTION_FIX.md b/WALLET_ENCRYPTION_FIX.md
deleted file mode 100644
index c9bdad68..00000000
--- a/WALLET_ENCRYPTION_FIX.md
+++ /dev/null
@@ -1,221 +0,0 @@
-# Wallet Encryption and KDF Integration Fix
-
-## Summary
-
-Fixed critical issues in wallet encryption and Key Derivation Function (KDF) integration that prevented encrypted wallets with custom KDF parameters from being validated and used correctly.
-
-## Issues Fixed
-
-### 1. **CRITICAL: validate_secret_key() Rejected 5-Part KDF Bundles**
-
-**Location**: `src/utils/config.rs:99-115`
-
-**Problem**:
-
-- The validation function only accepted 3-part encrypted bundles (legacy format: `salt:nonce:ciphertext`)
-- When `encrypt_secret()` created 5-part bundles with custom KDF parameters (`salt:nonce:ciphertext:mem:iterations`), validation would fail
-- This broke wallet rotation with custom KDF parameters and prevented encrypted wallets from being stored/loaded
-
-**Root Cause**:
-
-```rust
-// OLD CODE - Only validated 3-part bundles
-if parts.len() != 3 {
-    anyhow::bail!("Invalid encrypted secret bundle format");
-}
-```
-
-**Solution**:
-
-```rust
-// NEW CODE - Validates both 3-part and 5-part bundles
-if parts.len() != 3 && parts.len() != 5 {
-    anyhow::bail!("Invalid encrypted secret bundle format: expected 3 or 5 parts, got {}", parts.len());
-}
-
-// Validate base64 parts (first 3 are always base64)
-for i in 0..3 {
-    BASE64.decode(parts[i])
-        .map_err(|_| anyhow::anyhow!("Invalid base64 in encrypted secret bundle at part {}", i))?;
-}
-
-// If 5-part bundle, validate KDF parameters are valid u32
-if parts.len() == 5 {
-    parts[3].parse::<u32>()
-        .map_err(|_| anyhow!("Invalid KDF memory cost: must be a valid u32"))?;
-    parts[4].parse::<u32>()
-        .map_err(|_| anyhow!("Invalid KDF iteration count: must be a valid u32"))?;
-}
-```
-
-**Impact**:
-
-- ✅ Encrypted wallets with custom KDF parameters now pass validation
-- ✅ Wallet rotation with `--mem` and `--iterations` flags now works
-- ✅ Legacy 3-part bundles continue to work (backward compatible)
-
-### 2. **Inconsistent Encrypted Bundle Format Handling**
-
-**Location**: `src/utils/crypto.rs:250-281` vs `src/utils/config.rs:99-115`
-
-**Problem**:
-
-- `parse_encrypted_bundle()` correctly handled both 3-part and 5-part formats
-- `validate_secret_key()` only handled 3-part format
-- This inconsistency meant bundles could be encrypted/decrypted but fail validation
-
-**Solution**:
-
-- Updated `validate_secret_key()` to match `parse_encrypted_bundle()` behavior
-- Both functions now consistently handle 3-part (legacy) and 5-part (with KDF) formats
-
-## Affected Code Paths
-
-### Wallet Creation
-
-**File**: `src/commands/wallet.rs:521`
-
-```rust
-let secret_to_store = if encrypt {
-    let pwd = crypto::prompt_password("Set a secure passphrase to encrypt the wallet", true)?;
-    crypto::encrypt_secret(&pwd, &secret_key, None)?  // Uses default KDF
-} else {
-    secret_key.clone()
-};
-```
-
-✅ Now works correctly - creates 3-part bundle with default KDF
-
-### Wallet Rotation
-
-**File**: `src/commands/wallet.rs:1008`
-
-```rust
-let secret_to_store = if encrypt {
-    let pwd = crypto::prompt_password("Set a secure passphrase to encrypt the rotated wallet", true)?;
-    crypto::encrypt_secret(&pwd, &secret_key, kdf_options(mem, iterations).as_ref())?
-} else {
-    secret_key.clone()
-};
-```
-
-✅ Now works correctly - creates 5-part bundle with custom KDF when `--mem` or `--iterations` flags are used
-
-### Wallet Export/Import
-
-**Files**: `src/commands/wallet.rs:1095, 1152`
-
-- Export: Uses `None` for KDF (creates 3-part bundle)
-- Import: Uses `None` for KDF (creates 3-part bundle)
-  ✅ Both now work correctly with validation
-
-### Secret Decryption
-
-**Files**: `src/commands/contract.rs:220`, `src/commands/tx.rs:212, 405`
-
-- All use `decrypt_secret()` which already correctly handled both formats
-  ✅ No changes needed - already working
-
-## Encryption Flow
-
-### Legacy Format (3-part, default KDF)
-
-```
-Password → Argon2(default params) → Key → AES-256-GCM → Ciphertext
-Bundle: base64(salt):base64(nonce):base64(ciphertext)
-```
-
-### Enhanced Format (5-part, custom KDF)
-
-```
-Password → Argon2(custom mem/iterations) → Key → AES-256-GCM → Ciphertext
-Bundle: base64(salt):base64(nonce):base64(ciphertext):mem:iterations
-```
-
-## Test Coverage
-
-### Existing Tests (src/utils/crypto.rs)
-
-- ✅ `test_encryption_decryption()` - Basic encrypt/decrypt
-- ✅ `custom_kdf_params_roundtrip()` - Tests 5-part bundle creation and decryption
-- ✅ `legacy_three_part_bundle_uses_default_kdf()` - Tests 3-part bundle
-- ✅ Passphrase strength tests (8 tests)
-
-### New Integration Tests (tests/wallet_encryption_integration.rs)
-
-- ✅ `test_validate_encrypted_wallet_with_kdf_params()` - Validates 5-part bundles
-- ✅ `test_validate_legacy_encrypted_wallet()` - Validates 3-part bundles
-- ✅ `test_wallet_rotation_with_kdf_options()` - Tests rotation with custom KDF
-- ✅ `test_wallet_rotation_with_default_kdf()` - Tests rotation with default KDF
-- ✅ `test_reject_invalid_kdf_parameters()` - Tests error handling
-- ✅ `test_encrypted_bundle_format_consistency()` - Tests format validation
-- ✅ `test_wallet_secret_storage_formats()` - Tests plaintext vs encrypted storage
-- ✅ `test_wallet_rotation_history()` - Tests rotation tracking
-
-## Acceptance Criteria Met
-
-✅ **Encrypted wallet creation succeeds without compile or runtime errors**
-
-- Fixed validation to accept 5-part KDF bundles
-- Wallet creation with encryption now works end-to-end
-
-✅ **Wallet rotation and secret handling work as documented**
-
-- Rotation with custom KDF parameters now works
-- Secret validation accepts both legacy and enhanced formats
-- Decryption works for both formats
-
-✅ **Relevant tests pass with encryption enabled**
-
-- All existing crypto tests pass
-- New integration tests verify the complete flow
-- Backward compatibility maintained for legacy 3-part bundles
-
-## Backward Compatibility
-
-✅ **Fully backward compatible**
-
-- Legacy 3-part encrypted bundles continue to work
-- Existing wallets can be rotated with new KDF parameters
-- No migration needed for existing encrypted wallets
-
-## Security Considerations
-
-- ✅ KDF parameters are validated as u32 to prevent injection attacks
-- ✅ Base64 validation ensures bundle integrity
-- ✅ Argon2 parameters are validated by the crypto library
-- ✅ No changes to encryption/decryption algorithms
-- ✅ Password validation remains strict (12+ chars, strength checking)
-
-## Files Modified
-
-1. **src/utils/config.rs** - Fixed `validate_secret_key()` function
-2. **tests/wallet_encryption_integration.rs** - Added comprehensive integration tests
-
-## Verification Steps
-
-To verify the fix works:
-
-```bash
-# Run all crypto tests
-cargo test --lib utils::crypto
-
-# Run wallet encryption integration tests
-cargo test --test wallet_encryption_integration
-
-# Test wallet creation with encryption
-starforge wallet create --name test-wallet --encrypt
-
-# Test wallet rotation with custom KDF
-starforge wallet rotate --name test-wallet --encrypt --mem 32768 --iterations 4
-
-# Test wallet export/import
-starforge wallet export --name test-wallet
-starforge wallet import --file exported-wallet.json
-```
-
-## Related Issues
-
-- Wallet encryption support is a core trust and security feature
-- Broken behavior undermined user confidence in encrypted wallet functionality
-- This fix restores full encryption support for developers using secure storage
diff --git a/WALLET_LIFECYCLE_E2E_TEST_COVERAGE.md b/WALLET_LIFECYCLE_E2E_TEST_COVERAGE.md
deleted file mode 100644
index f95c86bc..00000000
--- a/WALLET_LIFECYCLE_E2E_TEST_COVERAGE.md
+++ /dev/null
@@ -1,329 +0,0 @@
-# Wallet Lifecycle End-to-End Test Coverage
-
-## Summary
-
-Added comprehensive end-to-end tests for wallet lifecycle commands, covering creation, listing, showing, funding, removal, and rotation operations with full error handling and edge case coverage.
-
-## Test Files Added
-
-### 1. `tests/wallet_lifecycle_e2e.rs`
-
-End-to-end integration tests for complete wallet workflows.
-
-**Test Categories:**
-
-#### Wallet Creation Tests (7 tests)
-
-- ✅ `test_create_wallet_basic()` - Basic wallet creation
-- ✅ `test_create_wallet_with_custom_network()` - Create with custom network
-- ✅ `test_create_wallet_empty_name_fails()` - Reject empty name
-- ✅ `test_create_wallet_invalid_name_characters()` - Reject invalid characters
-- ✅ `test_create_wallet_invalid_public_key()` - Reject invalid public key
-- ✅ `test_create_wallet_duplicate_name_fails()` - Prevent duplicates
-- ✅ `test_create_multiple_wallets()` - Create multiple wallets
-
-#### Wallet Listing Tests (2 tests)
-
-- ✅ `test_list_wallets_empty()` - List empty wallet set
-- ✅ `test_list_wallets_multiple()` - List multiple wallets
-
-#### Wallet Show Tests (3 tests)
-
-- ✅ `test_show_wallet_exists()` - Show existing wallet
-- ✅ `test_show_wallet_not_found()` - Handle missing wallet
-- ✅ `test_show_wallet_displays_funding_status()` - Display funding status
-
-#### Wallet Funding Tests (3 tests)
-
-- ✅ `test_fund_wallet_success()` - Successful funding
-- ✅ `test_fund_wallet_not_found()` - Handle missing wallet
-- ✅ `test_fund_wallet_mainnet_fails()` - Reject mainnet funding
-
-#### Wallet Removal Tests (3 tests)
-
-- ✅ `test_remove_wallet_success()` - Remove wallet
-- ✅ `test_remove_wallet_not_found()` - Handle missing wallet
-- ✅ `test_remove_wallet_preserves_others()` - Preserve other wallets
-
-#### Wallet Rename Tests (3 tests)
-
-- ✅ `test_rename_wallet_success()` - Rename wallet
-- ✅ `test_rename_wallet_not_found()` - Handle missing wallet
-- ✅ `test_rename_wallet_duplicate_name_fails()` - Prevent duplicate names
-
-#### Wallet Rotation Tests (3 tests)
-
-- ✅ `test_rotate_wallet_success()` - Rotate keypair
-- ✅ `test_rotate_wallet_not_found()` - Handle missing wallet
-- ✅ `test_rotate_wallet_invalid_key()` - Reject invalid key
-
-#### Complete Lifecycle Workflow Tests (2 tests)
-
-- ✅ `test_complete_wallet_lifecycle()` - Full workflow: create → list → show → fund → rotate → remove
-- ✅ `test_multiple_wallets_independent_operations()` - Multiple wallets with independent operations
-
-#### Error Recovery Tests (2 tests)
-
-- ✅ `test_wallet_config_consistency_after_failed_operations()` - Config stays consistent after errors
-- ✅ `test_wallet_operations_preserve_metadata()` - Metadata preserved through operations
-
-**Total: 31 end-to-end tests**
-
-### 2. `tests/wallet_error_handling.rs`
-
-Comprehensive error handling and edge case tests.
-
-**Test Categories:**
-
-#### Invalid Input Tests (4 tests)
-
-- ✅ `test_create_wallet_with_empty_name()` - Reject empty name
-- ✅ `test_create_wallet_with_special_characters_in_name()` - Reject special chars
-- ✅ `test_create_wallet_with_valid_name_characters()` - Accept valid chars
-- ✅ `test_create_wallet_with_invalid_public_key_format()` - Reject invalid keys
-
-#### Secret Key Validation Tests (2 tests)
-
-- ✅ `test_create_wallet_with_invalid_secret_key_format()` - Reject invalid secrets
-- ✅ `test_create_wallet_with_valid_secret_key_format()` - Accept valid secrets
-
-#### Duplicate Wallet Tests (2 tests)
-
-- ✅ `test_create_duplicate_wallet_fails()` - Prevent duplicates
-- ✅ `test_duplicate_check_is_case_sensitive()` - Case-sensitive checking
-
-#### Missing Wallet Tests (3 tests)
-
-- ✅ `test_get_nonexistent_wallet()` - Handle missing wallet
-- ✅ `test_fund_nonexistent_wallet()` - Handle missing wallet on fund
-- ✅ `test_remove_nonexistent_wallet()` - Handle missing wallet on remove
-
-#### Secret Key Decryption Tests (6 tests)
-
-- ✅ `test_decrypt_plaintext_secret()` - Decrypt plaintext secret
-- ✅ `test_decrypt_encrypted_secret_with_valid_password()` - Decrypt with valid password
-- ✅ `test_decrypt_encrypted_secret_with_empty_password()` - Reject empty password
-- ✅ `test_decrypt_encrypted_secret_with_short_password()` - Reject short password
-- ✅ `test_decrypt_nonexistent_wallet()` - Handle missing wallet
-- ✅ `test_decrypt_wallet_without_secret_key()` - Handle missing secret
-
-#### Network-Specific Error Tests (2 tests)
-
-- ✅ `test_fund_wallet_on_mainnet_fails()` - Reject mainnet funding
-- ✅ `test_fund_wallet_on_testnet_succeeds()` - Allow testnet funding
-
-#### Edge Case Tests (4 tests)
-
-- ✅ `test_wallet_name_with_numbers()` - Accept numeric names
-- ✅ `test_wallet_name_with_dashes_and_underscores()` - Accept dashes/underscores
-- ✅ `test_very_long_wallet_name()` - Handle very long names
-- ✅ `test_wallet_state_consistency_after_errors()` - State consistency
-
-#### State Consistency Tests (1 test)
-
-- ✅ `test_multiple_errors_dont_corrupt_state()` - Multiple errors don't corrupt state
-
-**Total: 24 error handling tests**
-
-## Test Coverage Summary
-
-### Wallet Operations (31 tests)
-
-- Create: 7 tests
-- List: 2 tests
-- Show: 3 tests
-- Fund: 3 tests
-- Remove: 3 tests
-- Rename: 3 tests
-- Rotate: 3 tests
-- Complete workflows: 2 tests
-- Error recovery: 2 tests
-
-### Error Handling (24 tests)
-
-- Invalid inputs: 4 tests
-- Secret key validation: 2 tests
-- Duplicate prevention: 2 tests
-- Missing wallet handling: 3 tests
-- Decryption errors: 6 tests
-- Network errors: 2 tests
-- Edge cases: 4 tests
-- State consistency: 1 test
-
-### Total: 55 comprehensive wallet lifecycle tests
-
-## Acceptance Criteria Met
-
-✅ **Main wallet commands operate correctly in test scenarios**
-
-- All major wallet commands tested (create, list, show, fund, remove, rename, rotate)
-- Real command execution paths exercised
-- Multiple wallet scenarios tested
-- Network-specific behavior validated
-
-✅ **Errors are surfaced clearly and predictably**
-
-- Invalid inputs caught with descriptive errors
-- Missing wallets handled gracefully
-- Network errors properly reported
-- Decryption failures handled
-- Duplicate prevention enforced
-
-✅ **Regression coverage exists for common wallet workflows**
-
-- Complete lifecycle workflow tested (create → fund → rotate → remove)
-- Multiple wallet independence verified
-- Metadata preservation validated
-- State consistency after errors confirmed
-- Edge cases covered (long names, special characters, etc.)
-
-## Test Execution
-
-Run all wallet lifecycle tests:
-
-```bash
-cargo test --test wallet_lifecycle_e2e
-cargo test --test wallet_error_handling
-```
-
-Run specific test category:
-
-```bash
-# Creation tests
-cargo test --test wallet_lifecycle_e2e test_create
-
-# Funding tests
-cargo test --test wallet_lifecycle_e2e test_fund
-
-# Error handling
-cargo test --test wallet_error_handling test_decrypt
-```
-
-Run with output:
-
-```bash
-cargo test --test wallet_lifecycle_e2e -- --nocapture
-```
-
-## Coverage Areas
-
-### ✅ Fully Covered
-
-- Wallet creation with all flag combinations
-- Wallet listing and showing
-- Wallet funding on testnet
-- Wallet removal and renaming
-- Wallet rotation with keypair replacement
-- Complete end-to-end workflows
-- Error handling for invalid inputs
-- Duplicate prevention
-- Missing wallet handling
-- Secret key decryption
-- Network-specific behavior
-- State consistency
-- Metadata preservation
-- Edge cases (long names, special chars, etc.)
-
-### 🔄 Partially Covered (by existing tests)
-
-- Hardware wallet integration (requires device)
-- Multi-signature operations (separate test suite)
-- Export/import workflows (separate test suite)
-- Encryption with custom KDF (separate test suite)
-
-### 📝 Future Enhancements
-
-- Network failure simulation
-- Concurrent wallet operations
-- Large wallet collections (1000+ wallets)
-- Horizon API timeout handling
-- Friendbot rate limiting
-- Transaction signing workflows
-- Account merge operations
-- Hardware wallet device detection
-
-## Key Testing Patterns
-
-### 1. Wallet Creation
-
-- Validates name format (alphanumeric, dash, underscore)
-- Validates public key format (starts with G, 56 chars)
-- Validates secret key format (starts with S or encrypted)
-- Prevents duplicate names
-- Supports custom networks
-
-### 2. Wallet Operations
-
-- List shows all wallets
-- Show displays wallet details and funding status
-- Fund marks wallet as funded (testnet only)
-- Remove deletes wallet
-- Rename changes wallet name
-- Rotate replaces keypair
-
-### 3. Error Handling
-
-- Empty inputs rejected
-- Invalid formats rejected
-- Missing wallets handled
-- Duplicate names prevented
-- Network restrictions enforced
-- State consistency maintained
-
-### 4. Workflow Completeness
-
-- Create → List → Show → Fund → Rotate → Remove
-- Multiple wallets operate independently
-- Metadata preserved through operations
-- Funding status tracked correctly
-
-## Benefits
-
-1. **Reliability**: Comprehensive tests catch regressions early
-2. **Confidence**: Developers can refactor with confidence
-3. **Documentation**: Tests serve as usage examples
-4. **Quality**: Broken workflows caught before release
-5. **Maintainability**: Clear test structure for future changes
-
-## Related Files
-
-- `src/commands/wallet.rs` - Wallet command handlers
-- `src/utils/config.rs` - Wallet configuration
-- `src/utils/crypto.rs` - Encryption/decryption
-- `src/utils/horizon.rs` - Horizon integration
-- `src/utils/mnemonic.rs` - BIP39 support
-- `tests/wallet_encryption_integration.rs` - Encryption tests
-
-## Notes
-
-- Tests use mock structures to avoid filesystem dependencies
-- Tests are isolated and can run in any order
-- All tests are deterministic and reproducible
-- No external network calls required
-- Tests run quickly (< 1 second total)
-- Error messages are clear and actionable
-
-## Test Statistics
-
-- **Total Tests**: 55
-- **Test Files**: 2
-- **Coverage Areas**: 8 (create, list, show, fund, remove, rename, rotate, workflows)
-- **Error Scenarios**: 24
-- **Edge Cases**: 4
-- **Execution Time**: < 1 second
-- **Lines of Test Code**: ~1000
-
-## Regression Prevention
-
-These tests prevent regressions in:
-
-- Wallet creation logic
-- Wallet listing and filtering
-- Wallet funding operations
-- Wallet removal and cleanup
-- Wallet renaming
-- Wallet rotation
-- Error handling
-- State management
-- Metadata preservation
-- Network-specific behavior
diff --git a/deny.toml b/deny.toml
index ef12360e..fcef9dd5 100644
--- a/deny.toml
+++ b/deny.toml
@@ -20,6 +20,9 @@ ignore = [
     "RUSTSEC-2026-0104",
     # number_prefix unmaintained; pulled in via indicatif. No safe upgrade.
     "RUSTSEC-2025-0119",
+    # rustls-pemfile unmaintained; pulled in transitively via reqwest's rustls-tls.
+    # Functionality moved into rustls-pki-types; no upgrade path on reqwest 0.11.
+    "RUSTSEC-2025-0134",
 ]
 
 [licenses]
diff --git a/docs/COMMAND_REFERENCE.md b/docs/COMMAND_REFERENCE.md
deleted file mode 100644
index 09c46af1..00000000
--- a/docs/COMMAND_REFERENCE.md
+++ /dev/null
@@ -1,182 +0,0 @@
-# StarForge Command Reference
-
-Browse every top-level command and its most important flags. For wallet, template, and transaction details see also [API_REFERENCE.md](../API_REFERENCE.md).
-
-## Global options
-
-| Flag | Description |
-|------|-------------|
-| `-q, --quiet` | Suppress banner and decorative output |
-| `--log-format human\|json` | Structured log format (default: `human`) |
-| `--log-dir <PATH>` | Optional rotating log directory |
-| `-h, --help` | Command help |
-| `-V, --version` | CLI version |
-
-## Quick workflow examples
-
-```bash
-# Environment check
-starforge info
-
-# Wallet + network
-starforge wallet create deployer --fund
-starforge network show
-
-# Templates + deploy
-starforge template list
-starforge deploy --wasm ./contract.wasm --wallet deployer --simulate
-
-# Guided tutorial
-starforge tutorial start hello-world
-starforge tutorial next
-```
-
----
-
-## `wallet`
-
-| Subcommand | Purpose |
-|------------|---------|
-| `create <NAME>` | Create and store a keypair (`--fund`, `--encrypt`, `--mnemonic`) |
-| `list` | List saved wallets |
-| `show <NAME>` | Show wallet metadata and balance (`--reveal`) |
-| `fund <NAME>` | Fund via Friendbot when configured |
-| `remove <NAME>` | Delete a saved wallet |
-| `rename <OLD> <NEW>` | Rename a wallet entry |
-| `merge` | Account merge (`--from`, `--to`, `--yes`) |
-| `rotate <NAME>` | Rotate keys in place (`--fund`, `--encrypt`, `--mem`, `--iterations`) |
-| `export <NAME> --output <FILE>` | Export backup JSON |
-| `import` | Import from file or `--mnemonic` |
-| `sign` | Sign a payload with a saved wallet |
-| `multisig` | Multisig helpers (create, add-signer, submit) |
-
----
-
-## `new`
-
-| Subcommand | Purpose |
-|------------|---------|
-| `contract <NAME>` | Scaffold Soroban contract (`--template`) |
-| `dapp <NAME>` | Scaffold Stellar dApp frontend |
-
----
-
-## `contract` / `inspect` / `deploy`
-
-| Command | Purpose |
-|---------|---------|
-| `contract invoke` | Invoke contract function (`--simulate`) |
-| `contract inspect` | Inspect deployed contract metadata |
-| `contract generate-bindings <WASM_FILE>` | Generate Rust or TypeScript wrappers (`--lang rust\|ts`) |
-| `inspect storage` | Deep storage inspection |
-| `deploy --wasm <FILE>` | Prepare Soroban deployment |
-
-**`deploy` flags:** `--network`, `--wallet`, `--optimize`, `--simulate`, `--yes`, `--execute`
-
-```bash
-starforge deploy --wasm target/wasm32v1-none/release/token.wasm \
-  --wallet deployer --network testnet --simulate
-
-starforge deploy --wasm ./token.wasm --optimize --yes --execute
-
-starforge contract generate-bindings ./token.wasm --lang rust
-```
-
----
-
-## `network` / `node`
-
-| Command | Purpose |
-|---------|---------|
-| `network show` | Show configured networks |
-| `network switch <NAME>` | Set active network |
-| `network add` | Add custom Horizon/RPC/Friendbot endpoints |
-| `network test` | Connectivity probe |
-| `node start` | Start local quickstart devnet (`--port`) |
-
----
-
-## `tx`
-
-| Subcommand | Purpose |
-|------------|---------|
-| `tx send` | Payment (`--from`, `--to`, `--amount`, `--asset`) |
-| `tx batch` | Batch operations from JSON (`--file`, `--from`) |
-| `tx history <PUBKEY>` | Recent transactions (`--limit`, `--cursor`, `--successful`) |
-
----
-
-## `template`
-
-| Subcommand | Purpose |
-|------------|---------|
-| `template list` | List marketplace templates |
-| `template search <QUERY>` | Search templates |
-| `template show <ID>` | Template details |
-| `template init <ID> <DIR>` | Scaffold from template |
-| `template publish` | Publish template metadata |
-| `template remove <ID>` | Remove local template entry |
-
----
-
-## `gas`
-
-| Subcommand | Purpose |
-|------------|---------|
-| `gas analyze <WASM>` | Heuristic gas/cpu report (`--network`) |
-| `gas optimize --target <IN> --output <OUT>` | Lightweight WASM shrink pass |
-| `gas diff <OLD> <NEW>` | Compare estimated costs |
-
----
-
-## `upgrade`
-
-| Subcommand | Purpose |
-|------------|---------|
-| `upgrade prepare` | Validate upgrade WASM (`--contract-id`, `--wasm`) |
-| `upgrade propose` | Create governance proposal |
-| `upgrade list` / `status` | List pending proposals |
-| `upgrade approve` | Approve proposal |
-| `upgrade execute` | Execute approved upgrade |
-| `upgrade rollback` | Roll back contract version |
-| `upgrade history` | Show upgrade history |
-
----
-
-## `tutorial`
-
-| Subcommand | Purpose |
-|------------|---------|
-| `tutorial list` | List tutorials under `./tutorials/` |
-| `tutorial start <SLUG>` | Begin guided flow (resets progress) |
-| `tutorial next` | Mark step complete and show next milestone |
-| `tutorial status` | Show active tutorial and current step |
-
----
-
-## Utility commands
-
-| Command | Purpose |
-|---------|---------|
-| `info` | Version, config path, network health, Stellar CLI detection |
-| `shell` | Interactive local REPL with persistent history and tab completion |
-| `monitor` | Live event/threshold monitoring |
-| `benchmark` | CLI performance benchmarks |
-| `test` | Soroban WASM test runner |
-| `lint <PATH>` | Static Soroban source lint |
-| `plugin install/list/run` | Dynamic plugin management |
-| `completions <SHELL>` | bash/zsh/fish completions |
-
----
-
-## External plugins
-
-```bash
-starforge plugin install my-plugin --path ./libmy_plugin.so
-starforge my-plugin <args>
-```
-
-## See also
-
-- [API_REFERENCE.md](../API_REFERENCE.md) — detailed per-command examples and output samples
-- [DEVELOPER_GUIDE.md](../DEVELOPER_GUIDE.md) — contributing and local development
diff --git a/examples/plugin_example.md b/examples/plugin_example.md
deleted file mode 100644
index 1cbe0b51..00000000
--- a/examples/plugin_example.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# StarForge Plugin Example
-
-Build a plugin using the `starforge-plugin-sdk` crate.
-
-## Setup
-
-Create a new crate:
-
-```bash
-cargo new --lib my-starforge-plugin
-cd my-starforge-plugin
-```
-
-Add to `Cargo.toml`:
-
-```toml
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-starforge-plugin-sdk = { path = "../crates/starforge-plugin-sdk" }
-```
-
-## Implement the plugin
-
-```rust
-use starforge_plugin_sdk::{export_plugin, PluginMeta, StarForgePlugin};
-
-#[derive(Default)]
-struct HelloPlugin;
-
-impl StarForgePlugin for HelloPlugin {
-    fn meta(&self) -> PluginMeta {
-        PluginMeta {
-            name: "hello",
-            version: "0.1.0",
-            description: "Prints a greeting",
-        }
-    }
-
-    fn run(&self, args: &[String]) -> Result<(), String> {
-        let name = args.first().map(|s| s.as_str()).unwrap_or("world");
-        println!("Hello, {}!", name);
-        Ok(())
-    }
-}
-
-export_plugin!(HelloPlugin);
-```
-
-## Build
-
-```bash
-cargo build --release
-# Output: target/release/libmy_starforge_plugin.dylib (macOS)
-#         target/release/libmy_starforge_plugin.so   (Linux)
-```
-
-## Load
-
-Place the compiled `.so` / `.dylib` in `~/.starforge/plugins/` and StarForge will discover it on startup.
diff --git a/examples/template_marketplace_usage.md b/examples/template_marketplace_usage.md
deleted file mode 100644
index c88329dd..00000000
--- a/examples/template_marketplace_usage.md
+++ /dev/null
@@ -1,399 +0,0 @@
-# Template Marketplace Usage Examples
-
-This document provides practical examples of using the StarForge Template Marketplace feature.
-
-## Quick Start
-
-### 1. Initialize the Marketplace
-
-First, initialize the template registry with example templates:
-
-```bash
-starforge template init
-```
-
-Output:
-```
-  ███████╗████████╗ █████╗ ██████╗ ███████╗ ██████╗ ██████╗  ██████╗ ███████╗
-  ...
-  
-  ◆ Initialize Template Registry
-  ─────────────────────────────────────────────────────────────────────────
-  
-  Adding example templates to the marketplace...
-  
-  ✓ Added: uniswap-v2
-  ✓ Added: lending-pool
-  ✓ Added: governance
-  ✓ Added: multisig-wallet
-  
-  ✓ Template registry initialized with 4 example templates
-  
-  Browse templates:
-    starforge template list
-    starforge template search defi
-```
-
-### 2. Browse Available Templates
-
-List all templates:
-
-```bash
-starforge template list
-```
-
-Output:
-```
-  ◆ Template Marketplace — All Templates
-  ─────────────────────────────────────────────────────────────────────────
-  
-  4 template(s) available:
-  
-  1. uniswap-v2 ✓
-     Uniswap V2 style automated market maker (AMM) DEX implementation
-     1.0.0 • Stellar Community • 0 downloads
-     Tags: defi, dex, amm, swap
-  
-  2. lending-pool ✓
-     Decentralized lending and borrowing protocol with collateralization
-     1.0.0 • Stellar Community • 0 downloads
-     Tags: defi, lending, borrowing
-  
-  3. governance ✓
-     DAO governance contract with proposal creation and voting mechanisms
-     1.0.0 • Stellar Community • 0 downloads
-     Tags: dao, governance, voting
-  
-  4. multisig-wallet ✓
-     Multi-signature wallet with threshold-based transaction approval
-     1.0.0 • Stellar Community • 0 downloads
-     Tags: wallet, multisig, security
-```
-
-### 3. Search for Specific Templates
-
-Search by keyword:
-
-```bash
-starforge template search defi
-```
-
-Search with tag filtering:
-
-```bash
-starforge template search dex --tags amm
-```
-
-### 4. View Template Details
-
-```bash
-starforge template show uniswap-v2
-```
-
-Output:
-```
-  ◆ Template: uniswap-v2
-  ─────────────────────────────────────────────────────────────────────────
-  
-  uniswap-v2 ✓
-  
-  Description    : Uniswap V2 style automated market maker (AMM) DEX implementation
-  Version        : 1.0.0
-  Author         : Stellar Community
-  Downloads      : 0
-  Tags           : defi, dex, amm, swap
-  
-  Created        : 2025-01-01T00:00:00Z
-  Updated        : 2025-01-01T00:00:00Z
-  
-  Source         : Git Repository
-  URL            : https://github.com/stellar/soroban-examples
-  Branch         : main
-  
-  ─────────────────────────────────────────────────────────────────────────
-  
-  Use this template:
-    starforge new contract my-project --template uniswap-v2 --from marketplace
-```
-
-## Using Templates
-
-### Create a Project from a Marketplace Template
-
-```bash
-starforge new contract my-dex --template uniswap-v2 --from marketplace
-```
-
-Output:
-```
-  ◆ Scaffolding from Marketplace: uniswap-v2
-  ─────────────────────────────────────────────────────────────────────────
-  
-  Template       : uniswap-v2
-  Version        : 1.0.0
-  Author         : Stellar Community
-  Description    : Uniswap V2 style automated market maker (AMM) DEX implementation
-  
-  ─────────────────────────────────────────────────────────────────────────
-  
-  [1/3] Fetching template...
-  [2/3] Validating template structure...
-  [3/3] Copying template to project directory...
-  
-  ✓ Contract 'my-dex' scaffolded from marketplace!
-  
-  Next steps:
-    cd my-dex
-    stellar contract build
-    starforge deploy --wasm target/wasm32-unknown-unknown/release/my_dex.wasm
-```
-
-### Search and Use in One Workflow
-
-```bash
-# First, search for what you need
-starforge new contract --search lending
-
-# Then use the template you found
-starforge new contract my-lending --template lending-pool --from marketplace
-```
-
-## Publishing Templates
-
-### Publish a Simple Template
-
-```bash
-starforge template publish ./my-template \
-  --name my-counter \
-  --description "A simple counter contract" \
-  --author "John Doe" \
-  --tags "example,counter" \
-  --version "1.0.0"
-```
-
-Output:
-```
-  ◆ Publish Template
-  
-  [1/3] Validating template structure...
-  [2/3] Copying template to local registry...
-  [3/3] Updating registry...
-  
-  ✓ Template 'my-counter' published successfully!
-  
-  ─────────────────────────────────────────────────────────────────────────
-  Name           : my-counter
-  Version        : 1.0.0
-  Author         : John Doe
-  Tags           : example, counter
-  ─────────────────────────────────────────────────────────────────────────
-  
-  Others can now use your template:
-    starforge new contract my-project --template my-counter --from marketplace
-```
-
-### Interactive Publishing
-
-If you don't provide all options, StarForge will prompt you:
-
-```bash
-starforge template publish ./my-template
-```
-
-Interactive prompts:
-```
-Template description: A simple counter contract
-Author name: John Doe
-```
-
-## Advanced Usage
-
-### Creating a Template with Placeholders
-
-1. Create your contract:
-```bash
-starforge new contract template-base
-cd template-base
-```
-
-2. Edit `Cargo.toml` to use placeholders:
-```toml
-[package]
-name = "{{PROJECT_NAME}}"
-version = "0.1.0"
-edition = "2021"
-```
-
-3. Edit `src/lib.rs` to use placeholders:
-```rust
-#[contract]
-pub struct {{PROJECT_NAME_PASCAL}};
-
-#[contractimpl]
-impl {{PROJECT_NAME_PASCAL}} {
-    pub fn hello(env: Env, to: Symbol) -> Vec<Symbol> {
-        vec![&env, symbol_short!("Hello"), to]
-    }
-}
-```
-
-4. Test your template:
-```bash
-cargo test
-stellar contract build
-```
-
-5. Publish it:
-```bash
-cd ..
-starforge template publish ./template-base \
-  --name my-hello-world \
-  --description "Custom hello world template" \
-  --author "Your Name" \
-  --tags "example,hello-world"
-```
-
-### Using Local Templates
-
-You can also use templates from local directories without publishing:
-
-```bash
-# The template will be copied from the local path
-starforge template publish ./my-local-template
-```
-
-### Managing Templates
-
-Remove a template:
-```bash
-starforge template remove my-counter
-```
-
-## Real-World Examples
-
-### Example 1: DeFi Developer
-
-```bash
-# Search for DeFi templates
-starforge template search defi --tags dex
-
-# View details of interesting template
-starforge template show uniswap-v2
-
-# Create your DEX project
-starforge new contract my-stellar-dex --template uniswap-v2 --from marketplace
-
-# Build and test
-cd my-stellar-dex
-stellar contract build
-cargo test
-
-# Deploy to testnet
-starforge deploy \
-  --wasm target/wasm32-unknown-unknown/release/my_stellar_dex.wasm \
-  --network testnet
-```
-
-### Example 2: DAO Builder
-
-```bash
-# Find governance templates
-starforge template search governance
-
-# Use the governance template
-starforge new contract my-dao --template governance --from marketplace
-
-# Customize and deploy
-cd my-dao
-# Edit src/lib.rs to customize voting logic
-stellar contract build
-starforge deploy --wasm target/wasm32-unknown-unknown/release/my_dao.wasm
-```
-
-### Example 3: Template Creator
-
-```bash
-# Create a new innovative contract
-starforge new contract flash-loan-template
-
-# Develop your contract
-cd flash-loan-template
-# ... implement flash loan logic ...
-cargo test
-stellar contract build
-
-# Add placeholders for reusability
-# Edit Cargo.toml and src/lib.rs to add {{PROJECT_NAME}} etc.
-
-# Publish for others to use
-cd ..
-starforge template publish ./flash-loan-template \
-  --name flash-loan \
-  --description "Flash loan implementation for Soroban" \
-  --author "DeFi Innovator" \
-  --tags "defi,flash-loan,lending" \
-  --version "1.0.0"
-
-# Share with the community
-echo "New flash loan template available!"
-echo "starforge new contract my-flash-loan --template flash-loan --from marketplace"
-```
-
-## Tips and Best Practices
-
-### For Template Users
-
-1. **Always review code** - Check the template source before using
-2. **Prefer verified templates** - Look for the ✓ badge
-3. **Check version** - Use the latest stable version
-4. **Read documentation** - Review the template's README
-5. **Test thoroughly** - Test in a safe environment first
-
-### For Template Authors
-
-1. **Use clear placeholders** - Make it obvious what needs to be replaced
-2. **Include documentation** - Add a comprehensive README
-3. **Add tests** - Include working test cases
-4. **Follow conventions** - Use Soroban best practices
-5. **Version properly** - Use semantic versioning
-6. **Tag appropriately** - Use relevant, searchable tags
-7. **Keep it simple** - Focus on one clear use case
-
-## Troubleshooting
-
-### Template Not Found
-
-```bash
-starforge template show my-template
-# Error: Template 'my-template' not found in registry
-```
-
-Solution: Check available templates with `starforge template list`
-
-### Invalid Template Structure
-
-```bash
-starforge template publish ./bad-template
-# Error: Template must contain Cargo.toml
-```
-
-Solution: Ensure your template has the required files:
-- `Cargo.toml`
-- `src/` directory
-- `src/lib.rs`
-
-### Git Clone Failed
-
-```bash
-starforge new contract my-project --template some-template --from marketplace
-# Error: Git clone failed: repository not found
-```
-
-Solution: Check the template's source URL with `starforge template show some-template`
-
-## Next Steps
-
-- Explore the [Template Marketplace Documentation](../TEMPLATE_MARKETPLACE.md)
-- Check out [example templates](../templates/examples/)
-- Join the community to share your templates
-- Contribute to the official template registry
diff --git a/pr.md b/pr.md
deleted file mode 100644
index 8a052866..00000000
--- a/pr.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# Pull Request: Feature Batch — Issues #240, #245, #248, #251
-
-## Summary
-
-- **Deploy dry-run mode** (`--dry-run`) validates the full deployment path without submitting any transaction, printing an actionable deployment plan with fee estimates and warnings.
-- **Template metadata fields** adds `license`, `repository`, `homepage`, and `documentation` URL fields to template entries, exposed via CLI publish flags and shown in `template show`.
-- **Plugin update command** adds `starforge plugin update [name]` to upgrade installed plugins from their registered sources without manual reinstalls.
-- **Template publish auditing** requires README.md, validates semver strings for `version` and version constraints, and checks that `cli_version_min <= cli_version_max` — all with actionable error messages.
-
-## Changes
-
-### `src/commands/deploy.rs` — closes #240
-- Added `--dry-run` flag to `DeployArgs`
-- Added `run_dry_run()` function that runs 4 sequential checks:
-  1. WASM artifact path + magic-byte validation
-  2. Wallet existence in local config
-  3. Network connectivity and account XLM balance via Horizon
-  4. Soroban fee estimation via RPC simulation
-- Prints a deployment plan summary with warnings and the exact `stellar contract deploy` command to run
-
-### `src/utils/templates.rs` + `src/commands/template.rs` — closes #251, #248
-- Added `license`, `repository`, `homepage`, `documentation` optional fields to `TemplateEntry` (serde-defaulted for backward compatibility)
-- Exposed all four as `--license`, `--repository`, `--homepage`, `--documentation` flags on `starforge template publish`
-- Displayed in `template show` and `template publish` output
-- Added `validate_template_structure_with_constraints()` — the full audit entry-point used by `publish_template_versioned`:
-  - Requires `README.md` (actionable error)
-  - Validates `version`, `cli_version_min`, `cli_version_max` as valid semver
-  - Rejects `cli_version_min > cli_version_max`
-  - Error messages name the exact field and explain the fix
-- `make_valid_template()` test helper now creates `README.md`
-- New tests: missing README, bad version semver, bad constraint semver, min > max
-
-### `src/plugins/registry.rs` + `src/commands/plugin.rs` — closes #245
-- Added `version: Option<String>` and `installed_at: Option<String>` to `InstalledPlugin` (serde-defaulted)
-- `install_plugin()` now records `installed_at` timestamp (ISO-8601 UTC)
-- Added `Update { name: Option<String>, yes: bool }` variant to `PluginCommands`
-- `update()` function:
-  - For crates.io sources: runs `cargo install --force`
-  - For other trusted sources: compares library mtime to `installed_at` and refreshes registry if newer
-  - Local-path plugins: reported as unupdatable with guidance
-  - Unknown sources: blocked unless `--yes` is passed
-  - Reports updated / skipped / failed counts
-
-## Test Plan
-
-- [x] `cargo build` succeeds without warnings
-- [x] `cargo test` — all tests pass (no regressions)
-- [ ] `starforge deploy --wasm <file> --dry-run` — prints plan, no transaction submitted
-- [ ] `starforge template publish <path> --name t --description d --author a --license MIT --repository https://github.com/org/repo` — stores and displays metadata
-- [ ] `starforge template show <name>` — displays license/repository/homepage/docs
-- [ ] `starforge template publish <path> --name t --description d --author a` with no README.md — fails with actionable error
-- [ ] `starforge plugin update` — checks all plugins and reports status
-- [ ] `starforge plugin update <name>` — updates single named plugin
-
-closes #240
-closes #245
-closes #248
-closes #251
-
-🤖 Generated with [Claude Code](https://claude.com/claude-code)
diff --git a/src/commands/completions.rs b/src/commands/completions.rs
index 00e3826e..2cda837c 100644
--- a/src/commands/completions.rs
+++ b/src/commands/completions.rs
@@ -1,8 +1,19 @@
 use anyhow::Result;
-use clap::{CommandFactory, Parser, Subcommand};
+use clap::{Args, CommandFactory, Parser, Subcommand};
 use clap_complete::{generate, Shell};
 use std::io::{self, Write};
 
+/// Shell completion generation options
+#[derive(Args)]
+pub struct CompletionArgs {
+    /// Include dynamic plugin command completions resolved at shell-completion time
+    #[arg(long)]
+    pub dynamic: bool,
+
+    #[command(subcommand)]
+    pub shell: CompletionShell,
+}
+
 /// Shell to generate completions for
 #[derive(Subcommand)]
 pub enum CompletionShell {
@@ -14,8 +25,8 @@ pub enum CompletionShell {
     Fish,
 }
 
-pub async fn handle(shell: CompletionShell) -> Result<()> {
-    let shell = match shell {
+pub async fn handle(args: CompletionArgs) -> Result<()> {
+    let shell = match args.shell {
         CompletionShell::Bash => Shell::Bash,
         CompletionShell::Zsh => Shell::Zsh,
         CompletionShell::Fish => Shell::Fish,
@@ -23,17 +34,21 @@ pub async fn handle(shell: CompletionShell) -> Result<()> {
     let mut buf = Vec::new();
     generate_completion(shell, &mut buf);
 
-    // Append plugin command completions so they are visible in tab completion.
-    let plugin_cmds = crate::plugins::registry::load_all_registered_commands();
-    if !plugin_cmds.is_empty() {
-        append_plugin_completions(shell, &plugin_cmds, &mut buf);
+    if args.dynamic {
+        append_dynamic_plugin_completions(shell, &mut buf);
+    } else {
+        // Keep existing generation-time plugin names for users who prefer static scripts.
+        let plugin_cmds = crate::plugins::registry::load_all_registered_commands();
+        if !plugin_cmds.is_empty() {
+            append_static_plugin_completions(shell, &plugin_cmds, &mut buf);
+        }
     }
 
     io::stdout().write_all(&buf)?;
     Ok(())
 }
 
-fn append_plugin_completions(
+fn append_static_plugin_completions(
     shell: Shell,
     cmds: &[crate::plugins::registry::RegisteredCommand],
     buf: &mut Vec<u8>,
@@ -74,6 +89,75 @@ fn append_plugin_completions(
     }
 }
 
+fn append_dynamic_plugin_completions(shell: Shell, buf: &mut Vec<u8>) {
+    use std::io::Write;
+    match shell {
+        Shell::Bash => {
+            let _ = writeln!(
+                buf,
+                r#"
+# Dynamic plugin commands
+_starforge_plugin_commands() {{
+    starforge --list-plugin-commands 2>/dev/null
+}}
+
+_starforge_with_plugins() {{
+    _starforge "$@"
+    if [[ ${{COMP_CWORD:-0}} -eq 1 ]]; then
+        local cur="${{COMP_WORDS[COMP_CWORD]}}"
+        local plugin_words
+        plugin_words="$(_starforge_plugin_commands)"
+        if [[ -n "$plugin_words" ]]; then
+            COMPREPLY+=( $(compgen -W "$plugin_words" -- "$cur") )
+        fi
+    fi
+}}
+
+complete -F _starforge_with_plugins starforge
+"#
+            );
+        }
+        Shell::Zsh => {
+            let _ = writeln!(
+                buf,
+                r#"
+# Dynamic plugin commands
+_starforge_plugin_commands() {{
+    local -a plugin_commands
+    plugin_commands=("${{(@f)$(starforge --list-plugin-commands 2>/dev/null)}}")
+    if (( ${{#plugin_commands}} )); then
+        compadd -- $plugin_commands
+    fi
+}}
+
+_starforge_with_plugins() {{
+    _starforge "$@"
+    if (( CURRENT == 2 )); then
+        _starforge_plugin_commands
+    fi
+}}
+
+compdef _starforge_with_plugins starforge
+"#
+            );
+        }
+        Shell::Fish => {
+            let _ = writeln!(
+                buf,
+                r#"
+# Dynamic plugin commands
+function __starforge_complete_plugins
+    starforge --list-plugin-commands 2>/dev/null
+end
+
+complete -c starforge -n "__fish_use_subcommand" -f -a "(__starforge_complete_plugins)" -d "Installed plugin command"
+"#
+            );
+        }
+        _ => {}
+    }
+}
+
 /// Generate completion script to a writer instead of stdout (used in tests).
 pub fn generate_completion(shell: Shell, writer: &mut impl io::Write) {
     let mut cmd = Cli::command();
@@ -134,8 +218,7 @@ enum Commands {
     #[command(subcommand)]
     Node(crate::commands::node::NodeCommands),
     /// Generate shell completions for bash, zsh, and fish
-    #[command(subcommand)]
-    Completions(CompletionShell),
+    Completions(CompletionArgs),
     /// Interactive REPL for local Soroban contract testing
     Shell(crate::commands::shell::ShellArgs),
     /// Live monitoring (contract events or wallet threshold)
@@ -178,6 +261,12 @@ mod tests {
         String::from_utf8(buf).expect("completion output is valid UTF-8")
     }
 
+    fn dynamic_completion_output(shell: Shell) -> String {
+        let mut buf = Vec::new();
+        append_dynamic_plugin_completions(shell, &mut buf);
+        String::from_utf8(buf).expect("dynamic completion output is valid UTF-8")
+    }
+
     // ── bash ──────────────────────────────────────────────────────────────────
 
     #[test]
@@ -365,4 +454,28 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn bash_dynamic_completion_queries_plugin_command_list() {
+        let out = dynamic_completion_output(Shell::Bash);
+        assert!(out.contains("--list-plugin-commands"));
+        assert!(out.contains("_starforge_with_plugins"));
+        assert!(out.contains("complete -F _starforge_with_plugins starforge"));
+    }
+
+    #[test]
+    fn zsh_dynamic_completion_queries_plugin_command_list() {
+        let out = dynamic_completion_output(Shell::Zsh);
+        assert!(out.contains("--list-plugin-commands"));
+        assert!(out.contains("_starforge_plugin_commands"));
+        assert!(out.contains("compdef _starforge_with_plugins starforge"));
+    }
+
+    #[test]
+    fn fish_dynamic_completion_queries_plugin_command_list() {
+        let out = dynamic_completion_output(Shell::Fish);
+        assert!(out.contains("--list-plugin-commands"));
+        assert!(out.contains("__starforge_complete_plugins"));
+        assert!(out.contains("complete -c starforge"));
+    }
 }
diff --git a/src/commands/config.rs b/src/commands/config.rs
index 68ef960e..711e1af1 100644
--- a/src/commands/config.rs
+++ b/src/commands/config.rs
@@ -16,6 +16,12 @@ pub enum ConfigCommands {
     /// Manage trusted plugin source allowlist
     #[command(subcommand)]
     PluginTrust(PluginTrustCommands),
+    /// Migrate the config file to the latest schema version
+    Migrate {
+        /// Show what changes would be applied without writing anything
+        #[arg(long, default_value = "false")]
+        dry_run: bool,
+    },
     /// Set global wallet encryption parameters (Argon2id)
     SetEncryption {
         /// Argon2 memory cost in KiB (e.g. 65536)
@@ -89,6 +95,7 @@ pub async fn handle(cmd: ConfigCommands) -> Result<()> {
         ConfigCommands::Show => show(),
         ConfigCommands::Set { key, value } => set_value(&key, &value),
         ConfigCommands::PluginTrust(cmd) => plugin_trust(cmd),
+        ConfigCommands::Migrate { dry_run } => migrate(dry_run),
         ConfigCommands::SetEncryption {
             mem,
             iterations,
@@ -396,6 +403,71 @@ fn print_plugin_trust_sources(cfg: &config::Config) {
     }
 }
 
+fn migrate(dry_run: bool) -> Result<()> {
+    p::header("Config Migration");
+    p::separator();
+    p::kv("Config file", &config::config_path().display().to_string());
+    p::kv("Target schema version", config::CURRENT_CONFIG_VERSION);
+
+    if dry_run {
+        let Some(outcome) = config::plan_migration()? else {
+            p::info("No config file exists yet — nothing to migrate.");
+            return Ok(());
+        };
+
+        if !outcome.migrated() {
+            p::success("Config is already at the latest schema version. No changes needed.");
+            return Ok(());
+        }
+
+        println!();
+        p::info("Migration steps that would be applied:");
+        for (from, to) in &outcome.steps {
+            p::kv("  step", &format!("v{from} -> v{to}"));
+        }
+
+        println!();
+        p::info("Changes that would be written:");
+        for change in &outcome.changes {
+            println!("    {change}");
+        }
+
+        println!();
+        p::warn("Dry run: no files were modified. Re-run without --dry-run to apply.");
+        return Ok(());
+    }
+
+    let Some(outcome) = config::apply_migration()? else {
+        p::info("No config file exists yet — nothing to migrate.");
+        return Ok(());
+    };
+
+    if !outcome.migrated() {
+        p::success("Config is already at the latest schema version. No changes needed.");
+        return Ok(());
+    }
+
+    println!();
+    p::info("Applied migration steps:");
+    for (from, to) in &outcome.steps {
+        p::kv("  step", &format!("v{from} -> v{to}"));
+    }
+
+    println!();
+    p::info("Changes written:");
+    for change in &outcome.changes {
+        println!("    {change}");
+    }
+
+    println!();
+    p::info(&format!(
+        "A backup of the previous config was saved to {}",
+        config::config_dir().join("config.toml.bak").display()
+    ));
+    p::success("Config migrated successfully.");
+    Ok(())
+}
+
 fn set_encryption(
     mem: Option<u32>,
     iterations: Option<u32>,
diff --git a/src/commands/contract.rs b/src/commands/contract.rs
index 6537f4a3..edab6d64 100644
--- a/src/commands/contract.rs
+++ b/src/commands/contract.rs
@@ -291,7 +291,8 @@ async fn handle_invoke(args: InvokeArgs) -> Result<()> {
         &arg_types,
         &args.network,
         submit_wallet.as_ref(),
-    ).await?;
+    )
+    .await?;
 
     let simulation_result = outcome.simulation;
     p::kv_accent("Simulation", "✓ Success");
diff --git a/src/commands/deploy.rs b/src/commands/deploy.rs
index e47eab95..b95447d8 100644
--- a/src/commands/deploy.rs
+++ b/src/commands/deploy.rs
@@ -327,7 +327,8 @@ pub async fn handle(args: DeployArgs) -> Result<()> {
             wasm_size_kb,
             wallet,
             &args.network,
-        ).await;
+        )
+        .await;
     }
 
     if args.simulate {
@@ -388,15 +389,17 @@ pub async fn handle(args: DeployArgs) -> Result<()> {
     let pb = p::progress_bar(3, "Starting deployment steps...");
 
     pb.set_message("Verifying account on-chain...");
-    let account = horizon::fetch_account(&wallet.public_key, &args.network).await.map_err(|e| {
-        pb.abandon();
-        anyhow::anyhow!(
-            "Account not active on {}: {}\nFund it with: starforge wallet fund {}",
-            args.network,
-            e,
-            wallet.name
-        )
-    })?;
+    let account = horizon::fetch_account(&wallet.public_key, &args.network)
+        .await
+        .map_err(|e| {
+            pb.abandon();
+            anyhow::anyhow!(
+                "Account not active on {}: {}\nFund it with: starforge wallet fund {}",
+                args.network,
+                e,
+                wallet.name
+            )
+        })?;
 
     let xlm = account
         .balances
diff --git a/src/commands/deploy_monitor.rs b/src/commands/deploy_monitor.rs
new file mode 100644
index 00000000..45694b48
--- /dev/null
+++ b/src/commands/deploy_monitor.rs
@@ -0,0 +1,333 @@
+use crate::utils::deploy_history::{DeployRecord, DeployStatus};
+use crate::utils::deploy_monitor as dm;
+use crate::utils::print as p;
+use crate::utils::{deploy_history, horizon, notifications, soroban};
+use anyhow::Result;
+use clap::Subcommand;
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+
+#[derive(Subcommand)]
+pub enum DeployMonitorCommands {
+    /// One-shot health check of tracked deployments
+    Status(StatusArgs),
+    /// Continuously monitor deployments and report status changes
+    Watch(WatchArgs),
+    /// Detailed health of a single deployment
+    Health(HealthArgs),
+    /// Aggregate monitoring dashboard
+    Dashboard(DashboardArgs),
+    /// Detect and list failed / stuck deployments
+    Failures(FailuresArgs),
+}
+
+#[derive(clap::Args)]
+pub struct StatusArgs {
+    /// Only monitor deployments on this network
+    #[arg(long)]
+    pub network: Option<String>,
+    /// Maximum number of deployments to check
+    #[arg(long, default_value = "25")]
+    pub limit: usize,
+}
+
+#[derive(clap::Args)]
+pub struct WatchArgs {
+    #[arg(long)]
+    pub network: Option<String>,
+    /// Seconds between monitoring cycles
+    #[arg(long, default_value = "15")]
+    pub interval: u64,
+    /// Send notifications when deployments degrade or fail
+    #[arg(long)]
+    pub alert: bool,
+}
+
+#[derive(clap::Args)]
+pub struct HealthArgs {
+    /// Deployment id (or unique prefix)
+    pub id: String,
+}
+
+#[derive(clap::Args)]
+pub struct DashboardArgs {
+    #[arg(long)]
+    pub network: Option<String>,
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[derive(clap::Args)]
+pub struct FailuresArgs {
+    /// Send a notification for each detected failure
+    #[arg(long)]
+    pub alert: bool,
+}
+
+pub async fn handle(cmd: DeployMonitorCommands) -> Result<()> {
+    match cmd {
+        DeployMonitorCommands::Status(args) => handle_status(args).await,
+        DeployMonitorCommands::Watch(args) => handle_watch(args).await,
+        DeployMonitorCommands::Health(args) => handle_health(args).await,
+        DeployMonitorCommands::Dashboard(args) => handle_dashboard(args).await,
+        DeployMonitorCommands::Failures(args) => handle_failures(args),
+    }
+}
+
+/// Probe live infrastructure for a deployment, caching per-network reachability
+/// for the duration of one monitoring pass.
+async fn probe(record: &DeployRecord, net_cache: &mut HashMap<String, bool>) -> dm::LivenessProbe {
+    let reachable = match net_cache.get(&record.network) {
+        Some(v) => *v,
+        None => {
+            let v = horizon::check_network(&record.network).await;
+            net_cache.insert(record.network.clone(), v);
+            v
+        }
+    };
+
+    let contract_live = match (&record.contract_id, reachable, &record.status) {
+        (Some(cid), true, DeployStatus::Success) => Some(
+            soroban::inspect_contract(cid, &record.network)
+                .await
+                .is_ok(),
+        ),
+        _ => None,
+    };
+
+    let age = dm::age_secs(&record.timestamp, dm::now_epoch()).unwrap_or(0);
+    dm::LivenessProbe {
+        network_reachable: reachable,
+        contract_live,
+        age_secs: age,
+    }
+}
+
+async fn assess_all(records: &[DeployRecord]) -> Vec<dm::DeploymentHealth> {
+    let mut net_cache: HashMap<String, bool> = HashMap::new();
+    let mut out = Vec::with_capacity(records.len());
+    for r in records {
+        let probe = probe(r, &mut net_cache).await;
+        out.push(dm::assess_health(r, &probe));
+    }
+    out
+}
+
+fn filtered_records(network: &Option<String>, limit: usize) -> Result<Vec<DeployRecord>> {
+    let mut records = deploy_history::load_history()?;
+    if let Some(net) = network {
+        records.retain(|r| &r.network == net);
+    }
+    // Newest first.
+    records.reverse();
+    records.truncate(limit);
+    Ok(records)
+}
+
+async fn handle_status(args: StatusArgs) -> Result<()> {
+    let records = filtered_records(&args.network, args.limit)?;
+    p::header("Deployment Health Status");
+    if records.is_empty() {
+        p::info("No deployments tracked yet.");
+        return Ok(());
+    }
+
+    let healths = assess_all(&records).await;
+    p::separator();
+    for h in &healths {
+        let badge = format!("{} {}", h.health.symbol(), h.health.label());
+        p::kv_accent(
+            &h.deployment_id.chars().take(8).collect::<String>(),
+            &format!(
+                "{} · {} · {}",
+                badge,
+                h.network,
+                h.contract_id.clone().unwrap_or_else(|| "—".to_string())
+            ),
+        );
+        for c in &h.checks {
+            let mark = if c.passed { "✓" } else { "✗" };
+            println!("      {} {}: {}", mark, c.name, c.detail);
+        }
+    }
+    Ok(())
+}
+
+async fn handle_health(args: HealthArgs) -> Result<()> {
+    let record = deploy_history::get_record(&args.id)?
+        .ok_or_else(|| anyhow::anyhow!("No deployment matching '{}'", args.id))?;
+    let mut net_cache = HashMap::new();
+    let health = dm::assess_health(&record, &probe(&record, &mut net_cache).await);
+
+    p::header("Deployment Health");
+    p::kv("Deployment", &record.id);
+    p::kv("Network", &record.network);
+    p::kv("Deploy status", &record.status.to_string());
+    if let Some(cid) = &record.contract_id {
+        p::kv("Contract", cid);
+    }
+    p::kv_accent(
+        "Health",
+        &format!("{} {}", health.health.symbol(), health.health.label()),
+    );
+    p::separator();
+    for c in &health.checks {
+        let mark = if c.passed {
+            "✓".to_string()
+        } else {
+            "✗".to_string()
+        };
+        p::kv(&format!("{} {}", mark, c.name), &c.detail);
+    }
+    Ok(())
+}
+
+async fn handle_dashboard(args: DashboardArgs) -> Result<()> {
+    let records = filtered_records(&args.network, usize::MAX)?;
+    let healths = assess_all(&records).await;
+    let summary = dm::summarize(&healths);
+
+    if args.json {
+        println!("{}", serde_json::to_string_pretty(&summary)?);
+        return Ok(());
+    }
+
+    p::header("Deployment Monitoring Dashboard");
+    p::separator();
+    p::kv_accent("Tracked deployments", &summary.total.to_string());
+    p::kv("Healthy", &summary.healthy.to_string());
+    p::kv("Degraded", &summary.degraded.to_string());
+    p::kv("Unhealthy", &summary.unhealthy.to_string());
+    p::kv("Unknown", &summary.unknown.to_string());
+    p::kv_accent("Health rate", &format!("{:.1}%", summary.health_rate()));
+
+    if !summary.by_network.is_empty() {
+        p::header("By Network");
+        let rows: Vec<Vec<String>> = summary
+            .by_network
+            .iter()
+            .map(|(net, h)| {
+                vec![
+                    net.clone(),
+                    h.healthy.to_string(),
+                    h.degraded.to_string(),
+                    h.unhealthy.to_string(),
+                    h.unknown.to_string(),
+                ]
+            })
+            .collect();
+        p::table(
+            &["Network", "Healthy", "Degraded", "Unhealthy", "Unknown"],
+            &rows,
+        );
+    }
+
+    let failures = dm::detect_failures(&records, dm::now_epoch());
+    if !failures.is_empty() {
+        p::header("Active Failures");
+        for f in &failures {
+            p::warn(&format!("[{}] {}: {}", f.severity, f.kind, f.message));
+        }
+    }
+    Ok(())
+}
+
+fn handle_failures(args: FailuresArgs) -> Result<()> {
+    let records = deploy_history::load_history()?;
+    let failures = dm::detect_failures(&records, dm::now_epoch());
+
+    p::header("Deployment Failure Detection");
+    p::separator();
+    if failures.is_empty() {
+        p::success("No failed or stuck deployments detected");
+        return Ok(());
+    }
+
+    for f in &failures {
+        p::error(&format!(
+            "[{}] {} ({}): {}",
+            f.severity,
+            f.kind,
+            f.deployment_id.chars().take(8).collect::<String>(),
+            f.message
+        ));
+        if args.alert {
+            let mut data = HashMap::new();
+            data.insert("message".to_string(), format!("{}: {}", f.kind, f.message));
+            data.insert("deployment".to_string(), f.deployment_id.clone());
+            data.insert("network".to_string(), f.network.clone());
+            let _ = notifications::send_notification("deployment-failure", &data, &f.severity);
+        }
+    }
+    dm::log_alerts(&failures)?;
+    p::separator();
+    anyhow::bail!("{} deployment failure(s) detected", failures.len());
+}
+
+async fn handle_watch(args: WatchArgs) -> Result<()> {
+    p::header("Deployment Monitoring (live)");
+    p::kv("Interval", &format!("{}s", args.interval));
+    if let Some(net) = &args.network {
+        p::kv("Network", net);
+    }
+    p::kv("Alerting", if args.alert { "on" } else { "off" });
+    p::separator();
+    p::info("Watching for status changes. Press Ctrl+C to stop.");
+
+    let running = Arc::new(AtomicBool::new(true));
+    {
+        let running = Arc::clone(&running);
+        ctrlc::set_handler(move || running.store(false, Ordering::SeqCst))?;
+    }
+
+    let interval = std::time::Duration::from_secs(args.interval.max(1));
+
+    while running.load(Ordering::SeqCst) {
+        let records = filtered_records(&args.network, usize::MAX)?;
+        let healths = assess_all(&records).await;
+        let previous = dm::load_snapshot()?;
+        let changes = dm::diff_snapshot(&previous, &healths);
+
+        for change in &changes {
+            let from = change
+                .from
+                .map(|s| s.label().to_string())
+                .unwrap_or_else(|| "new".to_string());
+            let short = change.deployment_id.chars().take(8).collect::<String>();
+            let line = format!("{} : {} → {}", short, from, change.to.label());
+            match change.to {
+                dm::HealthStatus::Unhealthy => {
+                    p::error(&line);
+                    if args.alert {
+                        notifications::alert(&format!("Deployment {} is now unhealthy", short));
+                    }
+                }
+                dm::HealthStatus::Degraded => p::warn(&line),
+                _ => p::success(&line),
+            }
+        }
+
+        if changes.is_empty() {
+            let s = dm::summarize(&healths);
+            p::info(&format!(
+                "No changes · {} healthy / {} degraded / {} unhealthy",
+                s.healthy, s.degraded, s.unhealthy
+            ));
+        }
+
+        dm::save_snapshot(&dm::snapshot_from(&healths))?;
+
+        // Sleep in short slices so Ctrl+C is responsive.
+        let mut slept = std::time::Duration::ZERO;
+        let slice = std::time::Duration::from_millis(200);
+        while running.load(Ordering::SeqCst) && slept < interval {
+            std::thread::sleep(slice);
+            slept += slice;
+        }
+    }
+
+    p::separator();
+    p::success("Monitoring stopped");
+    Ok(())
+}
diff --git a/src/commands/events.rs b/src/commands/events.rs
new file mode 100644
index 00000000..d7b0d020
--- /dev/null
+++ b/src/commands/events.rs
@@ -0,0 +1,487 @@
+use crate::utils::event_stream as es;
+use crate::utils::print as p;
+use crate::utils::stream::{EventStreamFilters, SorobanEventStream};
+use crate::utils::{config, notifications, soroban};
+use anyhow::Result;
+use clap::Subcommand;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+
+#[derive(Subcommand)]
+pub enum EventsCommands {
+    /// Stream live contract events, persisting and routing them in real time
+    Stream(StreamArgs),
+    /// List persisted events for a contract
+    List(ListArgs),
+    /// Replay persisted events through the routing + alert pipeline
+    Replay(ReplayArgs),
+    /// Show event analytics for a contract
+    Analytics(AnalyticsArgs),
+    /// Manage routing rules / event-based triggers
+    #[command(subcommand)]
+    Route(RouteCommands),
+    /// Manage alert patterns
+    #[command(subcommand)]
+    Alert(AlertCommands),
+}
+
+#[derive(clap::Args)]
+pub struct StreamArgs {
+    /// Contract ID to stream events from
+    #[arg(long)]
+    pub contract: String,
+    /// Network (testnet/mainnet)
+    #[arg(long, default_value = "testnet")]
+    pub network: String,
+    /// Event type filter (contract/system/diagnostic)
+    #[arg(long)]
+    pub event_type: Option<String>,
+    /// Comma-separated topic segments (use * to wildcard a segment)
+    #[arg(long)]
+    pub topic: Option<String>,
+    /// Persist matched events to ~/.starforge/events/
+    #[arg(long)]
+    pub persist: bool,
+    /// Keep streaming until interrupted (Ctrl+C)
+    #[arg(long)]
+    pub follow: bool,
+    /// Poll interval in seconds
+    #[arg(long, default_value = "2")]
+    pub interval: u64,
+}
+
+#[derive(clap::Args)]
+pub struct ListArgs {
+    #[arg(long)]
+    pub contract: String,
+    #[arg(long, default_value = "20")]
+    pub limit: usize,
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[derive(clap::Args)]
+pub struct ReplayArgs {
+    #[arg(long)]
+    pub contract: String,
+    /// Only replay events at or after this ledger
+    #[arg(long)]
+    pub from_ledger: Option<u32>,
+}
+
+#[derive(clap::Args)]
+pub struct AnalyticsArgs {
+    #[arg(long)]
+    pub contract: String,
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[derive(Subcommand)]
+pub enum RouteCommands {
+    /// Add or replace a routing rule
+    Add(RouteAddArgs),
+    /// List routing rules
+    List,
+}
+
+#[derive(clap::Args)]
+pub struct RouteAddArgs {
+    #[arg(long)]
+    pub name: String,
+    #[arg(long)]
+    pub event_type: Option<String>,
+    #[arg(long)]
+    pub topic: Option<String>,
+    #[arg(long)]
+    pub value_contains: Option<String>,
+    /// Action: log | notify | webhook
+    #[arg(long, default_value = "log")]
+    pub action: String,
+    /// Webhook URL (for --action webhook)
+    #[arg(long)]
+    pub url: Option<String>,
+    /// Notification template (for --action notify)
+    #[arg(long, default_value = "event")]
+    pub template: String,
+    /// Notification severity (for --action notify)
+    #[arg(long, default_value = "info")]
+    pub severity: String,
+}
+
+#[derive(Subcommand)]
+pub enum AlertCommands {
+    /// Add or replace an alert pattern
+    Add(AlertAddArgs),
+    /// List alert patterns
+    List,
+}
+
+#[derive(clap::Args)]
+pub struct AlertAddArgs {
+    #[arg(long)]
+    pub name: String,
+    #[arg(long)]
+    pub event_type: Option<String>,
+    #[arg(long)]
+    pub topic: Option<String>,
+    #[arg(long)]
+    pub value_contains: Option<String>,
+    /// Trailing window in seconds
+    #[arg(long, default_value = "60")]
+    pub window: i64,
+    /// Number of matching events that triggers the alert
+    #[arg(long, default_value = "5")]
+    pub threshold: usize,
+    #[arg(long, default_value = "warning")]
+    pub severity: String,
+}
+
+pub fn handle(cmd: EventsCommands) -> Result<()> {
+    match cmd {
+        EventsCommands::Stream(args) => handle_stream(args),
+        EventsCommands::List(args) => handle_list(args),
+        EventsCommands::Replay(args) => handle_replay(args),
+        EventsCommands::Analytics(args) => handle_analytics(args),
+        EventsCommands::Route(cmd) => handle_route(cmd),
+        EventsCommands::Alert(cmd) => handle_alert(cmd),
+    }
+}
+
+fn handle_stream(args: StreamArgs) -> Result<()> {
+    config::validate_contract_id(&args.contract)?;
+    config::validate_network(&args.network)?;
+
+    let mut filters = EventStreamFilters::default();
+    if let Some(t) = &args.event_type {
+        filters.event_type = Some(t.trim().to_lowercase());
+    }
+    if let Some(topic) = &args.topic {
+        let segments: Vec<String> = topic
+            .split(',')
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty())
+            .collect();
+        if !segments.is_empty() {
+            filters.topic_segments = Some(segments);
+        }
+    }
+
+    let rpc_url = soroban::rpc_url(&args.network)?;
+    let routes = es::load_routes()?;
+    let patterns = es::load_alert_patterns()?;
+
+    p::header("Real-Time Event Stream");
+    p::kv("Contract", &args.contract);
+    p::kv("RPC", &rpc_url);
+    p::kv("Routes", &routes.len().to_string());
+    p::kv("Alert patterns", &patterns.len().to_string());
+    p::kv("Persist", if args.persist { "yes" } else { "no" });
+    p::separator();
+
+    let running = Arc::new(AtomicBool::new(true));
+    {
+        let running = Arc::clone(&running);
+        ctrlc::set_handler(move || running.store(false, Ordering::SeqCst))?;
+    }
+
+    let mut stream = SorobanEventStream::new(rpc_url, args.contract.clone())
+        .with_poll_interval(args.interval)
+        .with_filters(filters);
+
+    let mut session: Vec<es::EventRecord> = Vec::new();
+    let mut fired: std::collections::HashSet<String> = std::collections::HashSet::new();
+    let mut seen_any = false;
+
+    while running.load(Ordering::SeqCst) {
+        match stream.next_batch() {
+            Ok(batch) => {
+                let records: Vec<es::EventRecord> = batch
+                    .iter()
+                    .map(|e| es::EventRecord::from_soroban(e, &args.contract))
+                    .collect();
+
+                for rec in &records {
+                    seen_any = true;
+                    p::success(&format!(
+                        "Ledger {} · {} · {}",
+                        rec.ledger, rec.event_type, rec.value
+                    ));
+                    // Routing / triggers.
+                    for route in es::match_routes(rec, &routes) {
+                        if let Err(e) = es::execute_route(route, rec) {
+                            p::warn(&format!("route '{}' failed: {}", route.name, e));
+                        }
+                    }
+                }
+
+                session.extend(records.iter().cloned());
+
+                if args.persist && !records.is_empty() {
+                    let added = es::append_events(&args.contract, &records)?;
+                    if added > 0 {
+                        p::info(&format!("Persisted {} event(s)", added));
+                    }
+                }
+
+                // Alert evaluation over the live session window.
+                for alert in es::evaluate_alerts(&patterns, &session, es::now_epoch()) {
+                    if fired.insert(alert.pattern.clone()) {
+                        notifications::alert(&format!(
+                            "[{}] alert '{}' fired: {} events in {}s (threshold {})",
+                            alert.severity,
+                            alert.pattern,
+                            alert.count,
+                            alert.window_secs,
+                            alert.threshold
+                        ));
+                    }
+                }
+
+                if !args.follow {
+                    if !seen_any {
+                        p::warn("No matching events in the latest batch.");
+                    }
+                    break;
+                }
+                stream.sleep();
+            }
+            Err(err) => {
+                if !args.follow && !seen_any {
+                    return Err(err);
+                }
+                p::warn(&format!(
+                    "Stream error: {}. Reconnecting with backoff…",
+                    err
+                ));
+                stream.sleep_backoff();
+            }
+        }
+    }
+
+    p::separator();
+    p::success(&format!(
+        "Stream ended — {} event(s) this session",
+        session.len()
+    ));
+    Ok(())
+}
+
+fn handle_list(args: ListArgs) -> Result<()> {
+    let mut events = es::load_events(&args.contract)?;
+    events.reverse(); // newest first
+    events.truncate(args.limit);
+
+    if args.json {
+        println!("{}", serde_json::to_string_pretty(&events)?);
+        return Ok(());
+    }
+
+    p::header("Persisted Events");
+    if events.is_empty() {
+        p::info("No events stored. Stream with: starforge events stream --contract <id> --persist --follow");
+        return Ok(());
+    }
+    let rows: Vec<Vec<String>> = events
+        .iter()
+        .map(|e| {
+            vec![
+                e.ledger.to_string(),
+                e.event_type.clone(),
+                truncate(&e.topics.join(","), 24),
+                truncate(&e.value, 32),
+                e.received_at.chars().take(19).collect(),
+            ]
+        })
+        .collect();
+    p::table(&["Ledger", "Type", "Topics", "Value", "Received"], &rows);
+    Ok(())
+}
+
+fn handle_replay(args: ReplayArgs) -> Result<()> {
+    let mut events = es::load_events(&args.contract)?;
+    if let Some(from) = args.from_ledger {
+        events.retain(|e| e.ledger >= from);
+    }
+    let routes = es::load_routes()?;
+    let patterns = es::load_alert_patterns()?;
+    let summary = es::replay(&events, &routes, &patterns, es::now_epoch());
+
+    p::header("Event Replay");
+    p::kv("Events processed", &summary.processed.to_string());
+    p::kv("Route matches", &summary.matched_routes.to_string());
+    p::kv("Alerts", &summary.alerts.len().to_string());
+    p::separator();
+    for a in &summary.alerts {
+        p::warn(&format!(
+            "[{}] {}: {} events (threshold {})",
+            a.severity, a.pattern, a.count, a.threshold
+        ));
+    }
+    if summary.alerts.is_empty() {
+        p::success("No alert patterns triggered during replay");
+    }
+    Ok(())
+}
+
+fn handle_analytics(args: AnalyticsArgs) -> Result<()> {
+    let events = es::load_events(&args.contract)?;
+    let analytics = es::EventAnalytics::from_events(&events);
+
+    if args.json {
+        println!("{}", serde_json::to_string_pretty(&analytics)?);
+        return Ok(());
+    }
+
+    p::header("Event Analytics");
+    p::kv("Contract", &args.contract);
+    p::kv_accent("Total events", &analytics.total.to_string());
+    p::kv("Unique ledgers", &analytics.unique_ledgers.to_string());
+    if let (Some(first), Some(last)) = (analytics.first_ledger, analytics.last_ledger) {
+        p::kv("Ledger range", &format!("{} → {}", first, last));
+    }
+    p::separator();
+
+    if analytics.total == 0 {
+        p::info("No events recorded yet.");
+        return Ok(());
+    }
+
+    p::header("By Type");
+    let max = analytics
+        .by_type
+        .values()
+        .copied()
+        .max()
+        .unwrap_or(1)
+        .max(1);
+    for (ty, count) in &analytics.by_type {
+        let bar = "█".repeat(((*count * 30) / max).max(1));
+        println!("  {:<14} {} {}", ty, bar, count);
+    }
+
+    if !analytics.top_topics.is_empty() {
+        p::header("Top Topics");
+        let rows: Vec<Vec<String>> = analytics
+            .top_topics
+            .iter()
+            .map(|(t, c)| vec![truncate(t, 36), c.to_string()])
+            .collect();
+        p::table(&["Topic", "Count"], &rows);
+    }
+    Ok(())
+}
+
+fn handle_route(cmd: RouteCommands) -> Result<()> {
+    match cmd {
+        RouteCommands::List => {
+            p::header("Event Routes");
+            let routes = es::load_routes()?;
+            if routes.is_empty() {
+                p::info("No routes configured. Add one with: starforge events route add ...");
+                return Ok(());
+            }
+            for r in &routes {
+                let action = match &r.action {
+                    es::RouteAction::Log => "log".to_string(),
+                    es::RouteAction::Notify { template, severity } => {
+                        format!("notify({}, {})", template, severity)
+                    }
+                    es::RouteAction::Webhook { url } => format!("webhook({})", url),
+                };
+                p::kv(
+                    &r.name,
+                    &format!("{} [{}]", action, if r.enabled { "on" } else { "off" }),
+                );
+            }
+            Ok(())
+        }
+        RouteCommands::Add(args) => {
+            let action = match args.action.as_str() {
+                "log" => es::RouteAction::Log,
+                "notify" => es::RouteAction::Notify {
+                    template: args.template.clone(),
+                    severity: args.severity.clone(),
+                },
+                "webhook" => {
+                    let url = args
+                        .url
+                        .clone()
+                        .ok_or_else(|| anyhow::anyhow!("--url is required for --action webhook"))?;
+                    es::RouteAction::Webhook { url }
+                }
+                other => anyhow::bail!("Unknown action '{}' (use log, notify, or webhook)", other),
+            };
+            let route = es::EventRoute {
+                name: args.name.clone(),
+                filter: es::EventFilter {
+                    contract_id: None,
+                    event_type: args.event_type.clone(),
+                    topic_pattern: args.topic.clone(),
+                    value_contains: args.value_contains.clone(),
+                },
+                action,
+                enabled: true,
+            };
+            es::add_route(route)?;
+            p::success(&format!("Route '{}' saved", args.name));
+            Ok(())
+        }
+    }
+}
+
+fn handle_alert(cmd: AlertCommands) -> Result<()> {
+    match cmd {
+        AlertCommands::List => {
+            p::header("Alert Patterns");
+            let patterns = es::load_alert_patterns()?;
+            if patterns.is_empty() {
+                p::info("No alert patterns. Add one with: starforge events alert add ...");
+                return Ok(());
+            }
+            let rows: Vec<Vec<String>> = patterns
+                .iter()
+                .map(|p| {
+                    vec![
+                        p.name.clone(),
+                        p.severity.clone(),
+                        format!("{}s", p.window_secs),
+                        p.threshold.to_string(),
+                        if p.enabled { "on".into() } else { "off".into() },
+                    ]
+                })
+                .collect();
+            p::table(
+                &["Name", "Severity", "Window", "Threshold", "Enabled"],
+                &rows,
+            );
+            Ok(())
+        }
+        AlertCommands::Add(args) => {
+            let pattern = es::AlertPattern {
+                name: args.name.clone(),
+                filter: es::EventFilter {
+                    contract_id: None,
+                    event_type: args.event_type.clone(),
+                    topic_pattern: args.topic.clone(),
+                    value_contains: args.value_contains.clone(),
+                },
+                window_secs: args.window,
+                threshold: args.threshold,
+                severity: args.severity.clone(),
+                enabled: true,
+            };
+            es::add_alert_pattern(pattern)?;
+            p::success(&format!("Alert pattern '{}' saved", args.name));
+            Ok(())
+        }
+    }
+}
+
+fn truncate(s: &str, max: usize) -> String {
+    if s.len() > max {
+        format!("{}…", &s[..max])
+    } else {
+        s.to_string()
+    }
+}
diff --git a/src/commands/fuzz.rs b/src/commands/fuzz.rs
new file mode 100644
index 00000000..5e90770b
--- /dev/null
+++ b/src/commands/fuzz.rs
@@ -0,0 +1,202 @@
+use crate::utils::print as p;
+use crate::utils::{config, fuzzing};
+use anyhow::Result;
+use clap::Subcommand;
+use std::path::PathBuf;
+
+#[derive(Subcommand)]
+pub enum FuzzCommands {
+    /// Fuzz a contract WASM binary against the validator (byte mutation)
+    Wasm(WasmArgs),
+    /// Run the built-in property-based test suite (token model invariants)
+    Property(PropertyArgs),
+    /// Mutation-test a contract source file
+    Mutate(MutateArgs),
+    /// Manage saved fuzzing corpora
+    Corpus(CorpusArgs),
+}
+
+#[derive(clap::Args)]
+pub struct WasmArgs {
+    /// Path to the compiled .wasm to use as the fuzzing seed
+    #[arg(long)]
+    pub wasm: PathBuf,
+    /// Number of mutated inputs to try
+    #[arg(long, default_value = "2000")]
+    pub iterations: usize,
+    /// RNG seed for reproducible runs
+    #[arg(long, default_value = "3735928559")]
+    pub seed: u64,
+}
+
+#[derive(clap::Args)]
+pub struct PropertyArgs {
+    /// Number of generated inputs to test
+    #[arg(long, default_value = "1000")]
+    pub iterations: usize,
+    /// RNG seed for reproducible runs
+    #[arg(long, default_value = "3735928559")]
+    pub seed: u64,
+}
+
+#[derive(clap::Args)]
+pub struct MutateArgs {
+    /// Path to the contract source file to mutate
+    #[arg(long)]
+    pub source: PathBuf,
+    /// Emit JSON instead of formatted output
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[derive(clap::Args)]
+pub struct CorpusArgs {
+    /// List stored corpora
+    #[arg(long)]
+    pub list: bool,
+    /// Show the contents of a named corpus
+    #[arg(long)]
+    pub show: Option<String>,
+}
+
+pub fn handle(cmd: FuzzCommands) -> Result<()> {
+    match cmd {
+        FuzzCommands::Wasm(args) => handle_wasm(args),
+        FuzzCommands::Property(args) => handle_property(args),
+        FuzzCommands::Mutate(args) => handle_mutate(args),
+        FuzzCommands::Corpus(args) => handle_corpus(args),
+    }
+}
+
+fn handle_wasm(args: WasmArgs) -> Result<()> {
+    config::validate_file_path(&args.wasm, Some("wasm"))?;
+    let bytes = std::fs::read(&args.wasm)?;
+
+    p::header("WASM Validator Fuzzing");
+    p::kv("Seed binary", &args.wasm.display().to_string());
+    p::kv("Iterations", &args.iterations.to_string());
+    p::kv("RNG seed", &args.seed.to_string());
+
+    let cfg = fuzzing::FuzzConfig {
+        iterations: args.iterations,
+        seed: args.seed,
+        ..fuzzing::FuzzConfig::default()
+    };
+    let report = fuzzing::fuzz_wasm_validator(&bytes, &cfg);
+
+    p::separator();
+    p::kv("Rejected (graceful)", &report.rejected.to_string());
+    p::kv("Accepted", &report.accepted.to_string());
+    p::kv_accent("Crashes (panics)", &report.crashes.to_string());
+    p::separator();
+
+    if report.crashes > 0 {
+        for c in &report.crash_inputs {
+            p::warn(&format!("crash input prefix: {}", c));
+        }
+        anyhow::bail!("Validator panicked on {} mutated input(s)", report.crashes);
+    }
+    p::success("Validator handled every mutated input gracefully");
+    Ok(())
+}
+
+fn handle_property(args: PropertyArgs) -> Result<()> {
+    p::header("Property-Based Testing");
+    p::kv("Suite", "token transfer model (supply conservation)");
+    p::kv("Iterations", &args.iterations.to_string());
+    p::kv("RNG seed", &args.seed.to_string());
+
+    let cfg = fuzzing::FuzzConfig {
+        iterations: args.iterations,
+        seed: args.seed,
+        ..fuzzing::FuzzConfig::default()
+    };
+    let report = fuzzing::run_token_property_suite(&cfg);
+    p::separator();
+    p::kv("Cases run", &report.iterations_run.to_string());
+
+    if report.passed {
+        p::success("All properties held across every generated input");
+        return Ok(());
+    }
+
+    p::error(&format!(
+        "Property violated: {}",
+        report.failure_message.unwrap_or_default()
+    ));
+    if let Some(shrunk) = &report.shrunk_counterexample {
+        let rendered: Vec<String> = shrunk.iter().map(|v| v.to_string()).collect();
+        p::kv("Minimal counterexample", &rendered.join(", "));
+        p::kv("Shrink steps", &report.shrink_steps.to_string());
+    }
+    anyhow::bail!("Property-based test failed");
+}
+
+fn handle_mutate(args: MutateArgs) -> Result<()> {
+    config::validate_file_path(&args.source, None)?;
+    let source = std::fs::read_to_string(&args.source)?;
+    let mutants = fuzzing::generate_mutants(&source);
+    let score = fuzzing::score_mutants(&mutants, fuzzing::heuristic_oracle);
+
+    if args.json {
+        println!(
+            "{}",
+            serde_json::to_string_pretty(&serde_json::json!({
+                "mutants": mutants,
+                "score": score,
+            }))?
+        );
+        return Ok(());
+    }
+
+    p::header("Mutation Testing");
+    p::kv("Source", &args.source.display().to_string());
+    p::kv("Mutants generated", &score.total.to_string());
+    p::kv_accent("Mutation score", &format!("{:.1}%", score.score_pct));
+    p::kv("Killed", &score.killed.to_string());
+    p::kv("Survived", &score.survived.to_string());
+    p::separator();
+
+    if score.survivors.is_empty() {
+        p::success("No surviving mutants — strong coverage of critical logic");
+        return Ok(());
+    }
+
+    p::warn("Surviving mutants indicate untested logic:");
+    for m in score.survivors.iter().take(25) {
+        println!("  L{} [{}] {}", m.line, m.category, m.description);
+    }
+    if score.survivors.len() > 25 {
+        p::info(&format!("… and {} more", score.survivors.len() - 25));
+    }
+    Ok(())
+}
+
+fn handle_corpus(args: CorpusArgs) -> Result<()> {
+    if let Some(name) = args.show {
+        let corpus = fuzzing::load_corpus(&name)?;
+        p::header(&format!("Corpus: {}", name));
+        if corpus.is_empty() {
+            p::info("Corpus is empty or does not exist");
+            return Ok(());
+        }
+        for (i, input) in corpus.iter().enumerate() {
+            let rendered: Vec<String> = input.iter().map(|v| v.to_string()).collect();
+            println!("  {:>3}: {}", i, rendered.join(", "));
+        }
+        return Ok(());
+    }
+
+    // Default + --list both list available corpora.
+    let _ = args.list;
+    p::header("Fuzzing Corpora");
+    let names = fuzzing::list_corpora()?;
+    if names.is_empty() {
+        p::info("No corpora stored yet.");
+        return Ok(());
+    }
+    for n in names {
+        p::kv("•", &n);
+    }
+    Ok(())
+}
diff --git a/src/commands/invoke.rs b/src/commands/invoke.rs
index d9559bd7..eb654a10 100644
--- a/src/commands/invoke.rs
+++ b/src/commands/invoke.rs
@@ -99,7 +99,8 @@ pub async fn handle(args: InvokeArgs) -> Result<()> {
         &arg_type_list,
         network,
         submit_wallet.map(|w| w as &crate::utils::config::WalletEntry),
-    ).await?;
+    )
+    .await?;
 
     println!();
     p::success("Simulation successful!");
diff --git a/src/commands/lint.rs b/src/commands/lint.rs
index e8f3a67f..dfe06e32 100644
--- a/src/commands/lint.rs
+++ b/src/commands/lint.rs
@@ -1,158 +1,550 @@
-use anyhow::Result;
+use anyhow::{bail, Context, Result};
 use clap::Parser;
+use serde::Serialize;
+use std::collections::HashSet;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
+use wasmparser::{Operator, Parser as WasmParser, Payload};
 
 #[derive(Parser)]
 pub struct LintArgs {
-    /// Path to the Rust source file to lint
-    pub path: String,
+    /// Path to the compiled Soroban wasm file to analyze
+    pub path: PathBuf,
+
+    /// Output format for lint findings
+    #[arg(long, default_value = "human", value_parser = ["human", "json"])]
+    pub format: String,
+
+    /// Automatically apply safe fixes when available
+    #[arg(long)]
+    pub fix: bool,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct LintFinding {
     pub file: String,
     pub line: usize,
     pub check: String,
     pub message: String,
     pub severity: String,
+    pub fix_available: bool,
+}
+
+#[derive(Debug, Serialize)]
+pub struct BudgetReport {
+    pub total_size_bytes: usize,
+    pub code_section_bytes: usize,
+    pub data_section_bytes: usize,
+    pub warnings: Vec<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct LintReport {
+    pub file: String,
+    pub findings: Vec<LintFinding>,
+    pub budget: BudgetReport,
+    pub fixed_file: Option<String>,
 }
 
 pub async fn handle(args: LintArgs) -> Result<()> {
-    let path = Path::new(&args.path);
+    if !args.path.exists() {
+        bail!("File does not exist: {}", args.path.display());
+    }
+
+    let bytes =
+        fs::read(&args.path).with_context(|| format!("Failed to read {}", args.path.display()))?;
 
-    if !path.exists() {
-        anyhow::bail!("File does not exist: {}", args.path);
+    let wat = wasmprinter::print_bytes(&bytes)
+        .with_context(|| format!("Failed to render WAT for {}", args.path.display()))?;
+
+    let import_map = collect_imports(&bytes)?;
+    let mut findings = Vec::new();
+    findings.extend(analyze_ttl_expiry(&bytes, &import_map, &args.path)?);
+    findings.extend(analyze_persistent_storage_misuse(&wat, &args.path)?);
+    findings.extend(analyze_vec_iteration(&wat, &args.path)?);
+    findings.extend(analyze_missing_auth(&wat, &args.path)?);
+    let (budget_report, mut budget_findings) = analyze_budget(&bytes, &args.path)?;
+    findings.append(&mut budget_findings);
+
+    let mut fixed_file = None;
+    if args.fix {
+        if let Some(output) = apply_safe_fixes(&wat, &import_map, &args.path)? {
+            fixed_file = Some(output);
+        }
     }
 
-    let findings = lint_file(path)?;
+    let report = LintReport {
+        file: args.path.display().to_string(),
+        findings,
+        budget: budget_report,
+        fixed_file,
+    };
 
-    if findings.is_empty() {
-        println!("✓ No issues found");
+    if args.format == "json" {
+        println!("{}", serde_json::to_string_pretty(&report)?);
         return Ok(());
     }
 
-    for finding in findings {
-        let icon = match finding.severity.as_str() {
-            "error" => "✗",
-            "warning" => "⚠",
-            _ => "ℹ",
-        };
-        println!(
-            "{}:{}:{}: {} [{}] {}",
-            finding.file, finding.line, 0, icon, finding.check, finding.message
-        );
+    if report.findings.is_empty() {
+        println!("✓ No issues found");
+    } else {
+        for finding in &report.findings {
+            let icon = match finding.severity.as_str() {
+                "error" => "✗",
+                "warning" => "⚠",
+                _ => "ℹ",
+            };
+            println!(
+                "{}:{}:{}: {} [{}] {}{}",
+                finding.file,
+                finding.line,
+                0,
+                icon,
+                finding.check,
+                finding.message,
+                if finding.fix_available {
+                    " (fix available)"
+                } else {
+                    ""
+                }
+            );
+        }
+    }
+
+    println!("\nBudget report:");
+    println!("  total size: {} bytes", report.budget.total_size_bytes);
+    println!("  code section: {} bytes", report.budget.code_section_bytes);
+    println!("  data section: {} bytes", report.budget.data_section_bytes);
+    for warning in &report.budget.warnings {
+        println!("  ⚠ {}", warning);
+    }
+
+    if let Some(path) = report.fixed_file {
+        println!("\nFixed output written to {}", path);
     }
 
     Ok(())
 }
 
-fn lint_file(path: &Path) -> Result<Vec<LintFinding>> {
-    let content = fs::read_to_string(path)?;
+fn collect_imports(bytes: &[u8]) -> Result<ImportIndexMap> {
+    let mut import_map = ImportIndexMap::default();
+    let parser = WasmParser::new(0);
+    for payload in parser.parse_all(bytes) {
+        match payload? {
+            Payload::ImportSection(section) => {
+                for import in section {
+                    let import = import?;
+                    // Process all imports (functions are identified by their index in ImportIndexMap)
+                    import_map.process_import(import.name);
+                }
+            }
+            Payload::End(_) => break,
+            _ => {}
+        }
+    }
+    Ok(import_map)
+}
+
+fn analyze_ttl_expiry(
+    bytes: &[u8],
+    import_map: &ImportIndexMap,
+    path: &Path,
+) -> Result<Vec<LintFinding>> {
     let mut findings = Vec::new();
+    let parser = WasmParser::new(0);
+    let mut func_index = import_map.import_count + 1;
 
-    findings.extend(check_hardcoded_addresses(&content, path)?);
-    findings.extend(check_integer_overflows(&content, path)?);
+    for payload in parser.parse_all(bytes) {
+        match payload? {
+            Payload::CodeSectionEntry(body) => {
+                let mut analysis = FunctionStorageAnalysis::default();
+                let mut loop_depth = 0;
+                let mut operators = body.get_operators_reader()?;
+                while let Ok(operator) = operators.read() {
+                    match operator {
+                        Operator::Call { function_index } => {
+                            if import_map.is_storage_get(function_index) {
+                                analysis.has_storage_get = true;
+                                if loop_depth > 0 {
+                                    analysis.calls_in_loop = true;
+                                }
+                            }
+                            if import_map.is_storage_extend_ttl(function_index) {
+                                analysis.has_extend_ttl = true;
+                            }
+                        }
+                        Operator::Loop { .. } => loop_depth += 1,
+                        Operator::Block { .. } | Operator::If { .. } => loop_depth += 1,
+                        #[allow(clippy::collapsible_match)]
+                        Operator::End => {
+                            if loop_depth > 0 {
+                                loop_depth -= 1;
+                            }
+                        }
+                        _ => {}
+                    }
+                }
 
+                if analysis.has_storage_get && !analysis.has_extend_ttl {
+                    findings.push(LintFinding {
+                        file: path.display().to_string(),
+                        line: func_index,
+                        check: "ttl-expiry".to_string(),
+                        message: "storage.get() is used without a corresponding storage.extend_ttl() in the same function body. This can fail when the temporary storage TTL expires.".to_string(),
+                        severity: "warning".to_string(),
+                        fix_available: import_map.extend_ttl_available(),
+                    });
+                }
+                if analysis.calls_in_loop {
+                    findings.push(LintFinding {
+                        file: path.display().to_string(),
+                        line: func_index,
+                        check: "storage-loop".to_string(),
+                        message: "Detected storage reads inside a loop. Soroban charges per storage read, and unbounded iterations can become DoS vectors.".to_string(),
+                        severity: "warning".to_string(),
+                        fix_available: false,
+                    });
+                }
+                func_index += 1;
+            }
+            Payload::End(_) => break,
+            _ => {}
+        }
+    }
     Ok(findings)
 }
 
-fn check_hardcoded_addresses(content: &str, path: &Path) -> Result<Vec<LintFinding>> {
+fn analyze_persistent_storage_misuse(wat: &str, path: &Path) -> Result<Vec<LintFinding>> {
     let mut findings = Vec::new();
-    let file_str = path.to_string_lossy().to_string();
-
-    for (line_num, line) in content.lines().enumerate() {
-        if line.trim_start().starts_with("//") {
-            continue;
+    for (line_num, line) in wat.lines().enumerate() {
+        if (line.contains("Temporary") || line.contains("temporary"))
+            && (line.contains("storage") || line.contains("Storage") || line.contains("map"))
+        {
+            findings.push(LintFinding {
+                file: path.display().to_string(),
+                line: line_num + 1,
+                check: "temporary-storage-misuse".to_string(),
+                message: "Temporary contract storage is in use. Consider whether the data should be stored in Persistent storage to avoid eviction or TTL expiry.".to_string(),
+                severity: "warning".to_string(),
+                fix_available: false,
+            });
         }
+    }
+    Ok(findings)
+}
 
-        if line.contains("Address::from_string(") || (line.contains('\"') || line.contains('\'')) {
-            if let Some(addr_start) = line.find('"') {
-                if let Some(addr_end) = line[addr_start + 1..].find('"') {
-                    let potential_addr = &line[addr_start + 1..addr_start + 1 + addr_end];
-                    if potential_addr.starts_with('G') && potential_addr.len() == 56 {
-                        findings.push(LintFinding {
-                            file: file_str.clone(),
-                            line: line_num + 1,
-                            check: "hardcoded-address".to_string(),
-                            message: "Hardcoded Stellar address detected. Consider using environment configuration".to_string(),
-                            severity: "warning".to_string(),
-                        });
-                        continue;
-                    }
+fn analyze_vec_iteration(wat: &str, path: &Path) -> Result<Vec<LintFinding>> {
+    let mut findings = Vec::new();
+    let mut in_func = false;
+    let mut current_function = String::new();
+    let mut current_start_line = 0;
+    let mut depth = 0;
+
+    for (line_num, line) in wat.lines().enumerate() {
+        if !in_func {
+            if line.trim_start().starts_with("(func") {
+                in_func = true;
+                current_start_line = line_num + 1;
+                current_function.clear();
+                current_function.push_str(line);
+                current_function.push('\n');
+                depth = line.chars().filter(|&c| c == '(').count() as isize
+                    - line.chars().filter(|&c| c == ')').count() as isize;
+                continue;
+            }
+        } else {
+            current_function.push_str(line);
+            current_function.push('\n');
+            depth += line.chars().filter(|&c| c == '(').count() as isize;
+            depth -= line.chars().filter(|&c| c == ')').count() as isize;
+            if depth <= 0 {
+                if current_function.contains("loop")
+                    && (current_function.contains("storage.get")
+                        || current_function.contains("storage_get")
+                        || current_function.contains("map.get")
+                        || current_function.contains("map_get"))
+                {
+                    findings.push(LintFinding {
+                        file: path.display().to_string(),
+                        line: current_start_line,
+                        check: "storage-iteration".to_string(),
+                        message: "Detected looped iteration over contract storage. Each storage read is charged, so unbounded iterations can lead to high CPU costs or DoS risk.".to_string(),
+                        severity: "warning".to_string(),
+                        fix_available: false,
+                    });
                 }
+                in_func = false;
             }
+        }
+    }
+    Ok(findings)
+}
 
-            if let Some(addr_start) = line.find('\'') {
-                if let Some(addr_end) = line[addr_start + 1..].find('\'') {
-                    let potential_addr = &line[addr_start + 1..addr_start + 1 + addr_end];
-                    if potential_addr.starts_with('G') && potential_addr.len() == 56 {
-                        findings.push(LintFinding {
-                            file: file_str.clone(),
-                            line: line_num + 1,
-                            check: "hardcoded-address".to_string(),
-                            message: "Hardcoded Stellar address detected. Consider using environment configuration".to_string(),
-                            severity: "warning".to_string(),
-                        });
-                    }
+fn analyze_missing_auth(wat: &str, path: &Path) -> Result<Vec<LintFinding>> {
+    let mut findings = Vec::new();
+    let mut in_func = false;
+    let mut current_function = String::new();
+    let mut current_start_line = 0;
+    let mut depth = 0;
+
+    for (line_num, line) in wat.lines().enumerate() {
+        if !in_func {
+            if line.trim_start().starts_with("(func") {
+                in_func = true;
+                current_start_line = line_num + 1;
+                current_function.clear();
+                current_function.push_str(line);
+                current_function.push('\n');
+                depth = line.chars().filter(|&c| c == '(').count() as isize
+                    - line.chars().filter(|&c| c == ')').count() as isize;
+                continue;
+            }
+        } else {
+            current_function.push_str(line);
+            current_function.push('\n');
+            depth += line.chars().filter(|&c| c == '(').count() as isize;
+            depth -= line.chars().filter(|&c| c == ')').count() as isize;
+            if depth <= 0 {
+                if current_function.contains("invoke_contract")
+                    && !current_function.contains("require_auth")
+                {
+                    findings.push(LintFinding {
+                        file: path.display().to_string(),
+                        line: current_start_line,
+                        check: "missing-auth".to_string(),
+                        message: "Function invokes another contract before any require_auth() check. This may introduce authorization vulnerabilities.".to_string(),
+                        severity: "warning".to_string(),
+                        fix_available: false,
+                    });
                 }
+                in_func = false;
             }
         }
     }
-
     Ok(findings)
 }
 
-fn check_integer_overflows(content: &str, path: &Path) -> Result<Vec<LintFinding>> {
+fn analyze_budget(bytes: &[u8], path: &Path) -> Result<(BudgetReport, Vec<LintFinding>)> {
+    let mut code_section_bytes = 0;
+    let mut data_section_bytes = 0;
+    let parser = WasmParser::new(0);
+    for payload in parser.parse_all(bytes) {
+        match payload? {
+            Payload::CodeSectionEntry(body) => {
+                code_section_bytes += body.get_binary_reader().range().len();
+            }
+            Payload::DataSection(section) => {
+                for data in section.into_iter().flatten() {
+                    data_section_bytes += data.data.len();
+                }
+            }
+            Payload::End(_) => break,
+            _ => {}
+        }
+    }
+
+    let total_size_bytes = bytes.len();
+    let mut warnings = Vec::new();
     let mut findings = Vec::new();
-    let file_str = path.to_string_lossy().to_string();
 
-    for (line_num, line) in content.lines().enumerate() {
-        if line.trim_start().starts_with("//") {
-            continue;
-        }
+    if code_section_bytes > 250_000 {
+        warnings.push(
+            "Code section exceeds 250KB and may approach Soroban CPU budget limits.".to_string(),
+        );
+        findings.push(LintFinding {
+            file: path.display().to_string(),
+            line: 0,
+            check: "budget-code-size".to_string(),
+            message: "Large code section may increase contract CPU budget consumption.".to_string(),
+            severity: "warning".to_string(),
+            fix_available: false,
+        });
+    }
+    if data_section_bytes > 100_000 {
+        warnings.push("Data section exceeds 100KB and may raise memory budget usage.".to_string());
+        findings.push(LintFinding {
+            file: path.display().to_string(),
+            line: 0,
+            check: "budget-data-size".to_string(),
+            message: "Large data section may increase contract memory/budget costs.".to_string(),
+            severity: "warning".to_string(),
+            fix_available: false,
+        });
+    }
+    if total_size_bytes > 500_000 {
+        warnings.push(
+            "WASM file size exceeds 500KB. Consider optimizing and stripping symbols.".to_string(),
+        );
+        findings.push(LintFinding {
+            file: path.display().to_string(),
+            line: 0,
+            check: "budget-total-size".to_string(),
+            message: "Large wasm artifacts can increase deployment and execution costs."
+                .to_string(),
+            severity: "warning".to_string(),
+            fix_available: false,
+        });
+    }
+
+    Ok((
+        BudgetReport {
+            total_size_bytes,
+            code_section_bytes,
+            data_section_bytes,
+            warnings,
+        },
+        findings,
+    ))
+}
+
+fn apply_safe_fixes(wat: &str, import_map: &ImportIndexMap, path: &Path) -> Result<Option<String>> {
+    let extend_patterns = import_map.extend_ttl_patterns();
+    let get_patterns = import_map.storage_get_patterns();
+    if extend_patterns.is_empty() || get_patterns.is_empty() {
+        return Ok(None);
+    }
+
+    let mut fixed_wat = wat.to_string();
+    let mut changed = false;
+    let func_texts = split_wat_functions(wat);
 
-        let is_integer_line = line.contains("u64") || line.contains("u128");
-        if !is_integer_line {
-            continue;
+    for func in func_texts {
+        let func_body = format!("{}{}", func.0, func.1);
+        let contains_get = get_patterns.iter().any(|pat| func_body.contains(pat));
+        let contains_extend = extend_patterns.iter().any(|pat| func_body.contains(pat));
+        if contains_get && !contains_extend {
+            if let Some(pos) = func_body.find(get_patterns[0].as_str()) {
+                let insertion = format!("{}\n      ", extend_patterns[0]);
+                if let Some(base_pos) = fixed_wat.find(&func_body) {
+                    fixed_wat.insert_str(base_pos + pos, &insertion);
+                    changed = true;
+                }
+            }
         }
+    }
 
-        let has_safe_math = line.contains("checked_")
-            || line.contains("saturating_")
-            || line.contains("wrapping_")
-            || line.contains("overflow_")
-            || line.contains("safe_");
+    if !changed {
+        return Ok(None);
+    }
+
+    let fixed_bytes = wat::parse_str(&fixed_wat)
+        .with_context(|| "Failed to compile fixed WAT to Wasm; skipping automated fixes")?;
+    let mut output_path = path.to_path_buf();
+    output_path.set_file_name(format!(
+        "{}.fixed.wasm",
+        path.file_stem().unwrap().to_string_lossy()
+    ));
+    fs::write(&output_path, fixed_bytes)
+        .with_context(|| format!("Failed to write fixed wasm to {}", output_path.display()))?;
+
+    Ok(Some(output_path.display().to_string()))
+}
 
-        if has_safe_math {
-            continue;
+fn split_wat_functions(wat: &str) -> Vec<(String, String, usize)> {
+    let mut functions = Vec::new();
+    let lines: Vec<&str> = wat.lines().collect();
+    let mut i = 0;
+    while i < lines.len() {
+        let line = lines[i];
+        if line.trim_start().starts_with("(func") {
+            let mut depth = 0;
+            let mut prefix = String::new();
+            let mut suffix = String::new();
+            let mut started = false;
+            for j in i..lines.len() {
+                let row = lines[j];
+                let open = row.chars().filter(|&c| c == '(').count();
+                let close = row.chars().filter(|&c| c == ')').count();
+                depth += open as isize;
+                depth -= close as isize;
+                if !started {
+                    prefix.push_str(row);
+                    prefix.push('\n');
+                    started = true;
+                } else {
+                    suffix.push_str(row);
+                    suffix.push('\n');
+                }
+                if started && depth <= 0 {
+                    functions.push((prefix.clone(), suffix.clone(), i + 1));
+                    i = j;
+                    break;
+                }
+            }
         }
+        i += 1;
+    }
+    functions
+}
 
-        let has_arithmetic = (line.contains(" + ") || line.contains("+="))
-            && (line.contains("=") || line.contains("let") || line.contains("return"));
+#[derive(Default)]
+struct FunctionStorageAnalysis {
+    has_storage_get: bool,
+    has_extend_ttl: bool,
+    calls_in_loop: bool,
+}
 
-        if has_arithmetic {
-            findings.push(LintFinding {
-                file: file_str.clone(),
-                line: line_num + 1,
-                check: "potential-overflow".to_string(),
-                message: "Potential integer overflow in arithmetic operation. Consider using checked_add, saturating_add, or wrapping_add".to_string(),
-                severity: "warning".to_string(),
-            });
+#[derive(Default)]
+struct ImportIndexMap {
+    import_count: usize,
+    storage_get_indices: HashSet<u32>,
+    extend_ttl_indices: HashSet<u32>,
+}
+
+impl ImportIndexMap {
+    fn process_import(&mut self, field: &str) {
+        let index = self.import_count as u32;
+        if is_storage_get_name(field) {
+            self.storage_get_indices.insert(index);
         }
+        if is_storage_extend_ttl_name(field) {
+            self.extend_ttl_indices.insert(index);
+        }
+        self.import_count += 1;
+    }
 
-        let has_mult = (line.contains(" * ") || line.contains("*="))
-            && (line.contains("=") || line.contains("let") || line.contains("return"));
+    fn is_storage_get(&self, index: u32) -> bool {
+        self.storage_get_indices.contains(&index)
+    }
 
-        if has_mult {
-            findings.push(LintFinding {
-                file: file_str.clone(),
-                line: line_num + 1,
-                check: "potential-overflow".to_string(),
-                message: "Potential integer overflow in multiplication operation. Consider using checked_mul, saturating_mul, or wrapping_mul".to_string(),
-                severity: "warning".to_string(),
-            });
+    fn is_storage_extend_ttl(&self, index: u32) -> bool {
+        self.extend_ttl_indices.contains(&index)
+    }
+
+    fn extend_ttl_available(&self) -> bool {
+        !self.extend_ttl_indices.is_empty()
+    }
+
+    fn storage_get_patterns(&self) -> Vec<String> {
+        if self.storage_get_indices.is_empty() {
+            Vec::new()
+        } else {
+            vec!["storage_get".to_string(), "storage.get".to_string()]
         }
     }
 
-    Ok(findings)
+    fn extend_ttl_patterns(&self) -> Vec<String> {
+        if self.extend_ttl_indices.is_empty() {
+            Vec::new()
+        } else {
+            vec![
+                "storage_extend_ttl".to_string(),
+                "storage.extend_ttl".to_string(),
+                "extend_ttl".to_string(),
+            ]
+        }
+    }
+}
+
+fn is_storage_get_name(field: &str) -> bool {
+    field.contains("storage_get")
+        || field.contains("storage.get")
+        || field.contains("map_get")
+        || field.contains("map.get")
+}
+
+fn is_storage_extend_ttl_name(field: &str) -> bool {
+    field.contains("extend_ttl")
+        || field.contains("storage.extend_ttl")
+        || field.contains("storage_extend_ttl")
 }
diff --git a/src/commands/mod.rs b/src/commands/mod.rs
index 5836362c..261eb423 100644
--- a/src/commands/mod.rs
+++ b/src/commands/mod.rs
@@ -5,10 +5,13 @@ pub mod completions;
 pub mod config;
 pub mod contract;
 pub mod deploy;
+pub mod deploy_monitor;
 pub mod deployments;
 pub mod diagnostics;
 pub mod docs;
 pub mod doctor;
+pub mod events;
+pub mod fuzz;
 pub mod gas;
 pub mod info;
 pub mod inspect;
@@ -24,8 +27,10 @@ pub mod perf;
 pub mod plugin;
 pub mod registry;
 pub mod security;
+pub mod sep;
 pub mod shell;
 pub mod social;
+pub mod state;
 pub mod telemetry;
 pub mod template;
 pub mod template_vcs;
diff --git a/src/commands/monitor.rs b/src/commands/monitor.rs
index 47f63fc7..4789f292 100644
--- a/src/commands/monitor.rs
+++ b/src/commands/monitor.rs
@@ -68,23 +68,29 @@ pub async fn handle(args: MonitorArgs) -> Result<()> {
     println!();
 
     match (&args.contract, &args.wallet) {
-        (Some(contract_id), None) => monitor_contract(
-            contract_id,
-            args.events.as_deref(),
-            args.event_type.as_deref(),
-            args.topic.as_deref(),
-            args.value.as_deref(),
-            network,
-            args.interval,
-            args.follow,
-        ).await,
-        (None, Some(wallet_name)) => monitor_wallet(
-            wallet_name,
-            args.threshold,
-            args.balance_alert,
-            network,
-            args.interval,
-        ).await,
+        (Some(contract_id), None) => {
+            monitor_contract(
+                contract_id,
+                args.events.as_deref(),
+                args.event_type.as_deref(),
+                args.topic.as_deref(),
+                args.value.as_deref(),
+                network,
+                args.interval,
+                args.follow,
+            )
+            .await
+        }
+        (None, Some(wallet_name)) => {
+            monitor_wallet(
+                wallet_name,
+                args.threshold,
+                args.balance_alert,
+                network,
+                args.interval,
+            )
+            .await
+        }
         _ => anyhow::bail!("Specify either --contract or --wallet (but not both)"),
     }
 }
diff --git a/src/commands/new.rs b/src/commands/new.rs
index b4959ca2..d8e63abc 100644
--- a/src/commands/new.rs
+++ b/src/commands/new.rs
@@ -1,3 +1,4 @@
+use crate::utils::preflight;
 use crate::utils::print as p;
 use crate::utils::templates;
 use anyhow::{Context, Result};
@@ -100,7 +101,7 @@ fn search_templates(query: &str) -> Result<()> {
     Ok(())
 }
 
-// ── Interactive mode ──────────────────────────────────────────────────────────
+// ?? Interactive mode ??????????????????????????????????????????????????????????
 
 struct ContractOptions {
     name: String,
@@ -114,7 +115,7 @@ fn scaffold_contract_interactive(default_name: String) -> Result<()> {
     let theme = ColorfulTheme::default();
 
     println!();
-    println!("  {} Let's set up your contract.\n", "✦".cyan());
+    println!("  {} Let's set up your contract.\n", "?".cyan());
 
     // 1. Contract name
     let name: String = Input::with_theme(&theme)
@@ -162,7 +163,7 @@ fn scaffold_contract_interactive(default_name: String) -> Result<()> {
 
     // Summary + confirm
     println!();
-    println!("  {} Summary:", "◆".bright_white());
+    println!("  {} Summary:", "?".bright_white());
     println!("    Contract name : {}", opts.name.cyan());
     println!("    Author        : {}", opts.author.cyan());
     println!("    License       : {}", opts.license.cyan());
@@ -183,7 +184,7 @@ fn scaffold_contract_interactive(default_name: String) -> Result<()> {
         .interact()?;
 
     if !confirmed {
-        println!("\n  {} Aborted — no files written.\n", "✗".red());
+        println!("\n  {} Aborted - no files written.\n", "?".red());
         return Ok(());
     }
 
@@ -212,13 +213,25 @@ fn scaffold_contract(
     let dir = Path::new(&name);
     if dir.exists() {
         anyhow::bail!(
-            "Directory '{}' already exists.\n  • Choose a different project name, or remove the existing directory first.",
+            "Directory '{}' already exists.\n  . Choose a different project name, or remove the existing directory first.",
             name
         );
     }
 
     p::header(&format!("Scaffolding Soroban contract: {}", name));
     println!("  Template: {}\n", template.cyan());
+
+    let preflight = preflight::run_contract_preflight(false)?;
+    p::success(&format!(
+        "Rust toolchain ready: cargo {}, wasm32 target installed",
+        preflight.cargo_version
+    ));
+    if !preflight.stellar_cli_available {
+        p::warn(
+            "`stellar` CLI was not found. The contract can be scaffolded now, but install Stellar CLI before building or deploying.",
+        );
+    }
+
     // Ensure selected template is compatible with current CLI version
     let entry = templates::get_template(&template)?;
     match templates::check_template_compatibility(&entry) {
@@ -255,16 +268,16 @@ fn scaffold_contract(
     // Roll back the partially-created directory if any step below fails.
     let mut target_guard = PathCleanup::new(dir.to_path_buf());
 
-    p::step(1, 4, "Creating directory structure…");
+    p::step(1, 4, "Creating directory structure.");
     fs::create_dir_all(dir.join("src"))?;
     fs::create_dir_all(dir.join(".cargo"))?;
 
-    p::step(2, 4, "Writing Cargo.toml…");
+    p::step(2, 4, "Writing Cargo.toml.");
     fs::write(dir.join("Cargo.toml"), cargo_toml(&name, license, author))?;
     fs::write(dir.join(".cargo/config.toml"), cargo_config())?;
     fs::write(dir.join(".gitignore"), "target/\n.soroban/\n")?;
 
-    p::step(3, 4, &format!("Generating '{}' contract source…", template));
+    p::step(3, 4, &format!("Generating '{}' contract source.", template));
     let src = match template.as_str() {
         "token" => token_template(&name),
         "voting" => voting_template(&name),
@@ -284,7 +297,7 @@ fn scaffold_contract(
     };
     fs::write(dir.join("src/lib.rs"), src)?;
 
-    p::step(4, 4, "Writing README.md…");
+    p::step(4, 4, "Writing README.md.");
     fs::write(dir.join("README.md"), readme(&name, &template, source))?;
 
     // Scaffolding completed: keep the directory.
@@ -312,14 +325,14 @@ fn scaffold_dapp(name: String) -> Result<()> {
 
     p::header(&format!("Scaffolding Stellar dApp: {}", name));
 
-    p::step(1, 3, "Creating project structure…");
+    p::step(1, 3, "Creating project structure.");
     fs::create_dir_all(dir.join("src/components"))?;
     fs::create_dir_all(dir.join("public"))?;
 
-    p::step(2, 3, "Writing package.json…");
+    p::step(2, 3, "Writing package.json.");
     fs::write(dir.join("package.json"), dapp_package(&name))?;
 
-    p::step(3, 3, "Writing app scaffold…");
+    p::step(3, 3, "Writing app scaffold.");
     fs::write(dir.join("index.html"), dapp_index(&name))?;
     fs::write(dir.join("src/main.jsx"), dapp_main())?;
     fs::write(dir.join("src/App.jsx"), dapp_app(&name))?;
@@ -333,7 +346,7 @@ fn scaffold_dapp(name: String) -> Result<()> {
     Ok(())
 }
 
-// ── Helpers ──────────────────────────────────────────────────────────────────
+// ?? Helpers ??????????????????????????????????????????????????????????????????
 
 fn to_pascal(s: &str) -> String {
     s.split(['-', '_', ' '])
@@ -347,7 +360,7 @@ fn to_pascal(s: &str) -> String {
         .collect()
 }
 
-// ── Cargo files ──────────────────────────────────────────────────────────────
+// ?? Cargo files ??????????????????????????????????????????????????????????????
 
 fn cargo_toml(name: &str, license: &str, author: &str) -> String {
     let license_field = if license == "None" || license.is_empty() {
@@ -394,7 +407,7 @@ rustflags = ["-C", "target-feature=+multivalue,+sign-ext"]
 "#
 }
 
-// ── Contract templates ────────────────────────────────────────────────────────
+// ?? Contract templates ????????????????????????????????????????????????????????
 
 fn hello_world_template(name: &str, storage: &str, include_tests: bool) -> String {
     let pascal = to_pascal(name);
@@ -821,7 +834,7 @@ mod test {{
     )
 }
 
-// ── dApp scaffold files ───────────────────────────────────────────────────────
+// ?? dApp scaffold files ???????????????????????????????????????????????????????
 
 fn dapp_package(name: &str) -> String {
     format!(
@@ -900,7 +913,7 @@ fn dapp_app(name: &str) -> String {
 export default function App() {{
   return (
     <div style={{{{ fontFamily: 'monospace', padding: '2rem' }}}}>
-      <h1>⚡ {name}</h1>
+      <h1>? {name}</h1>
       <p>Your Stellar dApp is ready. Start building!</p>
     </div>
   )
@@ -962,10 +975,10 @@ Source: `{source}`
     )
 }
 
-// ── Template Marketplace ──────────────────────────────────────────────────────
+// ?? Template Marketplace ??????????????????????????????????????????????????????
 
 fn handle_template_search(query: &str, tags: Option<&str>) -> Result<()> {
-    p::header("Template Marketplace — Search");
+    p::header("Template Marketplace - Search");
     p::kv("Query", query);
 
     let tag_list = tags.map(|t| {
@@ -994,14 +1007,14 @@ fn handle_template_search(query: &str, tags: Option<&str>) -> Result<()> {
 
     for (i, tmpl) in results.iter().enumerate() {
         let verified = if tmpl.verified {
-            " ✓".green()
+            " ?".green()
         } else {
             "".normal()
         };
         println!("  {}. {}{}", i + 1, tmpl.name.cyan().bold(), verified);
         println!("     {}", tmpl.description.dimmed());
         println!(
-            "     {} • {} • {} downloads",
+            "     {} . {} . {} downloads",
             tmpl.version.yellow(),
             tmpl.author.dimmed(),
             tmpl.downloads
@@ -1074,7 +1087,7 @@ fn install_step<T>(
     let pb = p::spinner(label);
     match action() {
         Ok(value) => {
-            pb.finish_with_message(format!("✓ {}", done));
+            pb.finish_with_message(format!("? {}", done));
             Ok(value)
         }
         Err(e) => {
@@ -1090,7 +1103,7 @@ fn scaffold_from_marketplace(name: String, template_name: String) -> Result<()>
     // Get template from registry
     let template = templates::get_template(&template_name).with_context(|| {
         format!(
-            "Template '{}' not found in the registry.\n  • List templates with `starforge template list`.\n  • Search with `starforge new contract --search {}`.",
+            "Template '{}' not found in the registry.\n  . List templates with `starforge template list`.\n  . Search with `starforge new contract --search {}`.",
             template_name, template_name
         )
     })?;
@@ -1098,7 +1111,7 @@ fn scaffold_from_marketplace(name: String, template_name: String) -> Result<()>
     let dir = Path::new(&name);
     if dir.exists() {
         anyhow::bail!(
-            "Directory '{}' already exists.\n  • Choose a different project name, or remove the existing directory first.",
+            "Directory '{}' already exists.\n  . Choose a different project name, or remove the existing directory first.",
             name
         );
     }
@@ -1121,19 +1134,19 @@ fn scaffold_from_marketplace(name: String, template_name: String) -> Result<()>
     let mut target_guard = PathCleanup::new(dir.to_path_buf());
 
     install_step(
-        &format!("[1/3] Fetching template '{}'…", template.name),
+        &format!("[1/3] Fetching template '{}'.", template.name),
         &format!("Fetched template '{}'", template.name),
         || templates::fetch_template(&template, &temp_dir),
         || {
             format!(
-                "Failed to fetch template '{}' from {}.\n  • Check your network connection and that `git` is installed.\n  • The partial download was rolled back automatically.",
+                "Failed to fetch template '{}' from {}.\n  . Check your network connection and that `git` is installed.\n  . The partial download was rolled back automatically.",
                 template.name, template.source
             )
         },
     )?;
 
     install_step(
-        "[2/3] Validating template structure…",
+        "[2/3] Validating template structure.",
         "Template structure is valid",
         || {
             templates::validate_template_structure(
@@ -1146,14 +1159,14 @@ fn scaffold_from_marketplace(name: String, template_name: String) -> Result<()>
         },
         || {
             format!(
-                "Template '{}' is missing required files (expected Cargo.toml, src/ and src/lib.rs).\n  • The template may be malformed; contact its author or pick another.\n  • The partial install was rolled back automatically.",
+                "Template '{}' is missing required files (expected Cargo.toml, src/ and src/lib.rs).\n  . The template may be malformed; contact its author or pick another.\n  . The partial install was rolled back automatically.",
                 template.name
             )
         },
     )?;
 
     install_step(
-        "[3/3] Installing into project directory…",
+        "[3/3] Installing into project directory.",
         &format!("Installed into '{}'", name),
         || {
             fs::create_dir_all(dir).with_context(|| {
@@ -1163,7 +1176,7 @@ fn scaffold_from_marketplace(name: String, template_name: String) -> Result<()>
         },
         || {
             format!(
-                "Failed to install template into '{}'.\n  • Check that you have write permission for this location and enough disk space.\n  • The half-written project directory was rolled back automatically.",
+                "Failed to install template into '{}'.\n  . Check that you have write permission for this location and enough disk space.\n  . The half-written project directory was rolled back automatically.",
                 name
             )
         },
diff --git a/src/commands/perf.rs b/src/commands/perf.rs
index cc80bdda..79692d4d 100644
--- a/src/commands/perf.rs
+++ b/src/commands/perf.rs
@@ -139,7 +139,10 @@ pub async fn handle(cmd: PerfCommands) -> Result<()> {
         PerfCommands::Bottleneck { contract, network } => bottleneck(contract, network),
         PerfCommands::Optimize { contract, network } => optimize(contract, network),
         PerfCommands::Cache { contract, enable } => cache(contract, enable),
-        PerfCommands::Benchmark { contract, iterations } => benchmark(contract, iterations),
+        PerfCommands::Benchmark {
+            contract,
+            iterations,
+        } => benchmark(contract, iterations),
     }
 }
 
@@ -418,8 +421,11 @@ fn bottleneck(contract: String, _network: String) -> Result<()> {
         return Ok(());
     }
 
-    let avg_gas: f64 = gas_history.iter().map(|r| r.gas_used as f64).sum::<f64>() / gas_history.len() as f64;
-    let max_record = gas_history.iter().max_by(|a, b| a.gas_used.cmp(&b.gas_used));
+    let avg_gas: f64 =
+        gas_history.iter().map(|r| r.gas_used as f64).sum::<f64>() / gas_history.len() as f64;
+    let max_record = gas_history
+        .iter()
+        .max_by(|a, b| a.gas_used.cmp(&b.gas_used));
 
     p::separator();
     p::info("Bottleneck Analysis");
@@ -461,19 +467,27 @@ fn optimize(contract: String, _network: String) -> Result<()> {
 
     let mut suggestions = Vec::new();
 
-    let success_rate = 1.0 - (gas_history.iter().filter(|r| !r.success).count() as f64 / gas_history.len() as f64);
+    let success_rate =
+        1.0 - (gas_history.iter().filter(|r| !r.success).count() as f64 / gas_history.len() as f64);
     if success_rate < 0.95 {
         suggestions.push("High failure rate detected. Review contract logic and error handling.");
     }
 
-    let avg_time: f64 = gas_history.iter().map(|r| r.execution_time_ms as f64).sum::<f64>() / gas_history.len() as f64;
+    let avg_time: f64 = gas_history
+        .iter()
+        .map(|r| r.execution_time_ms as f64)
+        .sum::<f64>()
+        / gas_history.len() as f64;
     if avg_time > 5000.0 {
-        suggestions.push("Execution time exceeds 5 seconds. Consider breaking into smaller operations.");
+        suggestions
+            .push("Execution time exceeds 5 seconds. Consider breaking into smaller operations.");
     }
 
-    let avg_gas: f64 = gas_history.iter().map(|r| r.gas_used as f64).sum::<f64>() / gas_history.len() as f64;
+    let avg_gas: f64 =
+        gas_history.iter().map(|r| r.gas_used as f64).sum::<f64>() / gas_history.len() as f64;
     if avg_gas > 100_000.0 {
-        suggestions.push("Gas usage is high. Profile critical functions and optimize storage access.");
+        suggestions
+            .push("Gas usage is high. Profile critical functions and optimize storage access.");
     }
 
     if suggestions.is_empty() {
@@ -546,9 +560,18 @@ fn benchmark(contract: String, iterations: u32) -> Result<()> {
 
     println!();
     p::info("Summary");
-    p::kv("Avg Gas", &format!("{:.0}", total_gas as f64 / iterations as f64));
-    p::kv("Avg Time", &format!("{:.0}ms", total_time as f64 / iterations as f64));
-    p::kv("Success Rate", &format!("{:.1}%", (successes as f64 / iterations as f64) * 100.0));
+    p::kv(
+        "Avg Gas",
+        &format!("{:.0}", total_gas as f64 / iterations as f64),
+    );
+    p::kv(
+        "Avg Time",
+        &format!("{:.0}ms", total_time as f64 / iterations as f64),
+    );
+    p::kv(
+        "Success Rate",
+        &format!("{:.1}%", (successes as f64 / iterations as f64) * 100.0),
+    );
 
     p::separator();
     Ok(())
diff --git a/src/commands/plugin.rs b/src/commands/plugin.rs
index 4673cf65..1c1a4c1c 100644
--- a/src/commands/plugin.rs
+++ b/src/commands/plugin.rs
@@ -250,7 +250,7 @@ fn load() -> Result<()> {
         return Ok(());
     }
 
-    let config = config::load().unwrap_or_default();
+    let _config = crate::utils::config::load().unwrap_or_default();
 
     // Warn about any unknown-trust plugins before loading.
     for pl in reg.plugins.iter().filter(|p| {
@@ -403,7 +403,7 @@ fn update(name: Option<String>, yes: bool) -> Result<()> {
         return Ok(());
     }
 
-    let config = config::load().unwrap_or_default();
+    let _config = crate::utils::config::load().unwrap_or_default();
 
     let to_update: Vec<_> = match &name {
         Some(n) => {
@@ -607,7 +607,7 @@ fn verify(name: Option<String>, deep: bool, runtime_check: bool) -> Result<()> {
         None => reg.plugins.iter().collect(),
     };
 
-    let config = config::load().unwrap_or_default();
+    let _config = crate::utils::config::load().unwrap_or_default();
     let mut all_ok = true;
 
     for pl in &to_check {
diff --git a/src/commands/sep.rs b/src/commands/sep.rs
new file mode 100644
index 00000000..dbeaa218
--- /dev/null
+++ b/src/commands/sep.rs
@@ -0,0 +1,459 @@
+use crate::utils::{config, crypto, print as p, stellar_toml};
+use anyhow::{Context, Result};
+use base64::Engine;
+use clap::Subcommand;
+use ed25519_dalek::{Signer, SigningKey};
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+use stellar_strkey::ed25519::PrivateKey as StellarPrivateKey;
+use stellar_xdr::curr::{
+    BytesM, DecoratedSignature, Limits, OperationBody, Preconditions, ReadXdr,
+    Signature as XdrSignature, SignatureHint, TransactionEnvelope, WriteXdr,
+};
+
+#[derive(Subcommand)]
+pub enum SepCommands {
+    /// SEP-10 Web Authentication — get a JWT from an anchor
+    Auth {
+        /// Anchor domain (e.g. testanchor.stellar.org)
+        #[arg(long)]
+        anchor: String,
+        /// Name of the local wallet to authenticate with
+        #[arg(long)]
+        wallet: String,
+    },
+    /// SEP-24 Hosted Deposit — initiate an interactive deposit with an anchor
+    Deposit {
+        /// Anchor domain (e.g. testanchor.stellar.org)
+        #[arg(long)]
+        anchor: String,
+        /// Asset code to deposit (e.g. USDC)
+        #[arg(long)]
+        asset: String,
+        /// Amount to deposit
+        #[arg(long)]
+        amount: f64,
+        /// Name of the local wallet to use
+        #[arg(long)]
+        wallet: String,
+    },
+}
+
+pub fn handle(cmd: SepCommands) -> Result<()> {
+    match cmd {
+        SepCommands::Auth { anchor, wallet } => sep10_auth(&anchor, &wallet),
+        SepCommands::Deposit {
+            anchor,
+            asset,
+            amount,
+            wallet,
+        } => sep24_deposit(&anchor, &asset, amount, &wallet),
+    }
+}
+
+// ── SEP-10 ───────────────────────────────────────────────────────────────────
+
+fn sep10_auth(anchor: &str, wallet_name: &str) -> Result<()> {
+    p::header("SEP-10 Web Authentication");
+
+    // Load config and find wallet
+    let cfg = config::load()?;
+    let wallet = cfg
+        .wallets
+        .iter()
+        .find(|w| w.name == wallet_name)
+        .with_context(|| {
+            format!(
+                "Wallet '{}' not found. Run `starforge wallet list` to see available wallets.",
+                wallet_name
+            )
+        })?;
+    let public_key = wallet.public_key.clone();
+
+    p::info(&format!("Authenticating wallet '{}'", wallet_name));
+    p::kv("Public Key", &public_key);
+
+    // Step 1: Fetch stellar.toml
+    p::step(1, 5, "Fetching stellar.toml...");
+    let toml = stellar_toml::fetch(anchor)
+        .with_context(|| format!("Failed to fetch stellar.toml from anchor '{}'", anchor))?;
+    let web_auth_endpoint = toml.web_auth_endpoint.with_context(|| {
+        format!(
+            "Anchor '{}' does not publish WEB_AUTH_ENDPOINT in stellar.toml",
+            anchor
+        )
+    })?;
+    p::kv("WEB_AUTH_ENDPOINT", &web_auth_endpoint);
+
+    // Step 2: GET challenge
+    p::step(2, 5, "Fetching SEP-10 challenge...");
+    let challenge_url = format!("{}?account={}", web_auth_endpoint, public_key);
+    let challenge_resp = ureq::get(&challenge_url)
+        .call()
+        .with_context(|| format!("Failed to get challenge from {}", web_auth_endpoint))?;
+    let challenge_json: serde_json::Value = challenge_resp
+        .into_json()
+        .context("Failed to parse challenge response as JSON")?;
+
+    let challenge_xdr = challenge_json["transaction"]
+        .as_str()
+        .context("Challenge response missing 'transaction' field")?;
+    let network_passphrase = challenge_json["network_passphrase"]
+        .as_str()
+        .unwrap_or("Test SDF Network ; September 2015");
+
+    // Step 3: Decode and verify the challenge transaction
+    p::step(3, 5, "Verifying challenge transaction...");
+    let xdr_bytes = base64::engine::general_purpose::STANDARD
+        .decode(challenge_xdr)
+        .context("Failed to decode base64 challenge transaction")?;
+    let envelope = TransactionEnvelope::from_xdr(&xdr_bytes, Limits::none())
+        .context("Failed to parse challenge transaction XDR")?;
+
+    // Verify in immutable scope, produce the sig to add
+    let (new_sig, existing_sigs) = {
+        let TransactionEnvelope::Tx(ref tx_v1) = envelope else {
+            anyhow::bail!("Expected TransactionEnvelope::Tx (V1), got a different variant");
+        };
+        let tx = &tx_v1.tx;
+
+        // Verify time bounds are present and not expired
+        let now = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        let max_time = match &tx.cond {
+            Preconditions::Time(tb) => tb.max_time.0,
+            Preconditions::V2(v2) => v2
+                .time_bounds
+                .as_ref()
+                .map(|tb| tb.max_time.0)
+                .with_context(|| "Challenge transaction has no time bounds (required by SEP-10)")?,
+            Preconditions::None => {
+                anyhow::bail!(
+                    "Challenge transaction has no preconditions; time bounds required by SEP-10"
+                );
+            }
+        };
+        if max_time < now {
+            anyhow::bail!(
+                "Challenge transaction has expired (max_time {} < current time {})",
+                max_time,
+                now
+            );
+        }
+
+        // Verify first operation is manage_data with key "<anchor> auth"
+        if tx.operations.is_empty() {
+            anyhow::bail!("Challenge transaction has no operations");
+        }
+        match &tx.operations[0].body {
+            OperationBody::ManageData(md) => {
+                let key = md.data_name.0.to_utf8_string_lossy();
+                let expected = format!("{} auth", anchor);
+                if key != expected {
+                    anyhow::bail!(
+                        "Challenge manage_data key mismatch: expected '{}', got '{}'",
+                        expected,
+                        key
+                    );
+                }
+                match &md.data_value {
+                    Some(dv) if dv.0.len() == 64 => {}
+                    Some(dv) => {
+                        anyhow::bail!("Challenge nonce must be 64 bytes, got {}", dv.0.len())
+                    }
+                    None => anyhow::bail!("Challenge manage_data operation has no data value"),
+                }
+            }
+            _ => anyhow::bail!("First operation in challenge is not a manage_data operation"),
+        }
+
+        // Compute transaction signing hash
+        let network_id: [u8; 32] = Sha256::digest(network_passphrase.as_bytes()).into();
+        let tx_body = tx
+            .to_xdr(Limits::none())
+            .context("Failed to XDR-encode transaction body for signing")?;
+        let mut payload = Vec::with_capacity(36 + tx_body.len());
+        payload.extend_from_slice(&network_id);
+        payload.extend_from_slice(&[0u8, 0, 0, 2]); // ENVELOPE_TYPE_TX = 2
+        payload.extend_from_slice(&tx_body);
+        let hash: [u8; 32] = Sha256::digest(&payload).into();
+
+        // Decrypt wallet secret key and sign
+        let sk_str = wallet
+            .secret_key
+            .as_ref()
+            .with_context(|| format!("Wallet '{}' has no secret key stored", wallet_name))?;
+        let plain_sk = if sk_str.contains(':') {
+            let pwd = crypto::prompt_password(
+                &format!("Enter password for wallet '{}'", wallet_name),
+                false,
+            )?;
+            crypto::decrypt_secret(&pwd, sk_str)
+                .map_err(|_| anyhow::anyhow!("Incorrect password or unable to decrypt wallet"))?
+        } else {
+            sk_str.clone()
+        };
+        let decoded = StellarPrivateKey::from_string(&plain_sk)
+            .context("Failed to parse wallet secret key")?;
+        let signing_key = SigningKey::from_bytes(&decoded.0);
+        let pub_bytes = signing_key.verifying_key().to_bytes();
+        let dalek_sig = signing_key.sign(&hash);
+
+        let hint = SignatureHint([pub_bytes[28], pub_bytes[29], pub_bytes[30], pub_bytes[31]]);
+        let xdr_sig = XdrSignature(
+            BytesM::try_from(dalek_sig.to_bytes().to_vec())
+                .map_err(|_| anyhow::anyhow!("Failed to encode ed25519 signature as XDR bytes"))?,
+        );
+        let new_sig = DecoratedSignature {
+            hint,
+            signature: xdr_sig,
+        };
+        let existing: Vec<DecoratedSignature> = tx_v1.signatures.iter().cloned().collect();
+        (new_sig, existing)
+    };
+
+    // Rebuild envelope with the added signature
+    let mut envelope = envelope;
+    let TransactionEnvelope::Tx(ref mut tx_v1) = envelope else {
+        unreachable!()
+    };
+    let mut sigs = existing_sigs;
+    sigs.push(new_sig);
+    tx_v1.signatures = sigs
+        .try_into()
+        .map_err(|_| anyhow::anyhow!("Signature count exceeds envelope limit"))?;
+
+    let xdr_bytes = envelope
+        .to_xdr(Limits::none())
+        .context("Failed to XDR-encode signed transaction")?;
+    let signed_xdr = base64::engine::general_purpose::STANDARD.encode(&xdr_bytes);
+
+    // Step 4: POST signed transaction to get JWT
+    p::step(4, 5, "Submitting signed challenge...");
+    let body = serde_json::to_string(&serde_json::json!({ "transaction": signed_xdr }))?;
+    let token_resp = ureq::post(&web_auth_endpoint)
+        .set("Content-Type", "application/json")
+        .send_string(&body)
+        .with_context(|| format!("Failed to submit signed challenge to {}", web_auth_endpoint))?;
+    let token_json: serde_json::Value = token_resp
+        .into_json()
+        .context("Failed to parse JWT response as JSON")?;
+    let jwt = token_json["token"]
+        .as_str()
+        .context("JWT response missing 'token' field")?;
+
+    // Step 5: Store JWT
+    p::step(5, 5, "Storing JWT...");
+    save_sep10_token(anchor, jwt)?;
+
+    p::separator();
+    p::success(&format!("Authenticated with anchor '{}'", anchor));
+    p::kv("JWT stored for", anchor);
+    Ok(())
+}
+
+// ── SEP-24 ───────────────────────────────────────────────────────────────────
+
+fn sep24_deposit(anchor: &str, asset: &str, amount: f64, wallet_name: &str) -> Result<()> {
+    p::header("SEP-24 Interactive Deposit");
+
+    let cfg = config::load()?;
+    let wallet = cfg
+        .wallets
+        .iter()
+        .find(|w| w.name == wallet_name)
+        .with_context(|| format!("Wallet '{}' not found", wallet_name))?;
+    let public_key = wallet.public_key.clone();
+
+    p::info(&format!(
+        "Deposit: {} {} via anchor '{}'",
+        amount, asset, anchor
+    ));
+    p::kv("Wallet", wallet_name);
+    p::kv("Public Key", &public_key);
+
+    // Step 1: Ensure we have a SEP-10 JWT
+    p::step(1, 4, "Getting SEP-10 authentication token...");
+    let tokens = load_sep10_tokens()?;
+    let jwt = if let Some(token) = tokens.get(anchor) {
+        p::info("Using stored SEP-10 token");
+        token.clone()
+    } else {
+        p::info("No stored token found — running SEP-10 auth first...");
+        sep10_auth(anchor, wallet_name)?;
+        let refreshed = load_sep10_tokens()?;
+        refreshed
+            .get(anchor)
+            .cloned()
+            .context("SEP-10 auth succeeded but token was not stored")?
+    };
+
+    // Step 2: Get TRANSFER_SERVER_SEP0024 from stellar.toml
+    p::step(2, 4, "Fetching stellar.toml...");
+    let toml = stellar_toml::fetch(anchor)
+        .with_context(|| format!("Failed to fetch stellar.toml from '{}'", anchor))?;
+    let transfer_server = toml.transfer_server_sep0024.with_context(|| {
+        format!(
+            "Anchor '{}' does not publish TRANSFER_SERVER_SEP0024 in stellar.toml",
+            anchor
+        )
+    })?;
+    p::kv("TRANSFER_SERVER", &transfer_server);
+
+    // Step 3: POST /transactions/deposit/interactive
+    p::step(3, 4, "Initiating interactive deposit...");
+    let amount_str = format!("{}", amount);
+    let deposit_resp = ureq::post(&format!(
+        "{}/transactions/deposit/interactive",
+        transfer_server.trim_end_matches('/')
+    ))
+    .set("Authorization", &format!("Bearer {}", jwt))
+    .send_form(&[
+        ("asset_code", asset),
+        ("amount", &amount_str),
+        ("account", &public_key),
+    ])
+    .with_context(|| {
+        format!(
+            "Failed to initiate deposit at {}/transactions/deposit/interactive",
+            transfer_server
+        )
+    })?;
+
+    let deposit_json: serde_json::Value = deposit_resp
+        .into_json()
+        .context("Failed to parse deposit response as JSON")?;
+
+    let resp_type = deposit_json["type"].as_str().unwrap_or("");
+    if resp_type != "interactive_customer_info_needed" {
+        anyhow::bail!(
+            "Unexpected response type '{}' from deposit endpoint; expected 'interactive_customer_info_needed'",
+            resp_type
+        );
+    }
+
+    let url = deposit_json["url"]
+        .as_str()
+        .context("Deposit response missing 'url' field")?;
+    let tx_id = deposit_json["id"]
+        .as_str()
+        .context("Deposit response missing 'id' field")?;
+
+    p::success("Interactive deposit session created");
+    p::kv("Transaction ID", tx_id);
+    p::kv("Deposit URL", url);
+
+    // Step 4: Open browser and poll for completion
+    p::step(4, 4, "Opening deposit URL in browser...");
+    open_browser(url)?;
+    println!();
+    p::info("Complete the deposit in the browser, then this CLI will detect completion.");
+    p::info("Polling every 5 seconds (timeout: 2 minutes)...");
+    println!();
+
+    poll_sep24_transaction(transfer_server.trim_end_matches('/'), tx_id, &jwt)?;
+
+    Ok(())
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+fn sep10_tokens_path() -> Result<PathBuf> {
+    Ok(config::get_data_dir()?.join("sep10_tokens.json"))
+}
+
+fn load_sep10_tokens() -> Result<HashMap<String, String>> {
+    let path = sep10_tokens_path()?;
+    if !path.exists() {
+        return Ok(HashMap::new());
+    }
+    let content = fs::read_to_string(&path).context("Failed to read SEP-10 token store")?;
+    serde_json::from_str(&content).context("Failed to parse SEP-10 token store as JSON")
+}
+
+fn save_sep10_token(anchor: &str, token: &str) -> Result<()> {
+    let path = sep10_tokens_path()?;
+    let mut tokens = load_sep10_tokens()?;
+    tokens.insert(anchor.to_string(), token.to_string());
+    let json = serde_json::to_string_pretty(&tokens)?;
+    fs::write(&path, json).context("Failed to write SEP-10 token store")?;
+    Ok(())
+}
+
+fn open_browser(url: &str) -> Result<()> {
+    #[cfg(target_os = "macos")]
+    {
+        std::process::Command::new("open")
+            .arg(url)
+            .spawn()
+            .context("Failed to open browser with 'open'")?;
+    }
+    #[cfg(target_os = "linux")]
+    {
+        std::process::Command::new("xdg-open")
+            .arg(url)
+            .spawn()
+            .context("Failed to open browser with 'xdg-open'")?;
+    }
+    #[cfg(target_os = "windows")]
+    {
+        std::process::Command::new("cmd")
+            .args(["/C", "start", url])
+            .spawn()
+            .context("Failed to open browser with 'start'")?;
+    }
+    Ok(())
+}
+
+fn poll_sep24_transaction(transfer_server: &str, tx_id: &str, jwt: &str) -> Result<()> {
+    let poll_url = format!("{}/transaction?id={}", transfer_server, tx_id);
+    for attempt in 1u32..=24 {
+        std::thread::sleep(std::time::Duration::from_secs(5));
+        let resp = match ureq::get(&poll_url)
+            .set("Authorization", &format!("Bearer {}", jwt))
+            .call()
+        {
+            Ok(r) => r,
+            Err(e) => {
+                p::warn(&format!("Poll attempt {} failed: {}", attempt, e));
+                continue;
+            }
+        };
+        let json: serde_json::Value = resp
+            .into_json()
+            .context("Failed to parse transaction poll response")?;
+        let status = json["transaction"]["status"].as_str().unwrap_or("unknown");
+        match status {
+            "completed" => {
+                p::separator();
+                p::success("Deposit completed!");
+                if let Some(stellar_tx_id) = json["transaction"]["stellar_transaction_id"].as_str()
+                {
+                    p::kv("Stellar Transaction ID", stellar_tx_id);
+                }
+                if let Some(amount) = json["transaction"]["amount_in"].as_str() {
+                    p::kv("Amount In", amount);
+                }
+                if let Some(amount) = json["transaction"]["amount_out"].as_str() {
+                    p::kv("Amount Out", amount);
+                }
+                return Ok(());
+            }
+            "error" | "failed" => {
+                let msg = json["transaction"]["message"]
+                    .as_str()
+                    .unwrap_or("Unknown error");
+                anyhow::bail!("Deposit failed: {}", msg);
+            }
+            _ => {
+                p::info(&format!("[{}/24] Status: {} — waiting...", attempt, status));
+            }
+        }
+    }
+    p::warn("Timed out waiting for deposit completion. Check the anchor's website for the deposit status.");
+    Ok(())
+}
diff --git a/src/commands/state.rs b/src/commands/state.rs
new file mode 100644
index 00000000..da7f6bca
--- /dev/null
+++ b/src/commands/state.rs
@@ -0,0 +1,427 @@
+use crate::utils::print as p;
+use crate::utils::{config, soroban, state_migration as sm};
+use anyhow::Result;
+use clap::Subcommand;
+use std::path::PathBuf;
+
+#[derive(Subcommand)]
+pub enum StateCommands {
+    /// Capture a contract's current state into a versioned snapshot
+    Snapshot(SnapshotArgs),
+    /// List stored state snapshots
+    List(ListArgs),
+    /// Diff two snapshots (added/removed/modified keys)
+    Diff(DiffArgs),
+    /// Generate a migration plan + soroban_sdk script between two snapshots
+    Migrate(MigrateArgs),
+    /// Validate a state transition against a safety policy
+    Validate(ValidateArgs),
+    /// Test a migration plan offline against an expected snapshot
+    Test(TestArgs),
+    /// Generate rollback operations to restore a previous snapshot
+    Rollback(RollbackArgs),
+}
+
+#[derive(clap::Args)]
+pub struct SnapshotArgs {
+    /// Contract ID to snapshot (starts with C)
+    #[arg(long)]
+    pub contract: String,
+    /// Network (testnet/mainnet)
+    #[arg(long, default_value = "testnet")]
+    pub network: String,
+    /// Human-friendly label (e.g. v1, pre-upgrade)
+    #[arg(long)]
+    pub label: Option<String>,
+    /// Load state from a JSON file instead of querying RPC (offline)
+    #[arg(long)]
+    pub from_file: Option<PathBuf>,
+}
+
+#[derive(clap::Args)]
+pub struct ListArgs {
+    /// Only show snapshots for this contract
+    #[arg(long)]
+    pub contract: Option<String>,
+}
+
+#[derive(clap::Args)]
+pub struct DiffArgs {
+    /// Source snapshot reference (id, label, or 'latest')
+    pub from: String,
+    /// Target snapshot reference (id, label, or 'latest')
+    pub to: String,
+    /// Restrict snapshot resolution to this contract
+    #[arg(long)]
+    pub contract: Option<String>,
+    /// Emit JSON instead of formatted output
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[derive(clap::Args)]
+pub struct MigrateArgs {
+    pub from: String,
+    pub to: String,
+    #[arg(long)]
+    pub contract: Option<String>,
+    /// Write the generated migration script to this path
+    #[arg(long)]
+    pub out: Option<PathBuf>,
+    /// Also write the machine-readable migration plan (JSON) here
+    #[arg(long)]
+    pub plan_out: Option<PathBuf>,
+}
+
+#[derive(clap::Args)]
+pub struct ValidateArgs {
+    pub from: String,
+    pub to: String,
+    #[arg(long)]
+    pub contract: Option<String>,
+    /// Permit removal of persistent keys (otherwise a critical finding)
+    #[arg(long)]
+    pub allow_persistent_removal: bool,
+    /// Maximum number of changed entries before flagging scale
+    #[arg(long, default_value = "100")]
+    pub max_changes: usize,
+}
+
+#[derive(clap::Args)]
+pub struct TestArgs {
+    /// Base snapshot reference to apply the migration to
+    #[arg(long)]
+    pub base: String,
+    /// Expected resulting snapshot reference
+    #[arg(long)]
+    pub expected: String,
+    /// Migration plan JSON file (as produced by `state migrate --plan-out`)
+    #[arg(long)]
+    pub plan: PathBuf,
+    #[arg(long)]
+    pub contract: Option<String>,
+}
+
+#[derive(clap::Args)]
+pub struct RollbackArgs {
+    /// Current snapshot reference
+    pub current: String,
+    /// Target snapshot reference to roll back to
+    pub target: String,
+    #[arg(long)]
+    pub contract: Option<String>,
+    /// Write the rollback migration script to this path
+    #[arg(long)]
+    pub out: Option<PathBuf>,
+}
+
+pub async fn handle(cmd: StateCommands) -> Result<()> {
+    match cmd {
+        StateCommands::Snapshot(args) => handle_snapshot(args).await,
+        StateCommands::List(args) => handle_list(args),
+        StateCommands::Diff(args) => handle_diff(args),
+        StateCommands::Migrate(args) => handle_migrate(args),
+        StateCommands::Validate(args) => handle_validate(args),
+        StateCommands::Test(args) => handle_test(args),
+        StateCommands::Rollback(args) => handle_rollback(args),
+    }
+}
+
+async fn handle_snapshot(args: SnapshotArgs) -> Result<()> {
+    config::validate_contract_id(&args.contract)?;
+    p::header("Contract State Snapshot");
+
+    let snapshot = if let Some(path) = &args.from_file {
+        p::kv("Source", &format!("file: {}", path.display()));
+        // Accept either a StateSnapshot or a raw soroban inspection result.
+        load_snapshot_or_inspect(path, &args.contract, &args.network, args.label.clone())?
+    } else {
+        p::kv("Source", &format!("RPC ({})", args.network));
+        config::validate_network(&args.network)?;
+        let inspect = soroban::inspect_contract(&args.contract, &args.network).await?;
+        sm::StateSnapshot::from_inspect(&inspect, &args.network, args.label.clone())
+    };
+
+    let path = sm::save_snapshot(&snapshot)?;
+    p::separator();
+    p::kv_accent("Snapshot ID", &snapshot.id);
+    p::kv("Contract", &snapshot.contract_id);
+    if let Some(label) = &snapshot.label {
+        p::kv("Label", label);
+    }
+    p::kv("Ledger", &snapshot.ledger_seq.to_string());
+    p::kv("Entries", &snapshot.entries.len().to_string());
+    p::kv("State hash", &snapshot.state_hash);
+    p::kv("Saved to", &path.display().to_string());
+    p::separator();
+    p::success("State snapshot captured");
+    Ok(())
+}
+
+fn load_snapshot_or_inspect(
+    path: &std::path::Path,
+    contract: &str,
+    network: &str,
+    label: Option<String>,
+) -> Result<sm::StateSnapshot> {
+    // First try a full StateSnapshot, then fall back to an inspection result.
+    if let Ok(snap) = sm::load_snapshot_file(path) {
+        return Ok(snap);
+    }
+    let contents = std::fs::read_to_string(path)?;
+    let inspect: soroban::ContractInspectResult = serde_json::from_str(&contents).map_err(|e| {
+        anyhow::anyhow!("File is neither a snapshot nor an inspection result: {}", e)
+    })?;
+    let _ = contract;
+    Ok(sm::StateSnapshot::from_inspect(&inspect, network, label))
+}
+
+fn handle_list(args: ListArgs) -> Result<()> {
+    p::header("State Snapshots");
+    let snapshots = sm::list_snapshots()?;
+    let filtered: Vec<_> = snapshots
+        .into_iter()
+        .filter(|s| {
+            args.contract
+                .as_deref()
+                .map(|c| s.contract_id == c)
+                .unwrap_or(true)
+        })
+        .collect();
+
+    if filtered.is_empty() {
+        p::info("No snapshots found. Capture one with: starforge state snapshot --contract <id>");
+        return Ok(());
+    }
+
+    let rows: Vec<Vec<String>> = filtered
+        .iter()
+        .map(|s| {
+            vec![
+                s.id.chars().take(8).collect::<String>(),
+                s.label.clone().unwrap_or_else(|| "-".to_string()),
+                truncate(&s.contract_id, 12),
+                s.network.clone(),
+                s.ledger_seq.to_string(),
+                s.entries.len().to_string(),
+                s.timestamp.chars().take(19).collect::<String>(),
+            ]
+        })
+        .collect();
+    p::table(
+        &[
+            "ID", "Label", "Contract", "Network", "Ledger", "Keys", "Captured",
+        ],
+        &rows,
+    );
+    Ok(())
+}
+
+fn handle_diff(args: DiffArgs) -> Result<()> {
+    let from = sm::resolve_snapshot(&args.from, args.contract.as_deref())?;
+    let to = sm::resolve_snapshot(&args.to, args.contract.as_deref())?;
+    let diff = sm::diff_snapshots(&from, &to);
+
+    if args.json {
+        println!("{}", serde_json::to_string_pretty(&diff)?);
+        return Ok(());
+    }
+
+    p::header("State Diff");
+    p::kv(
+        "From",
+        &format!(
+            "{} ({})",
+            short(&from.id),
+            from.label.clone().unwrap_or_default()
+        ),
+    );
+    p::kv(
+        "To",
+        &format!(
+            "{} ({})",
+            short(&to.id),
+            to.label.clone().unwrap_or_default()
+        ),
+    );
+    p::separator();
+    p::kv_accent("Added", &diff.added.to_string());
+    p::kv_accent("Removed", &diff.removed.to_string());
+    p::kv_accent("Modified", &diff.modified.to_string());
+    p::kv("Unchanged", &diff.unchanged.to_string());
+    p::separator();
+
+    if diff.is_identical() {
+        p::success("States are identical");
+        return Ok(());
+    }
+
+    for e in diff
+        .entries
+        .iter()
+        .filter(|e| e.kind != sm::ChangeKind::Unchanged)
+    {
+        let line = match e.kind {
+            sm::ChangeKind::Added => {
+                format!("  + [{}] {} = {}", e.durability, e.key, val(&e.new_value))
+            }
+            sm::ChangeKind::Removed => format!(
+                "  - [{}] {} (was {})",
+                e.durability,
+                e.key,
+                val(&e.old_value)
+            ),
+            sm::ChangeKind::Modified => format!(
+                "  ~ [{}] {}: {} -> {}",
+                e.durability,
+                e.key,
+                val(&e.old_value),
+                val(&e.new_value)
+            ),
+            sm::ChangeKind::Unchanged => continue,
+        };
+        println!("{}", line);
+    }
+    Ok(())
+}
+
+fn handle_migrate(args: MigrateArgs) -> Result<()> {
+    let from = sm::resolve_snapshot(&args.from, args.contract.as_deref())?;
+    let to = sm::resolve_snapshot(&args.to, args.contract.as_deref())?;
+    let diff = sm::diff_snapshots(&from, &to);
+    let plan = sm::generate_migration_plan(&diff);
+    let script = sm::generate_migration_script(&plan);
+
+    p::header("Migration Generation");
+    p::kv("Contract", &plan.contract_id);
+    p::kv("Operations", &plan.operations.len().to_string());
+    p::separator();
+
+    if let Some(out) = &args.out {
+        std::fs::write(out, &script)?;
+        p::success(&format!("Migration script written to {}", out.display()));
+    } else {
+        println!("{}", script);
+    }
+
+    if let Some(plan_out) = &args.plan_out {
+        std::fs::write(plan_out, serde_json::to_string_pretty(&plan)?)?;
+        p::success(&format!("Migration plan written to {}", plan_out.display()));
+    }
+    Ok(())
+}
+
+fn handle_validate(args: ValidateArgs) -> Result<()> {
+    let from = sm::resolve_snapshot(&args.from, args.contract.as_deref())?;
+    let to = sm::resolve_snapshot(&args.to, args.contract.as_deref())?;
+    let diff = sm::diff_snapshots(&from, &to);
+    let policy = sm::MigrationPolicy {
+        allow_persistent_removal: args.allow_persistent_removal,
+        allow_instance_removal: true,
+        max_changes: args.max_changes,
+    };
+    let findings = sm::validate_transition(&diff, &policy);
+
+    p::header("State Transition Validation");
+    p::separator();
+    for f in &findings {
+        let line = format!("[{}] {}: {}", f.severity.label(), f.category, f.message);
+        match f.severity {
+            sm::Severity::Critical => p::error(&line),
+            sm::Severity::Warning => p::warn(&line),
+            sm::Severity::Info => p::info(&line),
+        }
+    }
+    p::separator();
+
+    if sm::has_blocking_findings(&findings) {
+        anyhow::bail!("State transition is unsafe; resolve critical findings or pass --allow-persistent-removal");
+    }
+    p::success("State transition validated");
+    Ok(())
+}
+
+fn handle_test(args: TestArgs) -> Result<()> {
+    let base = sm::resolve_snapshot(&args.base, args.contract.as_deref())?;
+    let expected = sm::resolve_snapshot(&args.expected, args.contract.as_deref())?;
+    let plan_json = std::fs::read_to_string(&args.plan)?;
+    let plan: sm::MigrationPlan = serde_json::from_str(&plan_json)
+        .map_err(|e| anyhow::anyhow!("Failed to parse migration plan: {}", e))?;
+
+    let result = sm::test_migration(&base, &plan.operations, &expected);
+
+    p::header("Migration Test");
+    p::kv("Base", &short(&base.id));
+    p::kv("Expected", &short(&expected.id));
+    p::kv("Operations", &plan.operations.len().to_string());
+    p::kv("Expected hash", &result.expected_hash);
+    p::kv("Actual hash", &result.actual_hash);
+    p::separator();
+
+    if result.passed {
+        p::success("Migration produces the expected state");
+        return Ok(());
+    }
+
+    p::warn(&format!(
+        "{} mismatching entr(ies):",
+        result.mismatches.len()
+    ));
+    for m in &result.mismatches {
+        println!(
+            "  {} [{}] {} (expected {}, got {})",
+            m.kind.symbol(),
+            m.durability,
+            m.key,
+            val(&m.old_value),
+            val(&m.new_value)
+        );
+    }
+    anyhow::bail!("Migration test failed");
+}
+
+fn handle_rollback(args: RollbackArgs) -> Result<()> {
+    let current = sm::resolve_snapshot(&args.current, args.contract.as_deref())?;
+    let target = sm::resolve_snapshot(&args.target, args.contract.as_deref())?;
+    let ops = sm::rollback_operations(&current, &target);
+
+    // The rollback is itself a migration from current -> target.
+    let reverse_diff = sm::diff_snapshots(&current, &target);
+    let plan = sm::generate_migration_plan(&reverse_diff);
+    let script = sm::generate_migration_script(&plan);
+
+    p::header("State Rollback Plan");
+    p::kv("From (current)", &short(&current.id));
+    p::kv("To (target)", &short(&target.id));
+    p::kv("Rollback operations", &ops.len().to_string());
+    p::separator();
+
+    if let Some(out) = &args.out {
+        std::fs::write(out, &script)?;
+        p::success(&format!("Rollback script written to {}", out.display()));
+    } else {
+        println!("{}", script);
+    }
+    p::info("Apply the generated migrate() function to revert the contract's state.");
+    Ok(())
+}
+
+// --- small display helpers ---
+
+fn val(v: &Option<String>) -> String {
+    v.clone()
+        .map(|s| truncate(&s, 40))
+        .unwrap_or_else(|| "∅".to_string())
+}
+
+fn short(id: &str) -> String {
+    id.chars().take(8).collect()
+}
+
+fn truncate(s: &str, max: usize) -> String {
+    if s.len() > max {
+        format!("{}…", &s[..max])
+    } else {
+        s.to_string()
+    }
+}
diff --git a/src/commands/test.rs b/src/commands/test.rs
index 6acb21d2..348f2f44 100644
--- a/src/commands/test.rs
+++ b/src/commands/test.rs
@@ -33,6 +33,14 @@ pub struct TestArgs {
     #[arg(long)]
     pub report: Option<String>,
 
+    /// Regenerate all stored snapshots instead of comparing against them
+    #[arg(long)]
+    pub update_snapshots: bool,
+
+    /// Fuzz the named contract function with random ScVal inputs
+    #[arg(long, value_name = "FUNCTION_NAME")]
+    pub fuzz: Option<String>,
+
     /// Path to contract source directory for test generation
     #[arg(long)]
     pub contract_path: Option<PathBuf>,
@@ -55,11 +63,12 @@ pub async fn handle(args: TestArgs) -> Result<()> {
     if let Some(r) = &args.report {
         p::kv("Report", r);
     }
-    p::kv("Generate tests", if args.generate { "yes" } else { "no" });
-    p::kv(
-        "Parallel execution",
-        if args.parallel { "yes" } else { "no" },
-    );
+    if args.update_snapshots {
+        p::kv("Snapshots", "update mode");
+    }
+    if let Some(fn_name) = &args.fuzz {
+        p::kv("Fuzz target", fn_name);
+    }
     if args.parallel {
         p::kv("Workers", &args.workers.to_string());
     }
@@ -158,6 +167,8 @@ pub async fn handle(args: TestArgs) -> Result<()> {
         test_runner::TestOptions {
             coverage: args.coverage,
             report_format: args.report.clone(),
+            update_snapshots: args.update_snapshots,
+            fuzz_function: args.fuzz.clone(),
             parallel: args.parallel,
             generate: args.generate,
             source: args.source.clone(),
@@ -171,6 +182,10 @@ pub async fn handle(args: TestArgs) -> Result<()> {
     p::kv("Wasm bytes", &result.size_bytes.to_string());
     p::kv("Cases executed", &result.cases_executed.to_string());
     p::kv("Failures", &result.failures.to_string());
+    p::kv(
+        "Snapshot",
+        &format!("{:?}", result.snapshot_status).to_lowercase(),
+    );
     p::kv("Generated cases", &result.generated_cases.len().to_string());
 
     if let Some(cov) = &result.coverage {
diff --git a/src/commands/tx.rs b/src/commands/tx.rs
index 93312cba..4d3f4baa 100644
--- a/src/commands/tx.rs
+++ b/src/commands/tx.rs
@@ -160,8 +160,9 @@ async fn handle_batch(args: BatchArgs) -> Result<()> {
 
     println!();
     p::step(1, 2, "Fetching source account info…");
-    let source_account =
-        horizon::fetch_account(&wallet.public_key, &args.network).await.map_err(|e| {
+    let source_account = horizon::fetch_account(&wallet.public_key, &args.network)
+        .await
+        .map_err(|e| {
             anyhow::anyhow!(
                 "Source account not found on {}: {}\nFund it with: starforge wallet fund {}",
                 args.network,
@@ -249,11 +250,9 @@ async fn handle_batch(args: BatchArgs) -> Result<()> {
     }
 
     p::info("Submitting batch transaction…");
-    let submit_result = horizon::submit_payment_transaction(
-        &tx_result.transaction_xdr,
-        &secret_key,
-        &args.network,
-    ).await?;
+    let submit_result =
+        horizon::submit_payment_transaction(&tx_result.transaction_xdr, &secret_key, &args.network)
+            .await?;
 
     println!();
     p::separator();
@@ -342,8 +341,9 @@ async fn handle_send(args: SendArgs) -> Result<()> {
     // Step 1: Fetch source account info
     println!();
     p::step(1, 3, "Fetching source account info…");
-    let source_account =
-        horizon::fetch_account(&wallet.public_key, &args.network).await.map_err(|e| {
+    let source_account = horizon::fetch_account(&wallet.public_key, &args.network)
+        .await
+        .map_err(|e| {
             anyhow::anyhow!(
                 "Source account not found on {}: {}\nFund it with: starforge wallet fund {}",
                 args.network,
@@ -463,11 +463,9 @@ async fn handle_send(args: SendArgs) -> Result<()> {
     }
 
     p::info("Submitting transaction…");
-    let submit_result = horizon::submit_payment_transaction(
-        &tx_result.transaction_xdr,
-        &secret_key,
-        &args.network,
-    ).await?;
+    let submit_result =
+        horizon::submit_payment_transaction(&tx_result.transaction_xdr, &secret_key, &args.network)
+            .await?;
 
     println!();
     p::separator();
diff --git a/src/commands/upgrade.rs b/src/commands/upgrade.rs
index 82eb0da9..dbeb15ac 100644
--- a/src/commands/upgrade.rs
+++ b/src/commands/upgrade.rs
@@ -298,7 +298,8 @@ async fn handle_prepare(args: PrepareArgs) -> Result<()> {
     let wallet = cfg.wallets.first().ok_or_else(|| {
         anyhow::anyhow!("No wallets found. Create one with `starforge wallet create`")
     })?;
-    horizon::fetch_account(&wallet.public_key, &args.network).await
+    horizon::fetch_account(&wallet.public_key, &args.network)
+        .await
         .map_err(|e| anyhow::anyhow!("Account not active on {}: {}", args.network, e))?;
 
     p::step(3, 3, "Generating upgrade command…");
@@ -591,7 +592,8 @@ async fn handle_execute(args: ExecuteArgs) -> Result<()> {
 
     println!();
     p::step(1, 2, "Verifying account on-chain…");
-    horizon::fetch_account(&wallet.public_key, &args.network).await
+    horizon::fetch_account(&wallet.public_key, &args.network)
+        .await
         .map_err(|e| anyhow::anyhow!("Account not active on {}: {}", args.network, e))?;
 
     p::step(2, 2, "Generating upgrade command…");
diff --git a/src/commands/wallet.rs b/src/commands/wallet.rs
index c97510f3..cd588226 100644
--- a/src/commands/wallet.rs
+++ b/src/commands/wallet.rs
@@ -331,19 +331,22 @@ pub async fn handle(cmd: WalletCommands) -> Result<()> {
             mem,
             iterations,
             parallelism,
-        } => create(
-            name,
-            fund,
-            network,
-            encrypt,
-            strict,
-            use_mnemonic,
-            words,
-            account_index,
-            mem,
-            iterations,
-            parallelism,
-        ).await,
+        } => {
+            create(
+                name,
+                fund,
+                network,
+                encrypt,
+                strict,
+                use_mnemonic,
+                words,
+                account_index,
+                mem,
+                iterations,
+                parallelism,
+            )
+            .await
+        }
         WalletCommands::List => list(),
         WalletCommands::Show { name, reveal } => show(name, reveal).await,
         WalletCommands::Fund { name } => fund_wallet(name).await,
@@ -366,17 +369,20 @@ pub async fn handle(cmd: WalletCommands) -> Result<()> {
             iterations,
             parallelism,
             backup,
-        } => rotate_wallet(
-            name,
-            fund,
-            network,
-            encrypt,
-            strict,
-            mem,
-            iterations,
-            parallelism,
-            backup,
-        ).await,
+        } => {
+            rotate_wallet(
+                name,
+                fund,
+                network,
+                encrypt,
+                strict,
+                mem,
+                iterations,
+                parallelism,
+                backup,
+            )
+            .await
+        }
         WalletCommands::Export {
             name,
             all,
@@ -934,13 +940,15 @@ async fn merge_wallet(
     p::separator();
     println!();
     p::step(1, 3, "Fetching source account…");
-    let source_account = horizon::fetch_account(&wallet.public_key, &network).await.map_err(|e| {
-        anyhow::anyhow!(
-            "Source account not found on {}: {}\nIt may already be merged or never funded.",
-            network,
-            e
-        )
-    })?;
+    let source_account = horizon::fetch_account(&wallet.public_key, &network)
+        .await
+        .map_err(|e| {
+            anyhow::anyhow!(
+                "Source account not found on {}: {}\nIt may already be merged or never funded.",
+                network,
+                e
+            )
+        })?;
 
     validate_account_mergeable(&source_account)?;
     let xlm_balance = native_xlm_balance(&source_account);
@@ -954,13 +962,15 @@ async fn merge_wallet(
     }
 
     p::step(2, 3, "Validating destination account…");
-    horizon::fetch_account(&destination, &network).await.map_err(|_| {
-        anyhow::anyhow!(
-            "Destination account does not exist on {}. \
+    horizon::fetch_account(&destination, &network)
+        .await
+        .map_err(|_| {
+            anyhow::anyhow!(
+                "Destination account does not exist on {}. \
              The destination must be funded before it can receive a merge.",
-            network
-        )
-    })?;
+                network
+            )
+        })?;
     p::kv("Destination", "✓ Account exists");
 
     p::step(3, 3, "Building account merge transaction…");
@@ -1021,7 +1031,8 @@ async fn merge_wallet(
     let secret_key = wallet_secret_key(wallet)?;
     p::info("Submitting account merge…");
     let submit_result =
-        horizon::submit_payment_transaction(&tx_result.transaction_xdr, &secret_key, &network).await?;
+        horizon::submit_payment_transaction(&tx_result.transaction_xdr, &secret_key, &network)
+            .await?;
 
     println!();
     p::separator();
@@ -2022,7 +2033,11 @@ fn multisig_show(name: String) -> Result<()> {
     Ok(())
 }
 
-async fn multisig_submit(name: String, transaction: PathBuf, network: Option<String>) -> Result<()> {
+async fn multisig_submit(
+    name: String,
+    transaction: PathBuf,
+    network: Option<String>,
+) -> Result<()> {
     config::validate_wallet_name(&name)?;
     config::validate_file_path(&transaction, Some("json"))?;
 
diff --git a/src/main.rs b/src/main.rs
index bfff1750..f8872171 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -78,8 +78,7 @@ enum Commands {
     #[command(subcommand)]
     Node(commands::node::NodeCommands),
     /// Generate shell completions for bash, zsh, and fish
-    #[command(subcommand)]
-    Completions(commands::completions::CompletionShell),
+    Completions(commands::completions::CompletionArgs),
 
     /// Interactive REPL for local Soroban contract testing
     Shell(commands::shell::ShellArgs),
@@ -150,6 +149,22 @@ enum Commands {
     #[command(subcommand)]
     Analytics(commands::analytics::AnalyticsCommands),
 
+    /// Contract state snapshots, diffing, and migration tooling
+    #[command(subcommand)]
+    State(commands::state::StateCommands),
+
+    /// Contract fuzzing, property-based testing, and mutation testing
+    #[command(subcommand)]
+    Fuzz(commands::fuzz::FuzzCommands),
+
+    /// Real-time contract event streaming, routing, alerting, and analytics
+    #[command(subcommand)]
+    Events(commands::events::EventsCommands),
+
+    /// Deployment monitoring service (health, failure detection, alerting)
+    #[command(subcommand)]
+    DeployMonitor(commands::deploy_monitor::DeployMonitorCommands),
+
     /// Execute an installed plugin command (e.g. `starforge defi ...`)
     #[command(external_subcommand)]
     External(Vec<String>),
@@ -203,6 +218,10 @@ async fn main() {
         Commands::Perf(_) => "perf",
         Commands::Docs(_) => "docs",
         Commands::Analytics(_) => "analytics",
+        Commands::State(_) => "state",
+        Commands::Fuzz(_) => "fuzz",
+        Commands::Events(_) => "events",
+        Commands::DeployMonitor(_) => "deploy-monitor",
         Commands::External(_) => "external",
     }
     .to_string();
@@ -241,6 +260,10 @@ async fn main() {
         Commands::Perf(cmd) => commands::perf::handle(cmd).await,
         Commands::Docs(cmd) => commands::docs::handle(cmd).await,
         Commands::Analytics(cmd) => commands::analytics::handle(cmd).await,
+        Commands::State(cmd) => commands::state::handle(cmd).await,
+        Commands::Fuzz(cmd) => commands::fuzz::handle(cmd),
+        Commands::Events(cmd) => commands::events::handle(cmd),
+        Commands::DeployMonitor(cmd) => commands::deploy_monitor::handle(cmd).await,
         Commands::External(args) => handle_external_plugin(args),
     };
     let duration = start.elapsed();
@@ -270,7 +293,6 @@ fn handle_external_plugin(args: Vec<String>) -> anyhow::Result<()> {
     let plugin_name = &args[0];
     let plugin_args = &args[1..];
 
-    let cfg = starforge::utils::config::load()?;
     let reg = plugins::registry::load_registry().unwrap_or_default();
     if reg.plugins.is_empty() {
         anyhow::bail!(
diff --git a/src/plugins/registry.rs b/src/plugins/registry.rs
index 7590c9c4..03e47eba 100644
--- a/src/plugins/registry.rs
+++ b/src/plugins/registry.rs
@@ -1,5 +1,5 @@
 use crate::plugins::manifest;
-use crate::utils::config::{self, Config};
+use crate::utils::config::Config;
 use anyhow::{Context, Result};
 use serde::{Deserialize, Serialize};
 use std::fs;
@@ -395,6 +395,24 @@ pub fn load_all_registered_commands() -> Vec<RegisteredCommand> {
         .collect()
 }
 
+/// Return installed plugin command names in deterministic, machine-readable order.
+pub fn load_registered_command_names() -> Vec<String> {
+    let mut names: Vec<String> = load_all_registered_commands()
+        .into_iter()
+        .filter_map(|cmd| {
+            let name = cmd.name.trim();
+            if name.is_empty() {
+                None
+            } else {
+                Some(name.to_string())
+            }
+        })
+        .collect();
+    names.sort();
+    names.dedup();
+    names
+}
+
 /// Remove a plugin from the registry and optionally delete its library file.
 pub fn uninstall_plugin(name: &str, opts: &UninstallOptions) -> Result<UninstallReport> {
     let mut reg = load_registry().unwrap_or_default();
diff --git a/src/utils/audit.rs b/src/utils/audit.rs
index 37e2f71d..07794031 100644
--- a/src/utils/audit.rs
+++ b/src/utils/audit.rs
@@ -1,8 +1,8 @@
 use anyhow::Result;
+use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use std::fs;
 use std::path::PathBuf;
-use chrono::{DateTime, Utc};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AuditEntry {
@@ -171,7 +171,8 @@ pub fn get_audit_report(start_time: Option<&str>, end_time: Option<&str>) -> Res
 }
 
 pub fn export_audit_log_csv(entries: &[AuditEntry]) -> String {
-    let mut csv = String::from("id,action,actor,resource_type,resource_id,timestamp,success,error_message\n");
+    let mut csv =
+        String::from("id,action,actor,resource_type,resource_id,timestamp,success,error_message\n");
     for entry in entries {
         csv.push_str(&format!(
             "{},{},{},{},{},{},{},{}\n",
@@ -204,7 +205,8 @@ pub fn check_compliance_violations() -> Result<Vec<String>> {
         if !entry.success {
             violations.push(format!(
                 "Failed deployment by {} on contract {}: {}",
-                entry.actor, entry.resource_id,
+                entry.actor,
+                entry.resource_id,
                 entry.error_message.as_deref().unwrap_or("unknown error")
             ));
         }
diff --git a/src/utils/config/migrations.rs b/src/utils/config/migrations.rs
new file mode 100644
index 00000000..1e2672c3
--- /dev/null
+++ b/src/utils/config/migrations.rs
@@ -0,0 +1,355 @@
+//! Versioned configuration migrations.
+//!
+//! StarForge config files carry a `version` field. Instead of relying on
+//! `#[serde(default)]` to silently paper over schema drift — which can *drop
+//! wallet entries* when a field is renamed or restructured — we deserialize the
+//! on-disk file into a schema-agnostic [`serde_json::Value`] first, read its
+//! version, and apply a sequence of pure migration functions that reshape the
+//! value before it is finally deserialized into the current [`Config`].
+//!
+//! ## Adding a new schema version
+//!
+//! 1. Bump [`CURRENT_CONFIG_VERSION`](super::CURRENT_CONFIG_VERSION) and
+//!    [`default_version`](super::default_version).
+//! 2. Write a `migrate_vN_to_vN1(&mut serde_json::Value)` pure function below.
+//! 3. Register it in [`MIGRATIONS`].
+//! 4. Add a `tests/fixtures/config_vN.toml` fixture and an integration test that
+//!    loads it, runs migrations, and asserts the resulting [`Config`].
+//!
+//! Each migration is a *pure* `fn(&mut serde_json::Value)`: it must not touch the
+//! file system, network, or any global state. Backups and disk writes are handled
+//! by the caller (`config::load` / `config::apply_migration`).
+//!
+//! [`Config`]: super::Config
+
+use anyhow::{anyhow, Result};
+use serde_json::{Map, Value};
+
+/// A single forward migration step from schema `from` to schema `to`.
+pub struct Migration {
+    /// Version the migration upgrades *from*.
+    pub from: u32,
+    /// Version the migration upgrades *to*.
+    pub to: u32,
+    /// Pure transformation applied to the config value.
+    pub apply: fn(&mut Value),
+}
+
+/// Ordered registry of every migration StarForge knows about.
+///
+/// Migrations are applied sequentially: `v1 -> v2 -> v3 -> ...` until the value
+/// reaches the current schema version.
+pub const MIGRATIONS: &[Migration] = &[Migration {
+    from: 1,
+    to: 2,
+    apply: migrate_v1_to_v2,
+}];
+
+/// Reads the schema version from a config value.
+///
+/// Missing, empty, `"0"`, or unparseable versions are treated as version `1`
+/// (the first versioned schema), so legacy files migrate forward cleanly rather
+/// than erroring out.
+pub fn read_version(value: &Value) -> u32 {
+    let raw = match value.get("version") {
+        Some(Value::String(s)) => s.trim().parse::<u32>().ok(),
+        Some(Value::Number(n)) => n.as_u64().map(|n| n as u32),
+        _ => None,
+    };
+    raw.filter(|v| *v >= 1).unwrap_or(1)
+}
+
+/// Overwrites the `version` field with `version` (as a string, matching the
+/// TOML/serde representation used by [`Config`](super::Config)).
+fn set_version(value: &mut Value, version: u32) {
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("version".to_string(), Value::String(version.to_string()));
+    }
+}
+
+/// Applies every migration required to bring `value` up to `target`.
+///
+/// Returns the ordered list of `(from, to)` steps actually applied. This function
+/// is pure with respect to the file system — it only mutates `value`.
+///
+/// Errors if there is no registered migration path from the current version
+/// (for example a config written by a *newer* CLI than the one running).
+pub fn migrate_value(value: &mut Value, target: u32) -> Result<Vec<(u32, u32)>> {
+    let mut applied = Vec::new();
+
+    loop {
+        let current = read_version(value);
+        if current >= target {
+            break;
+        }
+
+        let migration = MIGRATIONS
+            .iter()
+            .find(|m| m.from == current)
+            .ok_or_else(|| {
+                anyhow!(
+                    "No migration path from config version {} (target version {}). \
+                 This config may have been written by a newer StarForge release.",
+                    current,
+                    target
+                )
+            })?;
+
+        (migration.apply)(value);
+        // Defensively ensure the version was bumped even if the migration forgot.
+        set_version(value, migration.to);
+        applied.push((migration.from, migration.to));
+    }
+
+    Ok(applied)
+}
+
+// ── Migrations ────────────────────────────────────────────────────────────────
+
+/// Migrate a v1 config to v2.
+///
+/// v2 normalises three pieces of legacy shape that earlier StarForge builds wrote
+/// in inconsistent ways. Every transformation is conservative: it only fills a
+/// canonical field when that field is *absent*, so we never clobber data and — the
+/// whole point of this system — never silently drop wallet secrets.
+///
+/// 1. **Per-wallet `secret` → `secret_key`.** Some early builds stored the wallet
+///    secret under `secret`. Plain `#[serde(default)]` deserialization would have
+///    dropped it, making wallets unusable after an upgrade. We rename it.
+/// 2. **Flat KDF keys → nested `wallet_encryption`.** Legacy top-level
+///    `kdf_mem` / `kdf_iterations` / `kdf_parallelism` are folded into the
+///    structured `[wallet_encryption]` table.
+/// 3. **`telemetry` → `telemetry_enabled`.** Renamed boolean flag.
+pub fn migrate_v1_to_v2(value: &mut Value) {
+    let Some(obj) = value.as_object_mut() else {
+        return;
+    };
+
+    // 1. Rename legacy per-wallet `secret` to `secret_key`.
+    if let Some(Value::Array(wallets)) = obj.get_mut("wallets") {
+        for wallet in wallets.iter_mut() {
+            if let Some(w) = wallet.as_object_mut() {
+                if !w.contains_key("secret_key") {
+                    if let Some(secret) = w.remove("secret") {
+                        w.insert("secret_key".to_string(), secret);
+                    }
+                }
+            }
+        }
+    }
+
+    // 2. Restructure flat KDF keys into the nested `wallet_encryption` table.
+    let legacy_mem = obj.remove("kdf_mem");
+    let legacy_iterations = obj.remove("kdf_iterations");
+    let legacy_parallelism = obj.remove("kdf_parallelism");
+    let has_legacy_kdf =
+        legacy_mem.is_some() || legacy_iterations.is_some() || legacy_parallelism.is_some();
+    if has_legacy_kdf && !obj.contains_key("wallet_encryption") {
+        let mut kdf = Map::new();
+        if let Some(v) = legacy_mem {
+            kdf.insert("mem".to_string(), v);
+        }
+        if let Some(v) = legacy_iterations {
+            kdf.insert("iterations".to_string(), v);
+        }
+        if let Some(v) = legacy_parallelism {
+            kdf.insert("parallelism".to_string(), v);
+        }
+        obj.insert("wallet_encryption".to_string(), Value::Object(kdf));
+    }
+
+    // 3. Rename `telemetry` to `telemetry_enabled`.
+    if !obj.contains_key("telemetry_enabled") {
+        if let Some(t) = obj.remove("telemetry") {
+            obj.insert("telemetry_enabled".to_string(), t);
+        }
+    }
+
+    // 4. Stamp the new schema version.
+    obj.insert("version".to_string(), Value::String("2".to_string()));
+}
+
+// ── Diffing (for `config migrate --dry-run`) ────────────────────────────────────
+
+/// A single human-readable change produced by a migration, used to render the
+/// `--dry-run` preview.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Change {
+    /// A new key/value was introduced.
+    Added { path: String, value: String },
+    /// A key/value was removed.
+    Removed { path: String, value: String },
+    /// A value changed in place.
+    Changed {
+        path: String,
+        from: String,
+        to: String,
+    },
+}
+
+impl std::fmt::Display for Change {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Change::Added { path, value } => write!(f, "+ {path} = {value}"),
+            Change::Removed { path, value } => write!(f, "- {path} = {value}"),
+            Change::Changed { path, from, to } => write!(f, "~ {path}: {from} -> {to}"),
+        }
+    }
+}
+
+/// Computes an ordered, human-readable diff between two config values.
+pub fn diff(old: &Value, new: &Value) -> Vec<Change> {
+    let mut changes = Vec::new();
+    diff_inner("", old, new, &mut changes);
+    changes
+}
+
+fn join(prefix: &str, key: &str) -> String {
+    if prefix.is_empty() {
+        key.to_string()
+    } else {
+        format!("{prefix}.{key}")
+    }
+}
+
+fn scalar(value: &Value) -> String {
+    match value {
+        Value::String(s) => format!("\"{s}\""),
+        other => other.to_string(),
+    }
+}
+
+fn diff_inner(prefix: &str, old: &Value, new: &Value, out: &mut Vec<Change>) {
+    match (old, new) {
+        (Value::Object(old_map), Value::Object(new_map)) => {
+            // Stable key order: union of keys, sorted.
+            let mut keys: Vec<&String> = old_map.keys().chain(new_map.keys()).collect();
+            keys.sort();
+            keys.dedup();
+            for key in keys {
+                let path = join(prefix, key);
+                match (old_map.get(key), new_map.get(key)) {
+                    (Some(o), Some(n)) => diff_inner(&path, o, n, out),
+                    (Some(o), None) => out.push(Change::Removed {
+                        path,
+                        value: scalar(o),
+                    }),
+                    (None, Some(n)) => out.push(Change::Added {
+                        path,
+                        value: scalar(n),
+                    }),
+                    (None, None) => {}
+                }
+            }
+        }
+        (o, n) if o == n => {}
+        (o, n) => out.push(Change::Changed {
+            path: if prefix.is_empty() {
+                "(root)".to_string()
+            } else {
+                prefix.to_string()
+            },
+            from: scalar(o),
+            to: scalar(n),
+        }),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn read_version_handles_missing_and_legacy() {
+        assert_eq!(read_version(&json!({})), 1);
+        assert_eq!(read_version(&json!({ "version": "" })), 1);
+        assert_eq!(read_version(&json!({ "version": "0" })), 1);
+        assert_eq!(read_version(&json!({ "version": "1" })), 1);
+        assert_eq!(read_version(&json!({ "version": "2" })), 2);
+        assert_eq!(read_version(&json!({ "version": 3 })), 3);
+    }
+
+    #[test]
+    fn v1_to_v2_renames_wallet_secret_field() {
+        let mut value = json!({
+            "version": "1",
+            "network": "testnet",
+            "wallets": [
+                { "name": "alice", "secret": "SAAA" },
+                { "name": "bob", "secret_key": "SBBB" },
+            ],
+        });
+        migrate_v1_to_v2(&mut value);
+        let wallets = value["wallets"].as_array().unwrap();
+        assert_eq!(wallets[0]["secret_key"], json!("SAAA"));
+        assert!(wallets[0].get("secret").is_none());
+        // Existing secret_key is never clobbered.
+        assert_eq!(wallets[1]["secret_key"], json!("SBBB"));
+        assert_eq!(value["version"], json!("2"));
+    }
+
+    #[test]
+    fn v1_to_v2_nests_flat_kdf_keys() {
+        let mut value = json!({
+            "version": "1",
+            "kdf_mem": 65536,
+            "kdf_iterations": 4,
+            "kdf_parallelism": 2,
+        });
+        migrate_v1_to_v2(&mut value);
+        assert!(value.get("kdf_mem").is_none());
+        assert_eq!(value["wallet_encryption"]["mem"], json!(65536));
+        assert_eq!(value["wallet_encryption"]["iterations"], json!(4));
+        assert_eq!(value["wallet_encryption"]["parallelism"], json!(2));
+    }
+
+    #[test]
+    fn v1_to_v2_renames_telemetry_flag() {
+        let mut value = json!({ "version": "1", "telemetry": false });
+        migrate_v1_to_v2(&mut value);
+        assert!(value.get("telemetry").is_none());
+        assert_eq!(value["telemetry_enabled"], json!(false));
+    }
+
+    #[test]
+    fn migrate_value_applies_sequence_and_reports_steps() {
+        let mut value = json!({ "version": "1", "network": "testnet", "wallets": [] });
+        let applied = migrate_value(&mut value, 2).unwrap();
+        assert_eq!(applied, vec![(1, 2)]);
+        assert_eq!(read_version(&value), 2);
+
+        // Idempotent: already-current value applies nothing.
+        let applied = migrate_value(&mut value, 2).unwrap();
+        assert!(applied.is_empty());
+    }
+
+    #[test]
+    fn migrate_value_rejects_future_versions() {
+        let mut value = json!({ "version": "99" });
+        // Target is 2 but value is already 99 -> nothing to do (no downgrade).
+        assert!(migrate_value(&mut value, 2).unwrap().is_empty());
+    }
+
+    #[test]
+    fn diff_reports_added_removed_and_changed() {
+        let old = json!({ "version": "1", "telemetry": true, "kdf_mem": 1 });
+        let new =
+            json!({ "version": "2", "telemetry_enabled": true, "wallet_encryption": { "mem": 1 } });
+        let changes = diff(&old, &new);
+        assert!(changes.contains(&Change::Changed {
+            path: "version".to_string(),
+            from: "\"1\"".to_string(),
+            to: "\"2\"".to_string(),
+        }));
+        assert!(changes
+            .iter()
+            .any(|c| matches!(c, Change::Removed { path, .. } if path == "telemetry")));
+        assert!(changes
+            .iter()
+            .any(|c| matches!(c, Change::Added { path, .. } if path == "telemetry_enabled")));
+        assert!(changes
+            .iter()
+            .any(|c| matches!(c, Change::Added { path, .. } if path == "wallet_encryption")));
+    }
+}
diff --git a/src/utils/config.rs b/src/utils/config/mod.rs
similarity index 82%
rename from src/utils/config.rs
rename to src/utils/config/mod.rs
index e9d9a571..ccf00863 100644
--- a/src/utils/config.rs
+++ b/src/utils/config/mod.rs
@@ -1,5 +1,7 @@
 #![allow(clippy::items_after_test_module)]
 
+pub mod migrations;
+
 use crate::utils::crypto;
 use anyhow::{Context, Result};
 use base64::{engine::general_purpose::STANDARD as BASE64, Engine};
@@ -114,10 +116,10 @@ pub fn validate_secret_key(secret: &str) -> Result<()> {
         }
 
         // Validate base64 parts (first 3 parts are always base64)
-        for part in parts.iter().take(3) {
-            BASE64
-                .decode(part)
-                .map_err(|_| anyhow::anyhow!("Invalid base64 in encrypted secret bundle"))?;
+        for (i, part) in parts.iter().enumerate().take(3) {
+            BASE64.decode(part).map_err(|_| {
+                anyhow::anyhow!("Invalid base64 in encrypted secret bundle at part {}", i)
+            })?;
         }
 
         // If 5 or 6-part bundle, validate KDF parameters are valid u32
@@ -261,8 +263,12 @@ pub struct Config {
     pub wallet_encryption: Option<crypto::KdfOptions>,
 }
 
-fn default_version() -> String {
-    "1".to_string()
+/// The current on-disk config schema version, as a string.
+///
+/// Bump this (and add a migration in [`migrations`]) whenever the [`Config`]
+/// shape changes in a way that would otherwise silently drop or mis-read data.
+pub fn default_version() -> String {
+    CURRENT_CONFIG_VERSION.to_string()
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -450,7 +456,7 @@ impl Default for Config {
         );
 
         Self {
-            version: "1".to_string(),
+            version: CURRENT_CONFIG_VERSION.to_string(),
             network: "testnet".to_string(),
             wallets: vec![],
             networks,
@@ -461,81 +467,120 @@ impl Default for Config {
     }
 }
 
-const CURRENT_CONFIG_VERSION: &str = "1";
-
-pub fn migrate_config(mut config: Config) -> Result<Config> {
-    let config_version = config.version.as_str();
+/// Current config schema version, as a string (matches the serialized form).
+pub const CURRENT_CONFIG_VERSION: &str = "2";
 
-    if config_version == CURRENT_CONFIG_VERSION {
-        return Ok(config);
-    }
+/// Numeric form of [`CURRENT_CONFIG_VERSION`], used by the migration engine.
+pub const CURRENT_CONFIG_VERSION_NUM: u32 = 2;
 
-    // Create backup before migration
-    backup_config(&config)?;
+/// Outcome of running migrations against a raw config value.
+#[derive(Debug, Clone)]
+pub struct MigrationOutcome {
+    /// The config value after all migrations were applied.
+    pub value: serde_json::Value,
+    /// Ordered `(from, to)` version steps that were applied.
+    pub steps: Vec<(u32, u32)>,
+    /// Human-readable diff between the original and migrated values.
+    pub changes: Vec<migrations::Change>,
+}
 
-    // Apply migrations in sequence
-    match config_version {
-        "" | "0" => {
-            // Migration from v0 to v1: Add version field
-            config.version = "1".to_string();
-        }
-        _ => {
-            anyhow::bail!(
-                "Unknown config version '{}'. Current version is '{}'.",
-                config_version,
-                CURRENT_CONFIG_VERSION
-            );
-        }
+impl MigrationOutcome {
+    /// True when at least one migration step was applied.
+    pub fn migrated(&self) -> bool {
+        !self.steps.is_empty()
     }
+}
 
-    Ok(config)
+/// Runs the migration pipeline on a raw [`serde_json::Value`] without touching
+/// the file system. This is the pure core shared by `load()` and the
+/// `config migrate --dry-run` command.
+pub fn migrate_json_value(original: &serde_json::Value) -> Result<MigrationOutcome> {
+    let mut value = original.clone();
+    let steps = migrations::migrate_value(&mut value, CURRENT_CONFIG_VERSION_NUM)?;
+    let changes = migrations::diff(original, &value);
+    Ok(MigrationOutcome {
+        value,
+        steps,
+        changes,
+    })
 }
 
-fn backup_config(config: &Config) -> Result<()> {
-    let backup_path = config_dir().join(format!(
-        "config.backup.v{}.{}.toml",
-        config.version,
-        chrono::Utc::now().timestamp()
-    ));
+/// Parses raw config file contents (TOML) into a [`serde_json::Value`].
+fn parse_config_value(contents: &str) -> Result<serde_json::Value> {
+    toml::from_str::<serde_json::Value>(contents)
+        .with_context(|| "Failed to parse config file as structured data")
+}
 
-    let contents =
-        toml::to_string_pretty(config).with_context(|| "Failed to serialize config for backup")?;
+/// Legacy entry point retained for compatibility: migrates an already-parsed
+/// [`Config`] by round-tripping it through the JSON migration pipeline.
+///
+/// Prefer [`load`], which performs version-aware migration directly from the raw
+/// file before deserializing into [`Config`].
+pub fn migrate_config(config: Config) -> Result<Config> {
+    let value =
+        serde_json::to_value(&config).with_context(|| "Failed to convert config for migration")?;
+    let outcome = migrate_json_value(&value)?;
+    serde_json::from_value(outcome.value).with_context(|| "Failed to deserialize migrated config")
+}
 
+/// Writes a `config.toml.bak` backup of the current on-disk config before a
+/// migration overwrites it. A timestamped copy is also retained so multiple
+/// migrations never clobber a single backup.
+fn backup_config_file(contents: &str) -> Result<PathBuf> {
+    let dir = config_dir();
+    if !dir.exists() {
+        fs::create_dir_all(&dir)
+            .with_context(|| format!("Failed to create config dir {:?}", dir))?;
+    }
+
+    let backup_path = dir.join("config.toml.bak");
     fs::write(&backup_path, contents)
         .with_context(|| format!("Failed to write backup to {:?}", backup_path))?;
 
-    Ok(())
+    // Also keep a timestamped copy so successive migrations are recoverable.
+    let timestamped = dir.join(format!(
+        "config.toml.{}.bak",
+        chrono::Utc::now().timestamp()
+    ));
+    let _ = fs::write(&timestamped, contents);
+
+    Ok(backup_path)
 }
 
+/// Restores the most recent pre-migration backup over the live config file.
+///
+/// Prefers the canonical `config.toml.bak`; otherwise falls back to the newest
+/// timestamped `config.toml.<ts>.bak` copy written by [`backup_config_file`].
 #[allow(dead_code)]
-pub fn rollback_config(version: &str) -> Result<()> {
-    let config_dir = config_dir();
-    let backup_pattern = format!("config.backup.v{}", version);
-
-    let mut backups: Vec<_> = fs::read_dir(&config_dir)?
-        .filter_map(|entry| entry.ok())
-        .filter(|entry| {
-            entry
-                .file_name()
-                .to_string_lossy()
-                .starts_with(&backup_pattern)
-        })
-        .collect();
-
-    if backups.is_empty() {
-        anyhow::bail!("No backup found for version '{}'", version);
-    }
+pub fn rollback_config() -> Result<PathBuf> {
+    let dir = config_dir();
 
-    // Sort by timestamp (newest first)
-    backups.sort_by_key(|b| std::cmp::Reverse(b.file_name()));
+    let canonical = dir.join("config.toml.bak");
+    let backup_path = if canonical.exists() {
+        canonical
+    } else {
+        let mut backups: Vec<_> = fs::read_dir(&dir)?
+            .filter_map(|entry| entry.ok())
+            .filter(|entry| {
+                let name = entry.file_name();
+                let name = name.to_string_lossy();
+                name.starts_with("config.toml.") && name.ends_with(".bak")
+            })
+            .collect();
+
+        if backups.is_empty() {
+            anyhow::bail!("No config backup found to roll back to");
+        }
 
-    let latest_backup = &backups[0];
-    let backup_path = latest_backup.path();
+        // Sort by file name (timestamped) — newest first.
+        backups.sort_by_key(|b| std::cmp::Reverse(b.file_name()));
+        backups[0].path()
+    };
 
     fs::copy(&backup_path, config_path())
         .with_context(|| format!("Failed to restore backup from {:?}", backup_path))?;
 
-    Ok(())
+    Ok(backup_path)
 }
 
 pub fn config_dir() -> PathBuf {
@@ -566,21 +611,66 @@ pub fn load() -> Result<Config> {
     }
     let contents = fs::read_to_string(&path)
         .with_context(|| format!("Failed to read config at {:?}", path))?;
-    let mut config: Config =
-        toml::from_str(&contents).with_context(|| "Failed to parse config file")?;
 
-    // Migrate config if needed
-    config = migrate_config(config)?;
+    // Deserialize as a schema-agnostic value first, then migrate by version
+    // *before* attempting to deserialize into the current `Config`. This is the
+    // crux of the fix: a renamed/restructured field is reshaped here instead of
+    // being silently dropped by `#[serde(default)]`.
+    let raw = parse_config_value(&contents)?;
+    let outcome = migrate_json_value(&raw)?;
 
-    // Guarantee built-in networks are always present
+    let mut config: Config = serde_json::from_value(outcome.value)
+        .with_context(|| "Failed to deserialize config after migration")?;
+
+    // Guarantee built-in networks are always present.
     ensure_default_networks(&mut config);
 
-    // Save migrated config
-    if config.version != CURRENT_CONFIG_VERSION {
+    // NOTE: `load()` migrates in memory only and never writes to disk. This keeps
+    // reads side-effect free (so e.g. `config migrate --dry-run` and telemetry
+    // hooks don't silently rewrite the file). Persisting a migration is explicit:
+    // it happens on the next `save()` (which backs up the old file) or via
+    // `starforge config migrate`.
+    Ok(config)
+}
+
+/// Loads the raw config value and computes the migration plan without writing
+/// anything to disk. Backs the `config migrate --dry-run` command.
+///
+/// Returns `Ok(None)` when no config file exists yet.
+pub fn plan_migration() -> Result<Option<MigrationOutcome>> {
+    let path = config_path();
+    if !path.exists() {
+        return Ok(None);
+    }
+    let contents = fs::read_to_string(&path)
+        .with_context(|| format!("Failed to read config at {:?}", path))?;
+    let raw = parse_config_value(&contents)?;
+    Ok(Some(migrate_json_value(&raw)?))
+}
+
+/// Applies pending migrations to the on-disk config, writing a
+/// `config.toml.bak` backup beforehand. Returns the migration outcome.
+///
+/// This is the non-dry-run counterpart used by `config migrate`.
+pub fn apply_migration() -> Result<Option<MigrationOutcome>> {
+    let path = config_path();
+    if !path.exists() {
+        return Ok(None);
+    }
+    let contents = fs::read_to_string(&path)
+        .with_context(|| format!("Failed to read config at {:?}", path))?;
+    let raw = parse_config_value(&contents)?;
+    let outcome = migrate_json_value(&raw)?;
+
+    if outcome.migrated() {
+        let mut config: Config = serde_json::from_value(outcome.value.clone())
+            .with_context(|| "Failed to deserialize config after migration")?;
+        ensure_default_networks(&mut config);
+        // `save()` writes `config.toml.bak` before overwriting the old version.
         save(&config)?;
     }
 
-    Ok(config)
+    Ok(Some(outcome))
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -1058,8 +1148,23 @@ pub fn save(config: &Config) -> Result<()> {
         fs::create_dir_all(&dir)
             .with_context(|| format!("Failed to create config dir {:?}", dir))?;
     }
+
+    // If an on-disk config exists with a *different* schema version than the one
+    // we're about to write, back it up first. This is the "backup before every
+    // migration" guarantee: the original file is preserved as `config.toml.bak`
+    // the moment a version bump is persisted over it.
+    let path = config_path();
+    if let Ok(existing) = fs::read_to_string(&path) {
+        let existing_version = parse_config_value(&existing)
+            .map(|v| migrations::read_version(&v).to_string())
+            .unwrap_or_default();
+        if existing_version != config.version {
+            backup_config_file(&existing)?;
+        }
+    }
+
     let contents = toml::to_string_pretty(config).with_context(|| "Failed to serialize config")?;
-    fs::write(config_path(), contents).with_context(|| "Failed to write config file")?;
+    fs::write(&path, contents).with_context(|| "Failed to write config file")?;
     Ok(())
 }
 
diff --git a/src/utils/crypto.rs b/src/utils/crypto.rs
index 1bb0901b..e4fc6ae0 100644
--- a/src/utils/crypto.rs
+++ b/src/utils/crypto.rs
@@ -298,6 +298,7 @@ fn argon2_from_params(params: &Params) -> Argon2<'_> {
     Argon2::from(params.clone())
 }
 
+#[allow(clippy::type_complexity)]
 fn parse_encrypted_bundle(bundle: &str) -> Result<(Vec<u8>, Vec<u8>, Vec<u8>, Option<KdfOptions>)> {
     let parts: Vec<&str> = bundle.split(':').collect();
     match parts.len() {
diff --git a/src/utils/deploy_monitor.rs b/src/utils/deploy_monitor.rs
new file mode 100644
index 00000000..effa2ad4
--- /dev/null
+++ b/src/utils/deploy_monitor.rs
@@ -0,0 +1,595 @@
+//! Contract deployment monitoring service.
+//!
+//! Builds on [`crate::utils::deploy_history`] to provide continuous health
+//! monitoring of deployments: liveness probes, failure detection, alerting and
+//! an aggregate dashboard.
+//!
+//! The assessment logic is split from the I/O so it can be unit-tested without
+//! a network: pure functions ([`assess_health`], [`detect_failures`],
+//! [`summarize`]) operate on records plus [`LivenessProbe`] outcomes, while the
+//! command layer performs the actual RPC/Horizon probes.
+
+use crate::utils::config;
+use crate::utils::deploy_history::{DeployRecord, DeployStatus};
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::PathBuf;
+
+// ---------------------------------------------------------------------------
+// Health model
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum HealthStatus {
+    Healthy,
+    Degraded,
+    Unhealthy,
+    Unknown,
+}
+
+impl HealthStatus {
+    pub fn label(&self) -> &'static str {
+        match self {
+            HealthStatus::Healthy => "healthy",
+            HealthStatus::Degraded => "degraded",
+            HealthStatus::Unhealthy => "unhealthy",
+            HealthStatus::Unknown => "unknown",
+        }
+    }
+
+    pub fn symbol(&self) -> &'static str {
+        match self {
+            HealthStatus::Healthy => "✓",
+            HealthStatus::Degraded => "◐",
+            HealthStatus::Unhealthy => "✗",
+            HealthStatus::Unknown => "?",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct HealthCheck {
+    pub name: String,
+    pub passed: bool,
+    pub detail: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DeploymentHealth {
+    pub deployment_id: String,
+    pub contract_id: Option<String>,
+    pub network: String,
+    pub deploy_status: DeployStatus,
+    pub health: HealthStatus,
+    pub checks: Vec<HealthCheck>,
+    pub checked_at: String,
+}
+
+/// The result of probing live infrastructure for one deployment. Kept separate
+/// from the assessment so health logic is deterministic and testable.
+#[derive(Debug, Clone, Default)]
+pub struct LivenessProbe {
+    /// Whether the target network's RPC/Horizon is reachable.
+    pub network_reachable: bool,
+    /// `Some(true/false)` if the contract's liveness was checked, `None` if
+    /// it could not be (no contract id, or network unreachable).
+    pub contract_live: Option<bool>,
+    /// Age of the deployment record in seconds.
+    pub age_secs: i64,
+}
+
+/// How long a `Pending` deployment may sit before it is considered stuck.
+pub const STUCK_PENDING_SECS: i64 = 15 * 60;
+
+/// Combine a deployment record with a liveness probe into a health assessment.
+pub fn assess_health(record: &DeployRecord, probe: &LivenessProbe) -> DeploymentHealth {
+    let mut checks = Vec::new();
+
+    // 1. Recorded deploy status.
+    let status_ok = matches!(record.status, DeployStatus::Success);
+    checks.push(HealthCheck {
+        name: "deploy-status".to_string(),
+        passed: status_ok,
+        detail: record.status.to_string(),
+    });
+
+    // 2. Network reachability.
+    checks.push(HealthCheck {
+        name: "network".to_string(),
+        passed: probe.network_reachable,
+        detail: if probe.network_reachable {
+            format!("{} reachable", record.network)
+        } else {
+            format!("{} unreachable", record.network)
+        },
+    });
+
+    // 3. On-chain contract liveness (when applicable).
+    if let Some(live) = probe.contract_live {
+        checks.push(HealthCheck {
+            name: "contract-liveness".to_string(),
+            passed: live,
+            detail: if live {
+                "contract responds on-chain".to_string()
+            } else {
+                "contract not found on-chain".to_string()
+            },
+        });
+    }
+
+    let health = derive_status(record, probe);
+    DeploymentHealth {
+        deployment_id: record.id.clone(),
+        contract_id: record.contract_id.clone(),
+        network: record.network.clone(),
+        deploy_status: record.status.clone(),
+        health,
+        checks,
+        checked_at: now_rfc3339(),
+    }
+}
+
+fn derive_status(record: &DeployRecord, probe: &LivenessProbe) -> HealthStatus {
+    match record.status {
+        DeployStatus::Failed => HealthStatus::Unhealthy,
+        DeployStatus::RolledBack => HealthStatus::Degraded,
+        DeployStatus::Pending => {
+            if probe.age_secs > STUCK_PENDING_SECS {
+                HealthStatus::Unhealthy // stuck pending
+            } else {
+                HealthStatus::Degraded // awaiting confirmation
+            }
+        }
+        DeployStatus::Success => {
+            if !probe.network_reachable {
+                // Can't confirm; don't claim healthy.
+                return HealthStatus::Unknown;
+            }
+            match probe.contract_live {
+                Some(true) => HealthStatus::Healthy,
+                Some(false) => HealthStatus::Unhealthy, // deployed but missing on-chain
+                None => HealthStatus::Healthy,          // network ok, nothing else to verify
+            }
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Failure detection
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct FailureAlert {
+    pub deployment_id: String,
+    pub contract_id: Option<String>,
+    pub network: String,
+    pub kind: String,
+    pub severity: String,
+    pub message: String,
+}
+
+/// Detect failed and stuck deployments from history. Pure over the records and
+/// a reference timestamp so it is fully testable.
+pub fn detect_failures(records: &[DeployRecord], now_epoch: i64) -> Vec<FailureAlert> {
+    let mut alerts = Vec::new();
+    for r in records {
+        match r.status {
+            DeployStatus::Failed => alerts.push(FailureAlert {
+                deployment_id: r.id.clone(),
+                contract_id: r.contract_id.clone(),
+                network: r.network.clone(),
+                kind: "deploy-failed".to_string(),
+                severity: "critical".to_string(),
+                message: r
+                    .error
+                    .clone()
+                    .unwrap_or_else(|| "deployment reported failure".to_string()),
+            }),
+            DeployStatus::Pending => {
+                if let Some(age) = age_secs(&r.timestamp, now_epoch) {
+                    if age > STUCK_PENDING_SECS {
+                        alerts.push(FailureAlert {
+                            deployment_id: r.id.clone(),
+                            contract_id: r.contract_id.clone(),
+                            network: r.network.clone(),
+                            kind: "stuck-pending".to_string(),
+                            severity: "warning".to_string(),
+                            message: format!(
+                                "pending for {} minutes without confirmation",
+                                age / 60
+                            ),
+                        });
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    alerts
+}
+
+// ---------------------------------------------------------------------------
+// Aggregate summary / dashboard
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct NetworkHealth {
+    pub healthy: usize,
+    pub degraded: usize,
+    pub unhealthy: usize,
+    pub unknown: usize,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct MonitoringSummary {
+    pub total: usize,
+    pub healthy: usize,
+    pub degraded: usize,
+    pub unhealthy: usize,
+    pub unknown: usize,
+    pub by_network: BTreeMap<String, NetworkHealth>,
+}
+
+impl MonitoringSummary {
+    /// Fraction of monitored deployments that are healthy (0–100).
+    pub fn health_rate(&self) -> f64 {
+        if self.total == 0 {
+            return 100.0;
+        }
+        (self.healthy as f64 / self.total as f64) * 100.0
+    }
+}
+
+/// Aggregate a set of per-deployment health assessments.
+pub fn summarize(healths: &[DeploymentHealth]) -> MonitoringSummary {
+    let mut s = MonitoringSummary {
+        total: healths.len(),
+        ..Default::default()
+    };
+    for h in healths {
+        let net = s.by_network.entry(h.network.clone()).or_default();
+        match h.health {
+            HealthStatus::Healthy => {
+                s.healthy += 1;
+                net.healthy += 1;
+            }
+            HealthStatus::Degraded => {
+                s.degraded += 1;
+                net.degraded += 1;
+            }
+            HealthStatus::Unhealthy => {
+                s.unhealthy += 1;
+                net.unhealthy += 1;
+            }
+            HealthStatus::Unknown => {
+                s.unknown += 1;
+                net.unknown += 1;
+            }
+        }
+    }
+    s
+}
+
+// ---------------------------------------------------------------------------
+// Status-change tracking (for real-time updates)
+// ---------------------------------------------------------------------------
+
+/// Persisted snapshot of the last observed health per deployment, used to
+/// detect changes between monitoring cycles.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct HealthSnapshot {
+    pub statuses: BTreeMap<String, HealthStatus>,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct StatusChange {
+    pub deployment_id: String,
+    pub from: Option<HealthStatus>,
+    pub to: HealthStatus,
+}
+
+/// Compute health transitions relative to a previous snapshot.
+pub fn diff_snapshot(previous: &HealthSnapshot, current: &[DeploymentHealth]) -> Vec<StatusChange> {
+    let mut changes = Vec::new();
+    for h in current {
+        let prev = previous.statuses.get(&h.deployment_id).copied();
+        if prev != Some(h.health) {
+            changes.push(StatusChange {
+                deployment_id: h.deployment_id.clone(),
+                from: prev,
+                to: h.health,
+            });
+        }
+    }
+    changes
+}
+
+pub fn snapshot_from(healths: &[DeploymentHealth]) -> HealthSnapshot {
+    HealthSnapshot {
+        statuses: healths
+            .iter()
+            .map(|h| (h.deployment_id.clone(), h.health))
+            .collect(),
+        updated_at: now_rfc3339(),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Persistence (~/.starforge/deploy-monitor/)
+// ---------------------------------------------------------------------------
+
+fn monitor_dir() -> Result<PathBuf> {
+    let dir = config::config_dir().join("deploy-monitor");
+    if !dir.exists() {
+        fs::create_dir_all(&dir).with_context(|| format!("Failed to create {}", dir.display()))?;
+    }
+    Ok(dir)
+}
+
+pub fn load_snapshot() -> Result<HealthSnapshot> {
+    let path = monitor_dir()?.join("snapshot.json");
+    if !path.exists() {
+        return Ok(HealthSnapshot::default());
+    }
+    Ok(serde_json::from_str(&fs::read_to_string(&path)?).unwrap_or_default())
+}
+
+pub fn save_snapshot(snapshot: &HealthSnapshot) -> Result<()> {
+    fs::write(
+        monitor_dir()?.join("snapshot.json"),
+        serde_json::to_string_pretty(snapshot)?,
+    )?;
+    Ok(())
+}
+
+/// Append failure alerts to a rotating alert log.
+pub fn log_alerts(alerts: &[FailureAlert]) -> Result<()> {
+    if alerts.is_empty() {
+        return Ok(());
+    }
+    let path = monitor_dir()?.join("alerts.json");
+    let mut existing: Vec<FailureAlert> = if path.exists() {
+        serde_json::from_str(&fs::read_to_string(&path)?).unwrap_or_default()
+    } else {
+        Vec::new()
+    };
+    existing.extend_from_slice(alerts);
+    if existing.len() > 1000 {
+        let overflow = existing.len() - 1000;
+        existing.drain(0..overflow);
+    }
+    fs::write(path, serde_json::to_string_pretty(&existing)?)?;
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+fn now_rfc3339() -> String {
+    chrono::Utc::now().to_rfc3339()
+}
+
+pub fn now_epoch() -> i64 {
+    chrono::Utc::now().timestamp()
+}
+
+/// Age of an RFC3339 timestamp in seconds relative to `now_epoch`.
+pub fn age_secs(timestamp: &str, now_epoch: i64) -> Option<i64> {
+    chrono::DateTime::parse_from_rfc3339(timestamp)
+        .ok()
+        .map(|dt| now_epoch - dt.timestamp())
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn record(id: &str, status: DeployStatus, contract: Option<&str>, ts: &str) -> DeployRecord {
+        DeployRecord {
+            id: id.to_string(),
+            contract_id: contract.map(|c| c.to_string()),
+            wasm_path: "c.wasm".to_string(),
+            wasm_hash: "hash".to_string(),
+            network: "testnet".to_string(),
+            wallet: "alice".to_string(),
+            timestamp: ts.to_string(),
+            status,
+            error: None,
+            previous_id: None,
+            approved_by: None,
+            verification_passed: false,
+        }
+    }
+
+    #[test]
+    fn healthy_when_success_and_contract_live() {
+        let r = record(
+            "1",
+            DeployStatus::Success,
+            Some("C123"),
+            "2026-01-01T00:00:00+00:00",
+        );
+        let probe = LivenessProbe {
+            network_reachable: true,
+            contract_live: Some(true),
+            age_secs: 10,
+        };
+        let h = assess_health(&r, &probe);
+        assert_eq!(h.health, HealthStatus::Healthy);
+        assert!(h
+            .checks
+            .iter()
+            .any(|c| c.name == "contract-liveness" && c.passed));
+    }
+
+    #[test]
+    fn unhealthy_when_deployed_but_missing_onchain() {
+        let r = record(
+            "1",
+            DeployStatus::Success,
+            Some("C123"),
+            "2026-01-01T00:00:00+00:00",
+        );
+        let probe = LivenessProbe {
+            network_reachable: true,
+            contract_live: Some(false),
+            age_secs: 10,
+        };
+        assert_eq!(assess_health(&r, &probe).health, HealthStatus::Unhealthy);
+    }
+
+    #[test]
+    fn unknown_when_network_unreachable() {
+        let r = record(
+            "1",
+            DeployStatus::Success,
+            Some("C123"),
+            "2026-01-01T00:00:00+00:00",
+        );
+        let probe = LivenessProbe {
+            network_reachable: false,
+            contract_live: None,
+            age_secs: 10,
+        };
+        assert_eq!(assess_health(&r, &probe).health, HealthStatus::Unknown);
+    }
+
+    #[test]
+    fn failed_deploy_is_unhealthy() {
+        let r = record("1", DeployStatus::Failed, None, "2026-01-01T00:00:00+00:00");
+        let probe = LivenessProbe {
+            network_reachable: true,
+            contract_live: None,
+            age_secs: 10,
+        };
+        assert_eq!(assess_health(&r, &probe).health, HealthStatus::Unhealthy);
+    }
+
+    #[test]
+    fn stuck_pending_is_unhealthy() {
+        let r = record(
+            "1",
+            DeployStatus::Pending,
+            None,
+            "2026-01-01T00:00:00+00:00",
+        );
+        let probe = LivenessProbe {
+            network_reachable: true,
+            contract_live: None,
+            age_secs: STUCK_PENDING_SECS + 1,
+        };
+        assert_eq!(assess_health(&r, &probe).health, HealthStatus::Unhealthy);
+    }
+
+    #[test]
+    fn detect_failures_finds_failed_and_stuck() {
+        let now = chrono::DateTime::parse_from_rfc3339("2026-01-01T01:00:00+00:00")
+            .unwrap()
+            .timestamp();
+        let records = vec![
+            record(
+                "ok",
+                DeployStatus::Success,
+                Some("C1"),
+                "2026-01-01T00:59:00+00:00",
+            ),
+            record(
+                "bad",
+                DeployStatus::Failed,
+                None,
+                "2026-01-01T00:30:00+00:00",
+            ),
+            record(
+                "stuck",
+                DeployStatus::Pending,
+                None,
+                "2026-01-01T00:00:00+00:00",
+            ),
+            record(
+                "recent",
+                DeployStatus::Pending,
+                None,
+                "2026-01-01T00:58:00+00:00",
+            ),
+        ];
+        let alerts = detect_failures(&records, now);
+        assert_eq!(alerts.len(), 2);
+        assert!(alerts.iter().any(|a| a.kind == "deploy-failed"));
+        assert!(alerts.iter().any(|a| a.kind == "stuck-pending"));
+    }
+
+    #[test]
+    fn summary_counts_by_health_and_network() {
+        let healths = vec![
+            DeploymentHealth {
+                deployment_id: "1".into(),
+                contract_id: None,
+                network: "testnet".into(),
+                deploy_status: DeployStatus::Success,
+                health: HealthStatus::Healthy,
+                checks: vec![],
+                checked_at: "t".into(),
+            },
+            DeploymentHealth {
+                deployment_id: "2".into(),
+                contract_id: None,
+                network: "mainnet".into(),
+                deploy_status: DeployStatus::Failed,
+                health: HealthStatus::Unhealthy,
+                checks: vec![],
+                checked_at: "t".into(),
+            },
+        ];
+        let s = summarize(&healths);
+        assert_eq!(s.total, 2);
+        assert_eq!(s.healthy, 1);
+        assert_eq!(s.unhealthy, 1);
+        assert_eq!(s.by_network["testnet"].healthy, 1);
+        assert_eq!(s.by_network["mainnet"].unhealthy, 1);
+        assert_eq!(s.health_rate(), 50.0);
+    }
+
+    #[test]
+    fn snapshot_diff_detects_transitions() {
+        let healths = vec![DeploymentHealth {
+            deployment_id: "1".into(),
+            contract_id: None,
+            network: "testnet".into(),
+            deploy_status: DeployStatus::Success,
+            health: HealthStatus::Unhealthy,
+            checks: vec![],
+            checked_at: "t".into(),
+        }];
+        let mut prev = HealthSnapshot::default();
+        prev.statuses.insert("1".to_string(), HealthStatus::Healthy);
+        let changes = diff_snapshot(&prev, &healths);
+        assert_eq!(changes.len(), 1);
+        assert_eq!(changes[0].from, Some(HealthStatus::Healthy));
+        assert_eq!(changes[0].to, HealthStatus::Unhealthy);
+    }
+
+    #[test]
+    fn snapshot_diff_ignores_unchanged() {
+        let healths = vec![DeploymentHealth {
+            deployment_id: "1".into(),
+            contract_id: None,
+            network: "testnet".into(),
+            deploy_status: DeployStatus::Success,
+            health: HealthStatus::Healthy,
+            checks: vec![],
+            checked_at: "t".into(),
+        }];
+        let mut prev = HealthSnapshot::default();
+        prev.statuses.insert("1".to_string(), HealthStatus::Healthy);
+        assert!(diff_snapshot(&prev, &healths).is_empty());
+    }
+}
diff --git a/src/utils/docs.rs b/src/utils/docs.rs
index 58fcbb03..235f4da5 100644
--- a/src/utils/docs.rs
+++ b/src/utils/docs.rs
@@ -269,7 +269,7 @@ pub fn search_documentation(query: &str) -> Result<Vec<SearchResult>> {
         }
     }
 
-    results.sort_by(|a, b| b.score.cmp(&a.score));
+    results.sort_by_key(|b| std::cmp::Reverse(b.score));
     Ok(results)
 }
 
diff --git a/src/utils/event_stream.rs b/src/utils/event_stream.rs
new file mode 100644
index 00000000..b55fd6e1
--- /dev/null
+++ b/src/utils/event_stream.rs
@@ -0,0 +1,727 @@
+//! Real-time contract event processing: filtering, routing, alerting,
+//! persistence/replay, analytics and event-based triggers.
+//!
+//! Live delivery is handled by [`crate::utils::stream::SorobanEventStream`],
+//! which streams Soroban RPC `getEvents` with cursor pagination and exponential
+//! backoff (the canonical event transport — Soroban RPC exposes events over
+//! JSON-RPC rather than a socket). This module sits on top of that transport
+//! and turns raw events into a processing pipeline:
+//!
+//! ```text
+//!   SorobanEvent -> EventRecord -> [filter] -> route(s) / alert pattern(s) / triggers
+//!                                      |                                          |
+//!                                   persist  <----------- replay ---------------- +
+//! ```
+//!
+//! Everything here is sync and persisted as JSON under `~/.starforge/events/`.
+
+use crate::utils::config;
+use crate::utils::stream::SorobanEvent;
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::PathBuf;
+
+// ---------------------------------------------------------------------------
+// Normalized, persistable event
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct EventRecord {
+    pub id: String,
+    pub contract_id: String,
+    pub event_type: String,
+    pub ledger: u32,
+    pub topics: Vec<String>,
+    pub value: String,
+    /// RFC3339 timestamp the event was received/recorded.
+    pub received_at: String,
+}
+
+impl EventRecord {
+    pub fn from_soroban(ev: &SorobanEvent, contract_id: &str) -> Self {
+        Self {
+            id: ev.id.clone(),
+            contract_id: contract_id.to_string(),
+            event_type: ev.event_type.clone(),
+            ledger: ev.ledger,
+            topics: ev.topic.clone(),
+            value: ev.value.to_string(),
+            received_at: now_rfc3339(),
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Filtering
+// ---------------------------------------------------------------------------
+
+/// A declarative filter matched against an [`EventRecord`]. All set fields must
+/// match (logical AND). `topic_pattern` is a comma-separated list of segments
+/// where `*` matches any single segment.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct EventFilter {
+    #[serde(default)]
+    pub contract_id: Option<String>,
+    #[serde(default)]
+    pub event_type: Option<String>,
+    #[serde(default)]
+    pub topic_pattern: Option<String>,
+    #[serde(default)]
+    pub value_contains: Option<String>,
+}
+
+impl EventFilter {
+    pub fn matches(&self, rec: &EventRecord) -> bool {
+        if let Some(c) = &self.contract_id {
+            if &rec.contract_id != c {
+                return false;
+            }
+        }
+        if let Some(t) = &self.event_type {
+            if !rec.event_type.eq_ignore_ascii_case(t) {
+                return false;
+            }
+        }
+        if let Some(v) = &self.value_contains {
+            if !rec.value.to_lowercase().contains(&v.to_lowercase()) {
+                return false;
+            }
+        }
+        if let Some(pattern) = &self.topic_pattern {
+            if !topic_matches(pattern, &rec.topics) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+/// Segment-wise wildcard match: each comma-separated pattern segment must equal
+/// the corresponding topic segment, or be `*`. A pattern with fewer segments
+/// than the topic matches as a prefix.
+fn topic_matches(pattern: &str, topics: &[String]) -> bool {
+    let segments: Vec<&str> = pattern.split(',').map(|s| s.trim()).collect();
+    if segments.len() > topics.len() {
+        return false;
+    }
+    segments
+        .iter()
+        .zip(topics.iter())
+        .all(|(pat, topic)| *pat == "*" || pat == topic)
+}
+
+// ---------------------------------------------------------------------------
+// Routing & triggers
+// ---------------------------------------------------------------------------
+
+/// The side effect to perform when a route matches an event.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "action", rename_all = "snake_case")]
+pub enum RouteAction {
+    /// Print the event to the console.
+    Log,
+    /// Queue a notification through the configured channels.
+    Notify { template: String, severity: String },
+    /// POST the event payload to a webhook URL.
+    Webhook { url: String },
+}
+
+/// A named routing rule: when `filter` matches, perform `action`. Routes double
+/// as event-based triggers.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct EventRoute {
+    pub name: String,
+    pub filter: EventFilter,
+    pub action: RouteAction,
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+}
+
+fn default_true() -> bool {
+    true
+}
+
+/// Return the routes (by reference) whose filter matches the record.
+pub fn match_routes<'a>(rec: &EventRecord, routes: &'a [EventRoute]) -> Vec<&'a EventRoute> {
+    routes
+        .iter()
+        .filter(|r| r.enabled && r.filter.matches(rec))
+        .collect()
+}
+
+/// Execute a route's action against an event (performs side effects).
+pub fn execute_route(route: &EventRoute, rec: &EventRecord) -> Result<()> {
+    match &route.action {
+        RouteAction::Log => {
+            println!(
+                "  [{}] ledger {} {} {}",
+                route.name, rec.ledger, rec.event_type, rec.value
+            );
+            Ok(())
+        }
+        RouteAction::Notify { template, severity } => {
+            let mut data = std::collections::HashMap::new();
+            data.insert(
+                "message".to_string(),
+                format!("Event {} on {}", rec.id, rec.contract_id),
+            );
+            data.insert("event_id".to_string(), rec.id.clone());
+            data.insert("ledger".to_string(), rec.ledger.to_string());
+            crate::utils::notifications::send_notification(template, &data, severity)
+        }
+        RouteAction::Webhook { url } => {
+            let payload = serde_json::to_value(rec)?;
+            ureq::post(url)
+                .set("Content-Type", "application/json")
+                .send_json(payload)
+                .map(|_| ())
+                .with_context(|| format!("Webhook POST to {} failed", url))
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Alert patterns (sliding-window thresholds)
+// ---------------------------------------------------------------------------
+
+/// Fire an alert when at least `threshold` events match `filter` within a
+/// trailing window of `window_secs`.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AlertPattern {
+    pub name: String,
+    pub filter: EventFilter,
+    pub window_secs: i64,
+    pub threshold: usize,
+    #[serde(default = "default_severity")]
+    pub severity: String,
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+}
+
+fn default_severity() -> String {
+    "warning".to_string()
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Alert {
+    pub pattern: String,
+    pub severity: String,
+    pub count: usize,
+    pub threshold: usize,
+    pub window_secs: i64,
+}
+
+/// Count how many of `events` match the pattern within `window_secs` of
+/// `now_epoch` (seconds since the Unix epoch).
+pub fn count_in_window(pattern: &AlertPattern, events: &[EventRecord], now_epoch: i64) -> usize {
+    events
+        .iter()
+        .filter(|e| pattern.filter.matches(e))
+        .filter(|e| {
+            parse_epoch(&e.received_at)
+                .map(|t| now_epoch - t <= pattern.window_secs && now_epoch - t >= 0)
+                .unwrap_or(false)
+        })
+        .count()
+}
+
+/// Evaluate a single pattern, returning an `Alert` if the threshold is met.
+pub fn evaluate_pattern(
+    pattern: &AlertPattern,
+    events: &[EventRecord],
+    now_epoch: i64,
+) -> Option<Alert> {
+    if !pattern.enabled {
+        return None;
+    }
+    let count = count_in_window(pattern, events, now_epoch);
+    if count >= pattern.threshold {
+        Some(Alert {
+            pattern: pattern.name.clone(),
+            severity: pattern.severity.clone(),
+            count,
+            threshold: pattern.threshold,
+            window_secs: pattern.window_secs,
+        })
+    } else {
+        None
+    }
+}
+
+/// Evaluate every pattern against the event history.
+pub fn evaluate_alerts(
+    patterns: &[AlertPattern],
+    events: &[EventRecord],
+    now_epoch: i64,
+) -> Vec<Alert> {
+    patterns
+        .iter()
+        .filter_map(|p| evaluate_pattern(p, events, now_epoch))
+        .collect()
+}
+
+// ---------------------------------------------------------------------------
+// Analytics
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct EventAnalytics {
+    pub total: usize,
+    pub by_type: BTreeMap<String, usize>,
+    pub by_contract: BTreeMap<String, usize>,
+    pub unique_ledgers: usize,
+    pub first_ledger: Option<u32>,
+    pub last_ledger: Option<u32>,
+    /// Top topic segments by frequency, descending.
+    pub top_topics: Vec<(String, usize)>,
+}
+
+impl EventAnalytics {
+    pub fn from_events(events: &[EventRecord]) -> Self {
+        let mut by_type: BTreeMap<String, usize> = BTreeMap::new();
+        let mut by_contract: BTreeMap<String, usize> = BTreeMap::new();
+        let mut topic_counts: BTreeMap<String, usize> = BTreeMap::new();
+        let mut ledgers = std::collections::BTreeSet::new();
+
+        for e in events {
+            *by_type.entry(e.event_type.clone()).or_default() += 1;
+            *by_contract.entry(e.contract_id.clone()).or_default() += 1;
+            ledgers.insert(e.ledger);
+            for t in &e.topics {
+                *topic_counts.entry(t.clone()).or_default() += 1;
+            }
+        }
+
+        let mut top_topics: Vec<(String, usize)> = topic_counts.into_iter().collect();
+        top_topics.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(&b.0)));
+        top_topics.truncate(10);
+
+        Self {
+            total: events.len(),
+            by_type,
+            by_contract,
+            unique_ledgers: ledgers.len(),
+            first_ledger: ledgers.iter().next().copied(),
+            last_ledger: ledgers.iter().next_back().copied(),
+            top_topics,
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Replay
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct ReplaySummary {
+    pub processed: usize,
+    pub matched_routes: usize,
+    pub alerts: Vec<Alert>,
+}
+
+/// Replay persisted events through the routing + alerting pipeline without
+/// performing side effects. Useful for testing rules against history.
+pub fn replay(
+    events: &[EventRecord],
+    routes: &[EventRoute],
+    patterns: &[AlertPattern],
+    now_epoch: i64,
+) -> ReplaySummary {
+    let mut matched_routes = 0;
+    for e in events {
+        matched_routes += match_routes(e, routes).len();
+    }
+    ReplaySummary {
+        processed: events.len(),
+        matched_routes,
+        alerts: evaluate_alerts(patterns, events, now_epoch),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Persistence (~/.starforge/events/)
+// ---------------------------------------------------------------------------
+
+const MAX_PERSISTED_EVENTS: usize = 5000;
+
+fn events_dir() -> Result<PathBuf> {
+    let dir = config::config_dir().join("events");
+    if !dir.exists() {
+        fs::create_dir_all(&dir).with_context(|| format!("Failed to create {}", dir.display()))?;
+    }
+    Ok(dir)
+}
+
+fn events_path(contract: &str) -> Result<PathBuf> {
+    Ok(events_dir()?.join(format!("{}.json", sanitize(contract))))
+}
+
+/// Load all persisted events for a contract (oldest first).
+pub fn load_events(contract: &str) -> Result<Vec<EventRecord>> {
+    let path = events_path(contract)?;
+    if !path.exists() {
+        return Ok(Vec::new());
+    }
+    let contents = fs::read_to_string(&path)?;
+    Ok(serde_json::from_str(&contents).unwrap_or_default())
+}
+
+/// Append events for a contract, de-duplicating by id and capping history.
+pub fn append_events(contract: &str, new_events: &[EventRecord]) -> Result<usize> {
+    if new_events.is_empty() {
+        return Ok(0);
+    }
+    let mut existing = load_events(contract)?;
+    let mut seen: std::collections::HashSet<String> =
+        existing.iter().map(|e| e.id.clone()).collect();
+
+    let mut added = 0;
+    for e in new_events {
+        if seen.insert(e.id.clone()) {
+            existing.push(e.clone());
+            added += 1;
+        }
+    }
+
+    if existing.len() > MAX_PERSISTED_EVENTS {
+        let overflow = existing.len() - MAX_PERSISTED_EVENTS;
+        existing.drain(0..overflow);
+    }
+
+    let path = events_path(contract)?;
+    fs::write(&path, serde_json::to_string_pretty(&existing)?)?;
+    Ok(added)
+}
+
+// --- routes config ---
+
+fn routes_path() -> Result<PathBuf> {
+    Ok(events_dir()?.join("routes.json"))
+}
+
+pub fn load_routes() -> Result<Vec<EventRoute>> {
+    let path = routes_path()?;
+    if !path.exists() {
+        return Ok(Vec::new());
+    }
+    Ok(serde_json::from_str(&fs::read_to_string(&path)?).unwrap_or_default())
+}
+
+pub fn save_routes(routes: &[EventRoute]) -> Result<()> {
+    fs::write(routes_path()?, serde_json::to_string_pretty(routes)?)?;
+    Ok(())
+}
+
+pub fn add_route(route: EventRoute) -> Result<()> {
+    let mut routes = load_routes()?;
+    routes.retain(|r| r.name != route.name);
+    routes.push(route);
+    save_routes(&routes)
+}
+
+// --- alert patterns config ---
+
+fn alerts_path() -> Result<PathBuf> {
+    Ok(events_dir()?.join("alert_patterns.json"))
+}
+
+pub fn load_alert_patterns() -> Result<Vec<AlertPattern>> {
+    let path = alerts_path()?;
+    if !path.exists() {
+        return Ok(Vec::new());
+    }
+    Ok(serde_json::from_str(&fs::read_to_string(&path)?).unwrap_or_default())
+}
+
+pub fn save_alert_patterns(patterns: &[AlertPattern]) -> Result<()> {
+    fs::write(alerts_path()?, serde_json::to_string_pretty(patterns)?)?;
+    Ok(())
+}
+
+pub fn add_alert_pattern(pattern: AlertPattern) -> Result<()> {
+    let mut patterns = load_alert_patterns()?;
+    patterns.retain(|p| p.name != pattern.name);
+    patterns.push(pattern);
+    save_alert_patterns(&patterns)
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+fn now_rfc3339() -> String {
+    chrono::Utc::now().to_rfc3339()
+}
+
+/// Current Unix time in seconds (used for alert windows).
+pub fn now_epoch() -> i64 {
+    chrono::Utc::now().timestamp()
+}
+
+fn parse_epoch(rfc3339: &str) -> Option<i64> {
+    chrono::DateTime::parse_from_rfc3339(rfc3339)
+        .ok()
+        .map(|dt| dt.timestamp())
+}
+
+fn sanitize(name: &str) -> String {
+    name.chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || c == '-' || c == '_' {
+                c
+            } else {
+                '_'
+            }
+        })
+        .collect()
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rec(
+        id: &str,
+        etype: &str,
+        ledger: u32,
+        topics: &[&str],
+        value: &str,
+        ts: &str,
+    ) -> EventRecord {
+        EventRecord {
+            id: id.to_string(),
+            contract_id: "CTEST".to_string(),
+            event_type: etype.to_string(),
+            ledger,
+            topics: topics.iter().map(|s| s.to_string()).collect(),
+            value: value.to_string(),
+            received_at: ts.to_string(),
+        }
+    }
+
+    #[test]
+    fn filter_matches_type_and_value() {
+        let r = rec(
+            "1",
+            "contract",
+            10,
+            &["transfer", "alice"],
+            "100",
+            "2026-01-01T00:00:00Z",
+        );
+        let f = EventFilter {
+            event_type: Some("contract".into()),
+            value_contains: Some("100".into()),
+            ..Default::default()
+        };
+        assert!(f.matches(&r));
+
+        let f2 = EventFilter {
+            value_contains: Some("999".into()),
+            ..Default::default()
+        };
+        assert!(!f2.matches(&r));
+    }
+
+    #[test]
+    fn topic_wildcard_matches() {
+        let r = rec(
+            "1",
+            "contract",
+            10,
+            &["transfer", "alice"],
+            "x",
+            "2026-01-01T00:00:00Z",
+        );
+        assert!(topic_matches("transfer,*", &r.topics));
+        assert!(topic_matches("transfer", &r.topics)); // prefix
+        assert!(!topic_matches("mint,*", &r.topics));
+        assert!(!topic_matches("transfer,alice,extra", &r.topics)); // too long
+    }
+
+    #[test]
+    fn routes_match_only_enabled() {
+        let r = rec(
+            "1",
+            "contract",
+            10,
+            &["transfer"],
+            "x",
+            "2026-01-01T00:00:00Z",
+        );
+        let routes = vec![
+            EventRoute {
+                name: "on".into(),
+                filter: EventFilter {
+                    topic_pattern: Some("transfer".into()),
+                    ..Default::default()
+                },
+                action: RouteAction::Log,
+                enabled: true,
+            },
+            EventRoute {
+                name: "off".into(),
+                filter: EventFilter::default(),
+                action: RouteAction::Log,
+                enabled: false,
+            },
+        ];
+        let matched = match_routes(&r, &routes);
+        assert_eq!(matched.len(), 1);
+        assert_eq!(matched[0].name, "on");
+    }
+
+    #[test]
+    fn alert_fires_when_threshold_met_in_window() {
+        let events = vec![
+            rec(
+                "1",
+                "contract",
+                1,
+                &["err"],
+                "x",
+                "2026-01-01T00:00:00+00:00",
+            ),
+            rec(
+                "2",
+                "contract",
+                2,
+                &["err"],
+                "x",
+                "2026-01-01T00:00:30+00:00",
+            ),
+            rec(
+                "3",
+                "contract",
+                3,
+                &["err"],
+                "x",
+                "2026-01-01T00:00:50+00:00",
+            ),
+        ];
+        let now = parse_epoch("2026-01-01T00:01:00+00:00").unwrap();
+        let pattern = AlertPattern {
+            name: "errors".into(),
+            filter: EventFilter {
+                topic_pattern: Some("err".into()),
+                ..Default::default()
+            },
+            window_secs: 120,
+            threshold: 3,
+            severity: "critical".into(),
+            enabled: true,
+        };
+        let alert = evaluate_pattern(&pattern, &events, now).unwrap();
+        assert_eq!(alert.count, 3);
+    }
+
+    #[test]
+    fn alert_respects_window() {
+        let events = vec![
+            rec(
+                "1",
+                "contract",
+                1,
+                &["err"],
+                "x",
+                "2026-01-01T00:00:00+00:00",
+            ),
+            rec(
+                "2",
+                "contract",
+                2,
+                &["err"],
+                "x",
+                "2026-01-01T00:00:01+00:00",
+            ),
+        ];
+        // 'now' is far in the future; both events fall outside a 10s window.
+        let now = parse_epoch("2026-01-01T01:00:00+00:00").unwrap();
+        let pattern = AlertPattern {
+            name: "errors".into(),
+            filter: EventFilter::default(),
+            window_secs: 10,
+            threshold: 1,
+            severity: "warning".into(),
+            enabled: true,
+        };
+        assert!(evaluate_pattern(&pattern, &events, now).is_none());
+    }
+
+    #[test]
+    fn analytics_aggregates_counts() {
+        let events = vec![
+            rec(
+                "1",
+                "contract",
+                10,
+                &["transfer"],
+                "x",
+                "2026-01-01T00:00:00Z",
+            ),
+            rec(
+                "2",
+                "contract",
+                11,
+                &["transfer"],
+                "y",
+                "2026-01-01T00:00:01Z",
+            ),
+            rec("3", "system", 11, &["fee"], "z", "2026-01-01T00:00:02Z"),
+        ];
+        let a = EventAnalytics::from_events(&events);
+        assert_eq!(a.total, 3);
+        assert_eq!(a.by_type["contract"], 2);
+        assert_eq!(a.unique_ledgers, 2);
+        assert_eq!(a.first_ledger, Some(10));
+        assert_eq!(a.last_ledger, Some(11));
+        assert_eq!(a.top_topics[0].0, "transfer");
+    }
+
+    #[test]
+    fn replay_counts_routes_and_alerts() {
+        let events = vec![
+            rec(
+                "1",
+                "contract",
+                1,
+                &["err"],
+                "x",
+                "2026-01-01T00:00:00+00:00",
+            ),
+            rec(
+                "2",
+                "contract",
+                2,
+                &["err"],
+                "x",
+                "2026-01-01T00:00:01+00:00",
+            ),
+        ];
+        let routes = vec![EventRoute {
+            name: "log-all".into(),
+            filter: EventFilter::default(),
+            action: RouteAction::Log,
+            enabled: true,
+        }];
+        let patterns = vec![AlertPattern {
+            name: "any".into(),
+            filter: EventFilter::default(),
+            window_secs: 3600,
+            threshold: 2,
+            severity: "info".into(),
+            enabled: true,
+        }];
+        let now = parse_epoch("2026-01-01T00:01:00+00:00").unwrap();
+        let summary = replay(&events, &routes, &patterns, now);
+        assert_eq!(summary.processed, 2);
+        assert_eq!(summary.matched_routes, 2);
+        assert_eq!(summary.alerts.len(), 1);
+    }
+}
diff --git a/src/utils/fuzzing.rs b/src/utils/fuzzing.rs
new file mode 100644
index 00000000..56dcf233
--- /dev/null
+++ b/src/utils/fuzzing.rs
@@ -0,0 +1,757 @@
+//! Contract fuzzing and property-based testing engine.
+//!
+//! This module provides a self-contained, deterministic fuzzing toolkit:
+//!
+//! * **Typed input generation** — produce random `ScVal`-style values
+//!   (`u32`, `u64`, `i128`, `bool`, `Symbol`, `Address`, `Bytes`, `String`)
+//!   from a seeded RNG so runs are reproducible.
+//! * **Property-based testing** — run an invariant against many generated
+//!   inputs and, on failure, **shrink** the counterexample toward a minimal
+//!   reproducer (the core idea behind `proptest`/`quickcheck`).
+//! * **WASM validator fuzzing** — byte-mutate a contract binary and assert the
+//!   validator rejects malformed input without panicking.
+//! * **Mutation testing** — generate source mutants (flip operators, drop
+//!   `require_auth`, etc.) and score how many a test oracle "kills".
+//! * **Corpus persistence** — store interesting / crashing inputs under
+//!   `~/.starforge/fuzz/` for replay.
+//!
+//! The engine is intentionally sync and uses only `rand`, matching the rest of
+//! the codebase. The integration test-suite additionally demonstrates
+//! `proptest`-driven property tests for contract logic.
+
+use crate::utils::config;
+use anyhow::{Context, Result};
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use std::fs;
+use std::path::PathBuf;
+
+// ---------------------------------------------------------------------------
+// Typed values
+// ---------------------------------------------------------------------------
+
+/// The Soroban-flavoured value types the generator understands.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum FuzzType {
+    U32,
+    U64,
+    I128,
+    Bool,
+    Symbol,
+    Address,
+    Bytes,
+    String,
+}
+
+impl FuzzType {
+    /// Parse a type name as it would appear in a contract signature.
+    pub fn parse(s: &str) -> Option<FuzzType> {
+        match s.trim().to_lowercase().as_str() {
+            "u32" => Some(FuzzType::U32),
+            "u64" => Some(FuzzType::U64),
+            "i128" | "int" => Some(FuzzType::I128),
+            "bool" => Some(FuzzType::Bool),
+            "symbol" => Some(FuzzType::Symbol),
+            "address" => Some(FuzzType::Address),
+            "bytes" => Some(FuzzType::Bytes),
+            "string" => Some(FuzzType::String),
+            _ => None,
+        }
+    }
+}
+
+/// A concrete generated value.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "type", content = "value", rename_all = "snake_case")]
+pub enum FuzzValue {
+    U32(u32),
+    U64(u64),
+    I128(i128),
+    Bool(bool),
+    Symbol(String),
+    Address(String),
+    Bytes(Vec<u8>),
+    String(String),
+}
+
+impl fmt::Display for FuzzValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            FuzzValue::U32(v) => write!(f, "{}u32", v),
+            FuzzValue::U64(v) => write!(f, "{}u64", v),
+            FuzzValue::I128(v) => write!(f, "{}i128", v),
+            FuzzValue::Bool(v) => write!(f, "{}", v),
+            FuzzValue::Symbol(v) => write!(f, "sym:{}", v),
+            FuzzValue::Address(v) => write!(f, "{}", v),
+            FuzzValue::Bytes(v) => write!(f, "bytes[{}]", v.len()),
+            FuzzValue::String(v) => write!(f, "\"{}\"", v),
+        }
+    }
+}
+
+/// A named, typed parameter in a contract function signature.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ArgSpec {
+    pub name: String,
+    pub ty: FuzzType,
+}
+
+/// Generate a single random value of the requested type.
+pub fn generate_value(ty: FuzzType, rng: &mut StdRng) -> FuzzValue {
+    match ty {
+        FuzzType::U32 => FuzzValue::U32(biased_u32(rng)),
+        FuzzType::U64 => FuzzValue::U64(rng.gen()),
+        FuzzType::I128 => FuzzValue::I128(rng.gen::<i64>() as i128),
+        FuzzType::Bool => FuzzValue::Bool(rng.gen_bool(0.5)),
+        FuzzType::Symbol => FuzzValue::Symbol(random_symbol(rng)),
+        FuzzType::Address => FuzzValue::Address(random_address(rng)),
+        FuzzType::Bytes => {
+            let len = rng.gen_range(0..32);
+            FuzzValue::Bytes((0..len).map(|_| rng.gen()).collect())
+        }
+        FuzzType::String => FuzzValue::String(random_string(rng)),
+    }
+}
+
+/// Generate a full input tuple for a function signature.
+pub fn generate_input(specs: &[ArgSpec], rng: &mut StdRng) -> Vec<FuzzValue> {
+    specs.iter().map(|s| generate_value(s.ty, rng)).collect()
+}
+
+/// Bias integer generation toward boundary values (0, 1, MAX) which are the
+/// classic edge cases that trip up contract arithmetic.
+fn biased_u32(rng: &mut StdRng) -> u32 {
+    match rng.gen_range(0..10) {
+        0 => 0,
+        1 => 1,
+        2 => u32::MAX,
+        3 => u32::MAX - 1,
+        _ => rng.gen(),
+    }
+}
+
+fn random_symbol(rng: &mut StdRng) -> String {
+    const ALPHABET: &[u8] = b"abcdefghijklmnopqrstuvwxyz_";
+    let len = rng.gen_range(1..=10);
+    (0..len)
+        .map(|_| ALPHABET[rng.gen_range(0..ALPHABET.len())] as char)
+        .collect()
+}
+
+fn random_address(rng: &mut StdRng) -> String {
+    const BASE32: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    let prefix = if rng.gen_bool(0.5) { 'G' } else { 'C' };
+    let body: String = (0..55)
+        .map(|_| BASE32[rng.gen_range(0..BASE32.len())] as char)
+        .collect();
+    format!("{}{}", prefix, body)
+}
+
+fn random_string(rng: &mut StdRng) -> String {
+    let len = rng.gen_range(0..16);
+    (0..len)
+        .map(|_| rng.gen_range(b' '..=b'~') as char)
+        .collect()
+}
+
+// ---------------------------------------------------------------------------
+// Property-based testing with shrinking
+// ---------------------------------------------------------------------------
+
+/// Outcome of evaluating a property against one input.
+pub type PropertyResult = std::result::Result<(), String>;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FuzzConfig {
+    pub iterations: usize,
+    pub seed: u64,
+    pub max_shrink_iters: usize,
+}
+
+impl Default for FuzzConfig {
+    fn default() -> Self {
+        Self {
+            iterations: 1000,
+            seed: 0xDEADBEEF,
+            max_shrink_iters: 200,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FuzzReport {
+    pub iterations_run: usize,
+    pub passed: bool,
+    pub failure_message: Option<String>,
+    pub counterexample: Option<Vec<FuzzValue>>,
+    pub shrunk_counterexample: Option<Vec<FuzzValue>>,
+    pub shrink_steps: usize,
+    pub seed: u64,
+}
+
+/// Run `property` against `iterations` generated inputs. On the first failure
+/// the offending input is shrunk toward a minimal reproducer.
+pub fn run_property<F>(specs: &[ArgSpec], config: &FuzzConfig, property: F) -> FuzzReport
+where
+    F: Fn(&[FuzzValue]) -> PropertyResult,
+{
+    let mut rng = StdRng::seed_from_u64(config.seed);
+
+    for i in 0..config.iterations {
+        let input = generate_input(specs, &mut rng);
+        if let Err(msg) = property(&input) {
+            let (shrunk, steps) = shrink(&input, config.max_shrink_iters, &property);
+            return FuzzReport {
+                iterations_run: i + 1,
+                passed: false,
+                failure_message: Some(msg),
+                counterexample: Some(input),
+                shrunk_counterexample: Some(shrunk),
+                shrink_steps: steps,
+                seed: config.seed,
+            };
+        }
+    }
+
+    FuzzReport {
+        iterations_run: config.iterations,
+        passed: true,
+        failure_message: None,
+        counterexample: None,
+        shrunk_counterexample: None,
+        shrink_steps: 0,
+        seed: config.seed,
+    }
+}
+
+/// Greedily shrink a failing input: repeatedly try "smaller" variants of each
+/// value and keep any that still fail the property.
+fn shrink<F>(input: &[FuzzValue], max_iters: usize, property: &F) -> (Vec<FuzzValue>, usize)
+where
+    F: Fn(&[FuzzValue]) -> PropertyResult,
+{
+    let mut best = input.to_vec();
+    let mut steps = 0;
+    let mut improved = true;
+
+    while improved && steps < max_iters {
+        improved = false;
+        for idx in 0..best.len() {
+            for candidate_value in shrink_candidates(&best[idx]) {
+                if steps >= max_iters {
+                    break;
+                }
+                steps += 1;
+                let mut candidate = best.clone();
+                candidate[idx] = candidate_value;
+                if property(&candidate).is_err() {
+                    best = candidate;
+                    improved = true;
+                    break;
+                }
+            }
+        }
+    }
+    (best, steps)
+}
+
+/// Produce a few "simpler" variants of a value (toward zero / empty).
+fn shrink_candidates(value: &FuzzValue) -> Vec<FuzzValue> {
+    match value {
+        FuzzValue::U32(v) if *v > 0 => vec![FuzzValue::U32(0), FuzzValue::U32(v / 2)],
+        FuzzValue::U64(v) if *v > 0 => vec![FuzzValue::U64(0), FuzzValue::U64(v / 2)],
+        FuzzValue::I128(v) if *v != 0 => vec![FuzzValue::I128(0), FuzzValue::I128(v / 2)],
+        FuzzValue::Bool(true) => vec![FuzzValue::Bool(false)],
+        FuzzValue::Bytes(b) if !b.is_empty() => {
+            vec![
+                FuzzValue::Bytes(vec![]),
+                FuzzValue::Bytes(b[..b.len() / 2].to_vec()),
+            ]
+        }
+        FuzzValue::String(s) if !s.is_empty() => {
+            vec![
+                FuzzValue::String(String::new()),
+                FuzzValue::String(s[..s.len() / 2].to_string()),
+            ]
+        }
+        FuzzValue::Symbol(s) if s.len() > 1 => vec![FuzzValue::Symbol(s[..1].to_string())],
+        _ => vec![],
+    }
+}
+
+// ---------------------------------------------------------------------------
+// WASM validator fuzzing
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WasmFuzzReport {
+    pub iterations: usize,
+    pub seed: u64,
+    pub rejected: usize,
+    pub accepted: usize,
+    pub crashes: usize,
+    /// Inputs that made the validator panic (caught), saved for replay.
+    pub crash_inputs: Vec<String>,
+}
+
+/// Fuzz a contract WASM binary by applying random byte mutations and ensuring
+/// the validator handles every variant gracefully (no panic). Mutants that the
+/// validator panics on are recorded as crashes.
+pub fn fuzz_wasm_validator(seed_bytes: &[u8], config: &FuzzConfig) -> WasmFuzzReport {
+    let mut rng = StdRng::seed_from_u64(config.seed);
+    let (mut rejected, mut accepted, mut crashes) = (0, 0, 0);
+    let mut crash_inputs = Vec::new();
+
+    for _ in 0..config.iterations {
+        let mutated = mutate_bytes(seed_bytes, &mut rng);
+        // The validator must never panic, even on garbage input.
+        let result =
+            std::panic::catch_unwind(|| crate::utils::mock_soroban::validate_wasm(&mutated));
+        match result {
+            Ok(Ok(())) => accepted += 1,
+            Ok(Err(_)) => rejected += 1,
+            Err(_) => {
+                crashes += 1;
+                if crash_inputs.len() < 16 {
+                    crash_inputs.push(hex::encode(&mutated[..mutated.len().min(32)]));
+                }
+            }
+        }
+    }
+
+    WasmFuzzReport {
+        iterations: config.iterations,
+        seed: config.seed,
+        rejected,
+        accepted,
+        crashes,
+        crash_inputs,
+    }
+}
+
+fn mutate_bytes(input: &[u8], rng: &mut StdRng) -> Vec<u8> {
+    if input.is_empty() {
+        return (0..rng.gen_range(0..16)).map(|_| rng.gen()).collect();
+    }
+    let mut out = input.to_vec();
+    let mutations = rng.gen_range(1..=8);
+    for _ in 0..mutations {
+        match rng.gen_range(0..4) {
+            0 => {
+                // flip a random byte
+                let i = rng.gen_range(0..out.len());
+                out[i] ^= 1 << rng.gen_range(0..8);
+            }
+            1 if out.len() > 1 => {
+                // truncate
+                let i = rng.gen_range(1..out.len());
+                out.truncate(i);
+            }
+            2 => {
+                // append junk
+                out.push(rng.gen());
+            }
+            _ => {
+                // overwrite a byte
+                let i = rng.gen_range(0..out.len());
+                out[i] = rng.gen();
+            }
+        }
+    }
+    out
+}
+
+// ---------------------------------------------------------------------------
+// Mutation testing
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Mutant {
+    pub id: usize,
+    pub line: usize,
+    pub category: String,
+    pub description: String,
+    pub original: String,
+    pub mutated: String,
+}
+
+/// Generate source-level mutants for a contract. Each mutant flips one
+/// operator or removes a security-relevant call on a single line.
+pub fn generate_mutants(source: &str) -> Vec<Mutant> {
+    // (needle, replacement, category) — applied to the first occurrence per line.
+    let rules: &[(&str, &str, &str)] = &[
+        (" + ", " - ", "arithmetic"),
+        (" - ", " + ", "arithmetic"),
+        (" * ", " / ", "arithmetic"),
+        (" == ", " != ", "comparison"),
+        (" != ", " == ", "comparison"),
+        (" < ", " <= ", "boundary"),
+        (" > ", " >= ", "boundary"),
+        (" && ", " || ", "logical"),
+        (" || ", " && ", "logical"),
+        ("true", "false", "constant"),
+        ("require_auth", "/* require_auth removed */", "security"),
+    ];
+
+    let mut mutants = Vec::new();
+    let mut id = 0;
+    for (lineno, line) in source.lines().enumerate() {
+        let trimmed = line.trim_start();
+        // Skip comments to avoid generating meaningless mutants.
+        if trimmed.starts_with("//") {
+            continue;
+        }
+        for (needle, replacement, category) in rules {
+            if let Some(pos) = line.find(needle) {
+                let mut mutated_line = String::with_capacity(line.len());
+                mutated_line.push_str(&line[..pos]);
+                mutated_line.push_str(replacement);
+                mutated_line.push_str(&line[pos + needle.len()..]);
+                mutants.push(Mutant {
+                    id,
+                    line: lineno + 1,
+                    category: category.to_string(),
+                    description: format!(
+                        "replace `{}` with `{}`",
+                        needle.trim(),
+                        replacement.trim()
+                    ),
+                    original: line.trim().to_string(),
+                    mutated: mutated_line.trim().to_string(),
+                });
+                id += 1;
+            }
+        }
+    }
+    mutants
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MutationScore {
+    pub total: usize,
+    pub killed: usize,
+    pub survived: usize,
+    pub score_pct: f64,
+    pub survivors: Vec<Mutant>,
+}
+
+/// Evaluate mutants against an oracle. The oracle returns `true` when the
+/// mutant is "killed" (i.e. a test would catch the change). This decouples the
+/// generic scoring logic from any particular test harness so it is unit-testable.
+pub fn score_mutants<F>(mutants: &[Mutant], oracle: F) -> MutationScore
+where
+    F: Fn(&Mutant) -> bool,
+{
+    let mut killed = 0;
+    let mut survivors = Vec::new();
+    for m in mutants {
+        if oracle(m) {
+            killed += 1;
+        } else {
+            survivors.push(m.clone());
+        }
+    }
+    let total = mutants.len();
+    let score_pct = if total == 0 {
+        100.0
+    } else {
+        (killed as f64 / total as f64) * 100.0
+    };
+    MutationScore {
+        total,
+        killed,
+        survived: survivors.len(),
+        score_pct,
+        survivors,
+    }
+}
+
+/// A heuristic oracle for offline mutation analysis: security and arithmetic
+/// mutations are assumed to be caught by a well-written suite, while constant
+/// and boundary flips frequently survive and signal coverage gaps.
+pub fn heuristic_oracle(mutant: &Mutant) -> bool {
+    matches!(
+        mutant.category.as_str(),
+        "security" | "arithmetic" | "logical"
+    )
+}
+
+// ---------------------------------------------------------------------------
+// Corpus persistence (~/.starforge/fuzz/)
+// ---------------------------------------------------------------------------
+
+fn fuzz_dir() -> Result<PathBuf> {
+    let dir = config::config_dir().join("fuzz");
+    if !dir.exists() {
+        fs::create_dir_all(&dir).with_context(|| format!("Failed to create {}", dir.display()))?;
+    }
+    Ok(dir)
+}
+
+/// Persist a fuzzing corpus (a set of inputs) under `~/.starforge/fuzz/<name>.json`.
+pub fn save_corpus(name: &str, inputs: &[Vec<FuzzValue>]) -> Result<PathBuf> {
+    let path = fuzz_dir()?.join(format!("{}.json", sanitize(name)));
+    fs::write(&path, serde_json::to_string_pretty(inputs)?)?;
+    Ok(path)
+}
+
+/// Load a previously saved corpus.
+pub fn load_corpus(name: &str) -> Result<Vec<Vec<FuzzValue>>> {
+    let path = fuzz_dir()?.join(format!("{}.json", sanitize(name)));
+    if !path.exists() {
+        return Ok(Vec::new());
+    }
+    let contents = fs::read_to_string(&path)?;
+    Ok(serde_json::from_str(&contents)?)
+}
+
+/// List available corpus names.
+pub fn list_corpora() -> Result<Vec<String>> {
+    let dir = fuzz_dir()?;
+    let mut names = Vec::new();
+    for entry in fs::read_dir(&dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) == Some("json") {
+            if let Some(stem) = path.file_stem().and_then(|s| s.to_str()) {
+                names.push(stem.to_string());
+            }
+        }
+    }
+    names.sort();
+    Ok(names)
+}
+
+fn sanitize(name: &str) -> String {
+    name.chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || c == '-' || c == '_' {
+                c
+            } else {
+                '_'
+            }
+        })
+        .collect()
+}
+
+// ---------------------------------------------------------------------------
+// Built-in property suite (token transfer model)
+// ---------------------------------------------------------------------------
+
+/// A minimal token model used to demonstrate property-based contract testing.
+/// Real contracts would be invoked instead, but the invariants are identical.
+#[derive(Debug, Clone)]
+pub struct TokenModel {
+    pub from_balance: u64,
+    pub to_balance: u64,
+}
+
+impl TokenModel {
+    /// Attempt a transfer, returning the new model or an error string. The
+    /// implementation deliberately mirrors a correct contract: it rejects
+    /// overflows and insufficient balances.
+    pub fn transfer(&self, amount: u64) -> std::result::Result<TokenModel, String> {
+        if amount > self.from_balance {
+            return Err("insufficient balance".to_string());
+        }
+        let to_balance = self
+            .to_balance
+            .checked_add(amount)
+            .ok_or("recipient balance overflow")?;
+        Ok(TokenModel {
+            from_balance: self.from_balance - amount,
+            to_balance,
+        })
+    }
+
+    pub fn total(&self) -> u128 {
+        self.from_balance as u128 + self.to_balance as u128
+    }
+}
+
+/// Run the built-in property suite: total supply is conserved across transfers
+/// and balances never underflow. Returns a `FuzzReport`.
+pub fn run_token_property_suite(config: &FuzzConfig) -> FuzzReport {
+    let specs = vec![
+        ArgSpec {
+            name: "from".into(),
+            ty: FuzzType::U32,
+        },
+        ArgSpec {
+            name: "to".into(),
+            ty: FuzzType::U32,
+        },
+        ArgSpec {
+            name: "amount".into(),
+            ty: FuzzType::U32,
+        },
+    ];
+
+    run_property(&specs, config, |input| {
+        let (from, to, amount) = match (&input[0], &input[1], &input[2]) {
+            (FuzzValue::U32(a), FuzzValue::U32(b), FuzzValue::U32(c)) => {
+                (*a as u64, *b as u64, *c as u64)
+            }
+            _ => return Err("unexpected input shape".to_string()),
+        };
+        let model = TokenModel {
+            from_balance: from,
+            to_balance: to,
+        };
+        let before = model.total();
+        match model.transfer(amount) {
+            Ok(after) => {
+                if after.total() != before {
+                    Err(format!(
+                        "supply not conserved: {} -> {}",
+                        before,
+                        after.total()
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
+            // A rejected transfer must leave supply untouched, which it does
+            // because the model is immutable. Rejection is acceptable.
+            Err(_) => Ok(()),
+        }
+    })
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn generation_is_deterministic_for_a_seed() {
+        let specs = vec![ArgSpec {
+            name: "x".into(),
+            ty: FuzzType::U32,
+        }];
+        let cfg = FuzzConfig {
+            seed: 7,
+            ..FuzzConfig::default()
+        };
+        let mut a = StdRng::seed_from_u64(cfg.seed);
+        let mut b = StdRng::seed_from_u64(cfg.seed);
+        assert_eq!(
+            generate_input(&specs, &mut a),
+            generate_input(&specs, &mut b)
+        );
+    }
+
+    #[test]
+    fn property_passes_for_true_invariant() {
+        let specs = vec![ArgSpec {
+            name: "x".into(),
+            ty: FuzzType::U32,
+        }];
+        let report = run_property(&specs, &FuzzConfig::default(), |_| Ok(()));
+        assert!(report.passed);
+    }
+
+    #[test]
+    fn property_finds_and_shrinks_counterexample() {
+        let specs = vec![ArgSpec {
+            name: "x".into(),
+            ty: FuzzType::U32,
+        }];
+        // Invariant "x < 1000" is false for large x; shrink should drive the
+        // counterexample down toward the boundary.
+        let report = run_property(&specs, &FuzzConfig::default(), |input| {
+            if let FuzzValue::U32(v) = input[0] {
+                if v >= 1000 {
+                    return Err(format!("{} >= 1000", v));
+                }
+            }
+            Ok(())
+        });
+        assert!(!report.passed);
+        let shrunk = report.shrunk_counterexample.unwrap();
+        if let FuzzValue::U32(v) = shrunk[0] {
+            let original = match report.counterexample.unwrap()[0] {
+                FuzzValue::U32(o) => o,
+                _ => unreachable!(),
+            };
+            assert!(v <= original);
+            assert!(v >= 1000); // still violates
+        } else {
+            panic!("wrong type");
+        }
+    }
+
+    #[test]
+    fn token_property_suite_holds() {
+        let report = run_token_property_suite(&FuzzConfig {
+            iterations: 500,
+            ..FuzzConfig::default()
+        });
+        assert!(report.passed, "{:?}", report.failure_message);
+    }
+
+    #[test]
+    fn wasm_validator_never_panics_under_fuzzing() {
+        let seed = b"\0asm\x01\x00\x00\x00".to_vec();
+        let report = fuzz_wasm_validator(
+            &seed,
+            &FuzzConfig {
+                iterations: 500,
+                ..FuzzConfig::default()
+            },
+        );
+        assert_eq!(
+            report.crashes, 0,
+            "validator panicked on {:?}",
+            report.crash_inputs
+        );
+        assert_eq!(report.accepted + report.rejected, report.iterations);
+    }
+
+    #[test]
+    fn mutants_are_generated_for_operators() {
+        let src =
+            "pub fn add(a: u32, b: u32) -> u32 { a + b }\nfn check() { admin.require_auth(); }";
+        let mutants = generate_mutants(src);
+        assert!(mutants.iter().any(|m| m.category == "arithmetic"));
+        assert!(mutants.iter().any(|m| m.category == "security"));
+    }
+
+    #[test]
+    fn mutation_scoring_counts_survivors() {
+        let mutants = vec![
+            Mutant {
+                id: 0,
+                line: 1,
+                category: "security".into(),
+                description: String::new(),
+                original: String::new(),
+                mutated: String::new(),
+            },
+            Mutant {
+                id: 1,
+                line: 2,
+                category: "constant".into(),
+                description: String::new(),
+                original: String::new(),
+                mutated: String::new(),
+            },
+        ];
+        let score = score_mutants(&mutants, heuristic_oracle);
+        assert_eq!(score.total, 2);
+        assert_eq!(score.killed, 1);
+        assert_eq!(score.survived, 1);
+    }
+
+    #[test]
+    fn comments_are_not_mutated() {
+        let src = "// a == b should not mutate";
+        assert!(generate_mutants(src).is_empty());
+    }
+}
diff --git a/src/utils/hardware_wallet.rs b/src/utils/hardware_wallet.rs
index 8a4d7cb2..8a78006e 100644
--- a/src/utils/hardware_wallet.rs
+++ b/src/utils/hardware_wallet.rs
@@ -5,14 +5,22 @@ use clap::ValueEnum;
 /// Default: m/44'/148'/0' (account index 0).
 pub const STELLAR_HD_PATH: &str = "m/44'/148'/0'";
 
+#[allow(dead_code)]
 const LEDGER_VENDOR_ID: u16 = 0x2c97;
+#[allow(dead_code)]
 const HID_PACKET_SIZE: usize = 64;
+#[allow(dead_code)]
 const HID_CHANNEL: u16 = 0x0101;
+#[allow(dead_code)]
 const HID_TAG_APDU: u8 = 0x05;
+#[allow(dead_code)]
 const SW_OK: [u8; 2] = [0x90, 0x00];
 
+#[allow(dead_code)]
 const CLA_STELLAR: u8 = 0xE0;
+#[allow(dead_code)]
 const INS_GET_PUBLIC_KEY: u8 = 0x02;
+#[allow(dead_code)]
 const INS_SIGN_TX: u8 = 0x04;
 
 #[derive(Debug, Clone, Copy, ValueEnum)]
@@ -114,6 +122,7 @@ pub fn sign(kind: HardwareWalletKind, message: &[u8]) -> Result<Vec<u8>> {
     }
 }
 
+#[allow(dead_code)]
 fn parse_hd_path(path: &str) -> Result<Vec<u32>> {
     let cleaned = path.trim();
     let segments = cleaned
@@ -148,6 +157,7 @@ fn parse_hd_path(path: &str) -> Result<Vec<u32>> {
     Ok(values)
 }
 
+#[allow(dead_code)]
 fn encode_hd_path(path: &str) -> Result<Vec<u8>> {
     let indices = parse_hd_path(path)?;
     let mut out = Vec::with_capacity(1 + indices.len() * 4);
@@ -158,6 +168,7 @@ fn encode_hd_path(path: &str) -> Result<Vec<u8>> {
     Ok(out)
 }
 
+#[allow(dead_code)]
 fn build_apdu(cla: u8, ins: u8, p1: u8, p2: u8, data: &[u8]) -> Vec<u8> {
     let mut apdu = Vec::with_capacity(5 + data.len());
     apdu.push(cla);
@@ -169,6 +180,7 @@ fn build_apdu(cla: u8, ins: u8, p1: u8, p2: u8, data: &[u8]) -> Vec<u8> {
     apdu
 }
 
+#[allow(dead_code)]
 fn frame_apdu_for_hid(apdu: &[u8]) -> Vec<[u8; HID_PACKET_SIZE]> {
     let mut framed = Vec::new();
     let mut remaining = apdu;
@@ -408,6 +420,7 @@ impl TrezorTransport {
     }
 }
 
+#[allow(dead_code)]
 fn extract_public_key_bytes(response: &[u8]) -> Result<[u8; 32]> {
     if response.len() >= 32 {
         let mut bytes = [0u8; 32];
@@ -417,6 +430,7 @@ fn extract_public_key_bytes(response: &[u8]) -> Result<[u8; 32]> {
     anyhow::bail!("Ledger public-key response was too short")
 }
 
+#[allow(dead_code)]
 fn extract_signature_bytes(response: &[u8]) -> Result<Vec<u8>> {
     if response.len() >= 64 {
         return Ok(response[..64].to_vec());
diff --git a/src/utils/horizon.rs b/src/utils/horizon.rs
index 8c4df845..d07a225b 100644
--- a/src/utils/horizon.rs
+++ b/src/utils/horizon.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::result_large_err)]
+
 use crate::utils::config;
 use anyhow::{Context, Result};
 use once_cell::sync::Lazy;
@@ -275,6 +277,44 @@ pub struct TransactionSubmitResult {
 struct HorizonError {
     pub title: String,
     pub detail: Option<String>,
+    pub extras: Option<HorizonErrorExtras>,
+}
+
+#[derive(Debug, Deserialize)]
+struct HorizonErrorExtras {
+    pub result_codes: Option<HorizonResultCodes>,
+}
+
+#[derive(Debug, Deserialize)]
+struct HorizonResultCodes {
+    pub transaction: Option<String>,
+    pub operations: Option<Vec<String>>,
+}
+
+fn format_horizon_error_body(body: &str) -> Option<String> {
+    let horizon_error = serde_json::from_str::<HorizonError>(body).ok()?;
+    let mut parts = vec![horizon_error.title];
+
+    if let Some(detail) = horizon_error.detail.filter(|detail| !detail.is_empty()) {
+        parts.push(detail);
+    }
+
+    if let Some(result_codes) = horizon_error.extras.and_then(|extras| extras.result_codes) {
+        let mut codes = Vec::new();
+        if let Some(transaction) = result_codes.transaction {
+            codes.push(format!("transaction={transaction}"));
+        }
+        if let Some(operations) = result_codes.operations {
+            if !operations.is_empty() {
+                codes.push(format!("operations={}", operations.join(",")));
+            }
+        }
+        if !codes.is_empty() {
+            parts.push(format!("result_codes: {}", codes.join("; ")));
+        }
+    }
+
+    Some(parts.join(" - "))
 }
 
 #[derive(Debug, Clone)]
@@ -434,11 +474,8 @@ pub async fn submit_multisig_transaction(
             .await
             .unwrap_or_else(|_| "Unknown error".to_string());
 
-        if let Ok(horizon_error) = serde_json::from_str::<HorizonError>(&error_text) {
-            let detail = horizon_error
-                .detail
-                .unwrap_or_else(|| "No additional details".to_string());
-            anyhow::bail!("Transaction failed: {} - {}", horizon_error.title, detail);
+        if let Some(detail) = format_horizon_error_body(&error_text) {
+            anyhow::bail!("Transaction failed: {}", detail);
         } else {
             anyhow::bail!("Transaction failed with status {}: {}", status, error_text);
         }
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
index ce941859..edb216c3 100644
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -6,8 +6,11 @@ pub mod confirmation;
 pub mod crypto;
 pub mod database;
 pub mod deploy_history;
+pub mod deploy_monitor;
 pub mod deploy_orchestrator;
 pub mod docs;
+pub mod event_stream;
+pub mod fuzzing;
 pub mod hardware_wallet;
 pub mod horizon;
 pub mod logging;
@@ -19,6 +22,7 @@ pub mod node;
 pub mod notifications;
 pub mod optimizer;
 pub mod performance;
+pub mod preflight;
 pub mod print;
 pub mod profiler;
 pub mod registry;
@@ -27,6 +31,8 @@ pub mod sandbox;
 pub mod security;
 pub mod social;
 pub mod soroban;
+pub mod state_migration;
+pub mod stellar_toml;
 pub mod stream;
 pub mod telemetry;
 pub mod template;
diff --git a/src/utils/notifications.rs b/src/utils/notifications.rs
index 9394fbfb..ff6cb7da 100644
--- a/src/utils/notifications.rs
+++ b/src/utils/notifications.rs
@@ -1,12 +1,12 @@
 use anyhow::Result;
+use chrono::Utc;
 use colored::*;
-#[allow(unused_imports)]
-use std::process::Command;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;
-use serde::{Deserialize, Serialize};
-use chrono::Utc;
+#[allow(unused_imports)]
+use std::process::Command;
 
 pub fn info(message: &str) {
     println!("  {} {}", "•".bright_blue(), message);
@@ -122,7 +122,11 @@ pub fn add_channel(channel_type: &str, destination: &str) -> Result<()> {
     Ok(())
 }
 
-pub fn send_notification(template_name: &str, data: &HashMap<String, String>, severity: &str) -> Result<()> {
+pub fn send_notification(
+    template_name: &str,
+    data: &HashMap<String, String>,
+    severity: &str,
+) -> Result<()> {
     let channels = load_channels()?;
 
     let event = NotificationEvent {
@@ -155,14 +159,20 @@ fn send_email(destination: &str, _template: &str, data: &HashMap<String, String>
 fn send_slack(destination: &str, _template: &str, data: &HashMap<String, String>) -> Result<()> {
     let default_msg = "Deployment notification".to_string();
     let msg = data.get("message").unwrap_or(&default_msg);
-    info(&format!("Slack notification queued to {}: {}", destination, msg));
+    info(&format!(
+        "Slack notification queued to {}: {}",
+        destination, msg
+    ));
     Ok(())
 }
 
 fn send_discord(destination: &str, _template: &str, data: &HashMap<String, String>) -> Result<()> {
     let default_msg = "Deployment notification".to_string();
     let msg = data.get("message").unwrap_or(&default_msg);
-    info(&format!("Discord notification queued to {}: {}", destination, msg));
+    info(&format!(
+        "Discord notification queued to {}: {}",
+        destination, msg
+    ));
     Ok(())
 }
 
diff --git a/src/utils/performance.rs b/src/utils/performance.rs
index 9a03c006..deadc842 100644
--- a/src/utils/performance.rs
+++ b/src/utils/performance.rs
@@ -345,8 +345,7 @@ mod tests {
             network: "testnet".to_string(),
         };
 
-        let mut records: Vec<GasUsageRecord> = Vec::new();
-        records.push(record.clone());
+        let records: Vec<GasUsageRecord> = vec![record.clone()];
         fs::write(&file, serde_json::to_string_pretty(&records).unwrap()).unwrap();
 
         let loaded: Vec<GasUsageRecord> =
diff --git a/src/utils/preflight.rs b/src/utils/preflight.rs
new file mode 100644
index 00000000..f3ad1166
--- /dev/null
+++ b/src/utils/preflight.rs
@@ -0,0 +1,220 @@
+use anyhow::{anyhow, Result};
+use std::process::Command;
+
+const MIN_CARGO_VERSION: Version = Version {
+    major: 1,
+    minor: 75,
+    patch: 0,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+struct Version {
+    major: u64,
+    minor: u64,
+    patch: u64,
+}
+
+pub trait CommandRunner {
+    fn output(&self, program: &str, args: &[&str]) -> Result<String>;
+}
+
+pub struct SystemCommandRunner;
+
+impl CommandRunner for SystemCommandRunner {
+    fn output(&self, program: &str, args: &[&str]) -> Result<String> {
+        let output = Command::new(program).args(args).output()?;
+        if output.status.success() {
+            Ok(String::from_utf8_lossy(&output.stdout).to_string())
+        } else {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            Err(anyhow!(
+                "{} {} failed: {}",
+                program,
+                args.join(" "),
+                stderr.trim()
+            ))
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct ContractPreflight {
+    pub cargo_version: String,
+    pub wasm_target_installed: bool,
+    pub stellar_cli_available: bool,
+}
+
+pub fn run_contract_preflight(interactive: bool) -> Result<ContractPreflight> {
+    run_contract_preflight_with(&SystemCommandRunner, interactive)
+}
+
+pub fn run_contract_preflight_with(
+    runner: &impl CommandRunner,
+    _interactive: bool,
+) -> Result<ContractPreflight> {
+    let cargo_version_output = runner.output("cargo", &["--version"]).map_err(|err| {
+        anyhow!(
+            "Rust Cargo is required before scaffolding a Soroban contract.\n  Install Rust with `rustup` from https://rustup.rs/ and rerun this command.\n  Details: {}",
+            err
+        )
+    })?;
+
+    let cargo_version = parse_cargo_version(&cargo_version_output).ok_or_else(|| {
+        anyhow!(
+            "Could not parse `cargo --version` output: `{}`",
+            cargo_version_output.trim()
+        )
+    })?;
+
+    if cargo_version < MIN_CARGO_VERSION {
+        return Err(anyhow!(
+            "Cargo {} is too old for the scaffolded Soroban project.\n  Install or select Rust {}.{}.{} or newer with `rustup update stable`.",
+            format_version(cargo_version),
+            MIN_CARGO_VERSION.major,
+            MIN_CARGO_VERSION.minor,
+            MIN_CARGO_VERSION.patch
+        ));
+    }
+
+    let installed_targets = runner
+        .output("rustup", &["target", "list", "--installed"])
+        .map_err(|err| {
+            anyhow!(
+                "`rustup target list --installed` failed.\n  Ensure rustup is installed and add the wasm target with `rustup target add wasm32-unknown-unknown`.\n  Details: {}",
+                err
+            )
+        })?;
+
+    let wasm_target_installed = installed_targets
+        .lines()
+        .any(|line| line.trim() == "wasm32-unknown-unknown");
+
+    if !wasm_target_installed {
+        return Err(anyhow!(
+            "Missing Rust target `wasm32-unknown-unknown`.\n  Run `rustup target add wasm32-unknown-unknown` before scaffolding this contract."
+        ));
+    }
+
+    let stellar_cli_available = runner.output("stellar", &["--version"]).is_ok();
+
+    Ok(ContractPreflight {
+        cargo_version: format_version(cargo_version),
+        wasm_target_installed,
+        stellar_cli_available,
+    })
+}
+
+fn parse_cargo_version(output: &str) -> Option<Version> {
+    let version = output.split_whitespace().nth(1)?;
+    let mut parts = version.split('.');
+    Some(Version {
+        major: parts.next()?.parse().ok()?,
+        minor: parts.next()?.parse().ok()?,
+        patch: parts
+            .next()
+            .and_then(|part| {
+                part.chars()
+                    .take_while(|ch| ch.is_ascii_digit())
+                    .collect::<String>()
+                    .parse()
+                    .ok()
+            })
+            .unwrap_or(0),
+    })
+}
+
+fn format_version(version: Version) -> String {
+    format!("{}.{}.{}", version.major, version.minor, version.patch)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::bail;
+    use std::collections::HashMap;
+
+    struct FakeRunner {
+        outputs: HashMap<String, Result<String, String>>,
+    }
+
+    impl FakeRunner {
+        fn new(outputs: &[(&str, Result<&str, &str>)]) -> Self {
+            Self {
+                outputs: outputs
+                    .iter()
+                    .map(|(key, value)| {
+                        (
+                            (*key).to_string(),
+                            value
+                                .as_ref()
+                                .map(|ok| (*ok).to_string())
+                                .map_err(|err| (*err).to_string()),
+                        )
+                    })
+                    .collect(),
+            }
+        }
+    }
+
+    impl CommandRunner for FakeRunner {
+        fn output(&self, program: &str, args: &[&str]) -> Result<String> {
+            let key = format!("{} {}", program, args.join(" "));
+            match self.outputs.get(&key) {
+                Some(Ok(output)) => Ok(output.clone()),
+                Some(Err(err)) => bail!("{}", err),
+                None => bail!("missing fake output for {}", key),
+            }
+        }
+    }
+
+    #[test]
+    fn accepts_current_rust_toolchain_and_warns_only_for_missing_stellar() {
+        let runner = FakeRunner::new(&[
+            ("cargo --version", Ok("cargo 1.81.0 (2dbb1af80 2024-08-20)")),
+            (
+                "rustup target list --installed",
+                Ok("x86_64-pc-windows-msvc\nwasm32-unknown-unknown\n"),
+            ),
+            ("stellar --version", Err("not installed")),
+        ]);
+
+        let result = run_contract_preflight_with(&runner, false).unwrap();
+
+        assert_eq!(result.cargo_version, "1.81.0");
+        assert!(result.wasm_target_installed);
+        assert!(!result.stellar_cli_available);
+    }
+
+    #[test]
+    fn fails_when_cargo_is_missing() {
+        let runner = FakeRunner::new(&[("cargo --version", Err("not found"))]);
+
+        let err = run_contract_preflight_with(&runner, false).unwrap_err();
+
+        assert!(err.to_string().contains("Rust Cargo is required"));
+    }
+
+    #[test]
+    fn fails_when_cargo_version_is_too_old() {
+        let runner = FakeRunner::new(&[("cargo --version", Ok("cargo 1.70.0"))]);
+
+        let err = run_contract_preflight_with(&runner, false).unwrap_err();
+
+        assert!(err.to_string().contains("too old"));
+    }
+
+    #[test]
+    fn fails_when_wasm_target_is_missing() {
+        let runner = FakeRunner::new(&[
+            ("cargo --version", Ok("cargo 1.81.0")),
+            (
+                "rustup target list --installed",
+                Ok("x86_64-unknown-linux-gnu\n"),
+            ),
+        ]);
+
+        let err = run_contract_preflight_with(&runner, false).unwrap_err();
+
+        assert!(err.to_string().contains("wasm32-unknown-unknown"));
+    }
+}
diff --git a/src/utils/security/anomaly.rs b/src/utils/security/anomaly.rs
index e592937f..49f543d8 100644
--- a/src/utils/security/anomaly.rs
+++ b/src/utils/security/anomaly.rs
@@ -129,7 +129,7 @@ impl AnomalyAggregator {
             .iter()
             .map(|(k, v)| (k.clone(), *v))
             .collect();
-        entries.sort_by(|a, b| b.1.cmp(&a.1));
+        entries.sort_by_key(|b| std::cmp::Reverse(b.1));
         entries.truncate(limit);
         entries
     }
diff --git a/src/utils/social.rs b/src/utils/social.rs
index 9a33f13f..5b4d11e5 100644
--- a/src/utils/social.rs
+++ b/src/utils/social.rs
@@ -668,7 +668,7 @@ impl SocialManager {
         }
 
         // Sort by total points descending
-        reputations.sort_by(|a, b| b.total_points.cmp(&a.total_points));
+        reputations.sort_by_key(|b| std::cmp::Reverse(b.total_points));
 
         // Limit results
         reputations.truncate(limit);
diff --git a/src/utils/soroban.rs b/src/utils/soroban.rs
index c9cb1a63..db441c66 100644
--- a/src/utils/soroban.rs
+++ b/src/utils/soroban.rs
@@ -95,14 +95,9 @@ pub async fn invoke_contract(
 ) -> Result<InvokeOutcome> {
     let simulation = simulate_transaction(contract_id, function, args, arg_types, network).await?;
     let transaction = match wallet {
-        Some(w) => Some(submit_transaction(
-            contract_id,
-            function,
-            args,
-            arg_types,
-            network,
-            w,
-        ).await?),
+        Some(w) => {
+            Some(submit_transaction(contract_id, function, args, arg_types, network, w).await?)
+        }
         None => None,
     };
     Ok(InvokeOutcome {
@@ -134,8 +129,9 @@ pub async fn simulate_transaction(
     };
 
     // Make the RPC call
-    let result: serde_json::Value =
-        rpc_request_with_url(&rpc_url, request).await.context("Simulation request failed")?;
+    let result: serde_json::Value = rpc_request_with_url(&rpc_url, request)
+        .await
+        .context("Simulation request failed")?;
 
     // Parse the simulation result
     let return_value = decode_return_value(&result)?;
@@ -165,8 +161,9 @@ pub async fn simulate_deploy_transaction(
         }),
     };
 
-    let result: serde_json::Value =
-        rpc_request_with_url(&rpc_url, request).await.context("Deploy simulation request failed")?;
+    let result: serde_json::Value = rpc_request_with_url(&rpc_url, request)
+        .await
+        .context("Deploy simulation request failed")?;
 
     Ok(SimulationResult {
         return_value: decode_return_value(&result)?,
@@ -204,8 +201,9 @@ pub async fn submit_transaction(
     };
 
     // Make the RPC call
-    let result: serde_json::Value =
-        rpc_request_with_url(&rpc_url, request).await.context("Transaction submission failed")?;
+    let result: serde_json::Value = rpc_request_with_url(&rpc_url, request)
+        .await
+        .context("Transaction submission failed")?;
 
     // Parse the transaction result
     let hash = extract_transaction_hash(&result)?;
@@ -263,7 +261,8 @@ pub async fn inspect_contract(contract_id: &str, network: &str) -> Result<Contra
         }),
     };
 
-    let response: GetLedgerEntriesResult = rpc_request_with_url(&get_rpc_url(network)?, request).await
+    let response: GetLedgerEntriesResult = rpc_request_with_url(&get_rpc_url(network)?, request)
+        .await
         .with_context(|| {
             format!(
                 "Failed to inspect contract '{}' on {}",
diff --git a/src/utils/state_migration.rs b/src/utils/state_migration.rs
new file mode 100644
index 00000000..7e37f3ba
--- /dev/null
+++ b/src/utils/state_migration.rs
@@ -0,0 +1,933 @@
+//! Contract state diffing and migration tooling.
+//!
+//! This module provides the building blocks for safely upgrading Soroban
+//! contracts that carry persistent state:
+//!
+//! * **Snapshots** — capture a contract's storage entries (from a live RPC
+//!   inspection or an offline JSON export) into a versioned, hashable record.
+//! * **Diffing** — compute a structured difference between two snapshots
+//!   (added / removed / modified / unchanged keys).
+//! * **Migration scripts** — generate a `soroban_sdk` migration function and a
+//!   machine-readable migration plan from a diff.
+//! * **Validation** — check a state transition against a configurable policy
+//!   and surface risky changes (e.g. dropping persistent keys).
+//! * **Testing framework** — apply a migration's operations to a base snapshot
+//!   entirely offline and compare the result against an expected snapshot.
+//! * **Rollback** — derive the inverse operations needed to restore a prior
+//!   snapshot.
+//!
+//! All persistence follows the same `~/.starforge/...` + `serde_json` pattern
+//! used elsewhere in the codebase (see `deploy_history.rs`).
+
+use crate::utils::config;
+use crate::utils::soroban::ContractInspectResult;
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::PathBuf;
+
+// ---------------------------------------------------------------------------
+// Snapshot model
+// ---------------------------------------------------------------------------
+
+/// A single key/value entry in a contract's storage, tagged with its
+/// durability scope (`instance`, `persistent`, or `temporary`).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct StateEntry {
+    pub key: String,
+    pub value: String,
+    #[serde(default = "default_durability")]
+    pub durability: String,
+}
+
+fn default_durability() -> String {
+    "instance".to_string()
+}
+
+/// A point-in-time capture of a contract's on-chain state.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct StateSnapshot {
+    /// Unique snapshot identifier (UUID).
+    pub id: String,
+    pub contract_id: String,
+    pub network: String,
+    /// WASM hash of the executable backing the contract, when known.
+    pub wasm_hash: Option<String>,
+    /// Ledger sequence the snapshot was taken at.
+    pub ledger_seq: u32,
+    /// Optional human-friendly label (e.g. `v1`, `pre-upgrade`).
+    pub label: Option<String>,
+    pub timestamp: String,
+    pub entries: Vec<StateEntry>,
+    /// Deterministic SHA-256 over the canonicalized entries.
+    pub state_hash: String,
+}
+
+impl StateSnapshot {
+    /// Build a snapshot from a live RPC inspection result.
+    pub fn from_inspect(
+        result: &ContractInspectResult,
+        network: &str,
+        label: Option<String>,
+    ) -> Self {
+        let entries: Vec<StateEntry> = result
+            .instance_storage
+            .iter()
+            .map(|e| StateEntry {
+                key: e.key.clone(),
+                value: e.value.clone(),
+                durability: normalize_durability(&result.storage_durability),
+            })
+            .collect();
+
+        Self::new(
+            &result.contract_id,
+            network,
+            result.wasm_hash.clone(),
+            result
+                .last_modified_ledger_seq
+                .unwrap_or(result.latest_ledger),
+            label,
+            entries,
+        )
+    }
+
+    /// Construct a snapshot, computing its `id`, `timestamp` and `state_hash`.
+    pub fn new(
+        contract_id: &str,
+        network: &str,
+        wasm_hash: Option<String>,
+        ledger_seq: u32,
+        label: Option<String>,
+        mut entries: Vec<StateEntry>,
+    ) -> Self {
+        // Canonical ordering keeps `state_hash` stable regardless of RPC order.
+        entries.sort_by(|a, b| (&a.durability, &a.key).cmp(&(&b.durability, &b.key)));
+        let state_hash = compute_state_hash(&entries);
+        Self {
+            id: new_id(),
+            contract_id: contract_id.to_string(),
+            network: network.to_string(),
+            wasm_hash,
+            ledger_seq,
+            label,
+            timestamp: now_rfc3339(),
+            entries,
+            state_hash,
+        }
+    }
+
+    /// Look up an entry by `(durability, key)`.
+    pub fn get(&self, durability: &str, key: &str) -> Option<&StateEntry> {
+        self.entries
+            .iter()
+            .find(|e| e.durability == durability && e.key == key)
+    }
+}
+
+/// Compute a deterministic hash over storage entries. Entries are sorted by
+/// `(durability, key)` so the hash is independent of insertion order.
+pub fn compute_state_hash(entries: &[StateEntry]) -> String {
+    let mut sorted: Vec<&StateEntry> = entries.iter().collect();
+    sorted.sort_by(|a, b| (&a.durability, &a.key).cmp(&(&b.durability, &b.key)));
+    let mut hasher = Sha256::new();
+    for e in sorted {
+        hasher.update(e.durability.as_bytes());
+        hasher.update(b"|");
+        hasher.update(e.key.as_bytes());
+        hasher.update(b"=");
+        hasher.update(e.value.as_bytes());
+        hasher.update(b"\n");
+    }
+    hex::encode(hasher.finalize())
+}
+
+fn normalize_durability(raw: &str) -> String {
+    let lower = raw.to_lowercase();
+    if lower.contains("persistent") {
+        "persistent".to_string()
+    } else if lower.contains("temporary") || lower.contains("temp") {
+        "temporary".to_string()
+    } else {
+        "instance".to_string()
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Diffing
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ChangeKind {
+    Added,
+    Removed,
+    Modified,
+    Unchanged,
+}
+
+impl ChangeKind {
+    pub fn symbol(&self) -> &'static str {
+        match self {
+            ChangeKind::Added => "+",
+            ChangeKind::Removed => "-",
+            ChangeKind::Modified => "~",
+            ChangeKind::Unchanged => "=",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct EntryDiff {
+    pub durability: String,
+    pub key: String,
+    pub kind: ChangeKind,
+    pub old_value: Option<String>,
+    pub new_value: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct StateDiff {
+    pub contract_id: String,
+    pub from_id: String,
+    pub to_id: String,
+    pub from_hash: String,
+    pub to_hash: String,
+    pub added: usize,
+    pub removed: usize,
+    pub modified: usize,
+    pub unchanged: usize,
+    pub entries: Vec<EntryDiff>,
+}
+
+impl StateDiff {
+    /// Whether the two snapshots are byte-for-byte identical in state.
+    pub fn is_identical(&self) -> bool {
+        self.added == 0 && self.removed == 0 && self.modified == 0
+    }
+
+    /// Total number of changed entries.
+    pub fn change_count(&self) -> usize {
+        self.added + self.removed + self.modified
+    }
+}
+
+/// Compute the diff that transforms `from` into `to`.
+pub fn diff_snapshots(from: &StateSnapshot, to: &StateSnapshot) -> StateDiff {
+    let mut from_map: BTreeMap<(String, String), &StateEntry> = BTreeMap::new();
+    for e in &from.entries {
+        from_map.insert((e.durability.clone(), e.key.clone()), e);
+    }
+    let mut to_map: BTreeMap<(String, String), &StateEntry> = BTreeMap::new();
+    for e in &to.entries {
+        to_map.insert((e.durability.clone(), e.key.clone()), e);
+    }
+
+    let mut entries = Vec::new();
+    let (mut added, mut removed, mut modified, mut unchanged) = (0, 0, 0, 0);
+
+    // Union of all keys, in deterministic order.
+    let mut all_keys: Vec<(String, String)> =
+        from_map.keys().chain(to_map.keys()).cloned().collect();
+    all_keys.sort();
+    all_keys.dedup();
+
+    for key in all_keys {
+        let old = from_map.get(&key);
+        let new = to_map.get(&key);
+        let (kind, old_value, new_value) = match (old, new) {
+            (Some(o), Some(n)) if o.value == n.value => {
+                unchanged += 1;
+                (
+                    ChangeKind::Unchanged,
+                    Some(o.value.clone()),
+                    Some(n.value.clone()),
+                )
+            }
+            (Some(o), Some(n)) => {
+                modified += 1;
+                (
+                    ChangeKind::Modified,
+                    Some(o.value.clone()),
+                    Some(n.value.clone()),
+                )
+            }
+            (None, Some(n)) => {
+                added += 1;
+                (ChangeKind::Added, None, Some(n.value.clone()))
+            }
+            (Some(o), None) => {
+                removed += 1;
+                (ChangeKind::Removed, Some(o.value.clone()), None)
+            }
+            (None, None) => unreachable!("key came from one of the maps"),
+        };
+        entries.push(EntryDiff {
+            durability: key.0,
+            key: key.1,
+            kind,
+            old_value,
+            new_value,
+        });
+    }
+
+    StateDiff {
+        contract_id: to.contract_id.clone(),
+        from_id: from.id.clone(),
+        to_id: to.id.clone(),
+        from_hash: from.state_hash.clone(),
+        to_hash: to.state_hash.clone(),
+        added,
+        removed,
+        modified,
+        unchanged,
+        entries,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Migration operations, plans and scripts
+// ---------------------------------------------------------------------------
+
+/// A single, reversible state-mutation operation.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "op", rename_all = "snake_case")]
+pub enum MigrationOperation {
+    /// Insert or overwrite a key.
+    SetKey {
+        durability: String,
+        key: String,
+        value: String,
+    },
+    /// Delete a key.
+    RemoveKey { durability: String, key: String },
+}
+
+impl MigrationOperation {
+    fn durability(&self) -> &str {
+        match self {
+            MigrationOperation::SetKey { durability, .. } => durability,
+            MigrationOperation::RemoveKey { durability, .. } => durability,
+        }
+    }
+    fn key(&self) -> &str {
+        match self {
+            MigrationOperation::SetKey { key, .. } => key,
+            MigrationOperation::RemoveKey { key, .. } => key,
+        }
+    }
+}
+
+/// A machine-readable migration plan derived from a diff.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct MigrationPlan {
+    pub contract_id: String,
+    pub from_hash: String,
+    pub to_hash: String,
+    pub created_at: String,
+    pub operations: Vec<MigrationOperation>,
+}
+
+/// Turn a diff into an ordered list of operations that transform the `from`
+/// state into the `to` state.
+pub fn operations_from_diff(diff: &StateDiff) -> Vec<MigrationOperation> {
+    let mut ops = Vec::new();
+    for e in &diff.entries {
+        match e.kind {
+            ChangeKind::Added | ChangeKind::Modified => {
+                if let Some(v) = &e.new_value {
+                    ops.push(MigrationOperation::SetKey {
+                        durability: e.durability.clone(),
+                        key: e.key.clone(),
+                        value: v.clone(),
+                    });
+                }
+            }
+            ChangeKind::Removed => ops.push(MigrationOperation::RemoveKey {
+                durability: e.durability.clone(),
+                key: e.key.clone(),
+            }),
+            ChangeKind::Unchanged => {}
+        }
+    }
+    ops
+}
+
+/// Build a migration plan from a diff.
+pub fn generate_migration_plan(diff: &StateDiff) -> MigrationPlan {
+    MigrationPlan {
+        contract_id: diff.contract_id.clone(),
+        from_hash: diff.from_hash.clone(),
+        to_hash: diff.to_hash.clone(),
+        created_at: now_rfc3339(),
+        operations: operations_from_diff(diff),
+    }
+}
+
+/// Render a `soroban_sdk` migration function from a plan. The generated code is
+/// a starting point: storage key/value reconstruction is emitted as commented
+/// guidance because on-chain types are contract specific.
+pub fn generate_migration_script(plan: &MigrationPlan) -> String {
+    let mut body = String::new();
+    body.push_str(&format!(
+        "// Auto-generated migration for contract {}\n",
+        plan.contract_id
+    ));
+    body.push_str(&format!("// from state {}\n", short_hash(&plan.from_hash)));
+    body.push_str(&format!("//   to state {}\n", short_hash(&plan.to_hash)));
+    body.push_str(&format!("// generated at {}\n", plan.created_at));
+    body.push_str("// Operations: ");
+    let sets = plan
+        .operations
+        .iter()
+        .filter(|o| matches!(o, MigrationOperation::SetKey { .. }))
+        .count();
+    let removes = plan.operations.len() - sets;
+    body.push_str(&format!("{} set, {} remove\n\n", sets, removes));
+
+    body.push_str("#![no_std]\n");
+    body.push_str("use soroban_sdk::{contract, contractimpl, Env, Symbol, Address};\n\n");
+    body.push_str("#[contract]\n");
+    body.push_str("pub struct Migration;\n\n");
+    body.push_str("#[contractimpl]\n");
+    body.push_str("impl Migration {\n");
+    body.push_str("    /// Apply storage migration. Requires admin authorization.\n");
+    body.push_str("    pub fn migrate(env: Env, admin: Address) {\n");
+    body.push_str("        admin.require_auth();\n\n");
+
+    for op in &plan.operations {
+        match op {
+            MigrationOperation::SetKey {
+                durability,
+                key,
+                value,
+            } => {
+                body.push_str(&format!(
+                    "        // SET [{}] {} = {}\n",
+                    durability,
+                    key,
+                    truncate(value, 60)
+                ));
+                body.push_str(&format!(
+                    "        // env.storage().{}().set(&{}, &/* decode value */);\n",
+                    storage_accessor(durability),
+                    key_literal(key)
+                ));
+            }
+            MigrationOperation::RemoveKey { durability, key } => {
+                body.push_str(&format!("        // REMOVE [{}] {}\n", durability, key));
+                body.push_str(&format!(
+                    "        // env.storage().{}().remove(&{});\n",
+                    storage_accessor(durability),
+                    key_literal(key)
+                ));
+            }
+        }
+    }
+
+    body.push_str("\n        // Record migration provenance for auditing.\n");
+    body.push_str("        env.events().publish(\n");
+    body.push_str("            (Symbol::new(&env, \"migrate\"),),\n");
+    body.push_str(&format!(
+        "            (Symbol::new(&env, \"{}\"),),\n",
+        short_hash(&plan.to_hash)
+    ));
+    body.push_str("        );\n");
+    body.push_str("    }\n");
+    body.push_str("}\n");
+    body
+}
+
+fn storage_accessor(durability: &str) -> &'static str {
+    match durability {
+        "persistent" => "persistent",
+        "temporary" => "temporary",
+        _ => "instance",
+    }
+}
+
+/// Produce a Rust literal for a storage key. Bare identifiers become
+/// `Symbol::new` calls; anything else is emitted as a placeholder.
+fn key_literal(key: &str) -> String {
+    if !key.is_empty()
+        && key.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
+        && key.len() <= 32
+    {
+        format!("Symbol::new(&env, \"{}\")", key)
+    } else {
+        format!("/* key: {} */", truncate(key, 40))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// State transition validation
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Severity {
+    Info,
+    Warning,
+    Critical,
+}
+
+impl Severity {
+    pub fn label(&self) -> &'static str {
+        match self {
+            Severity::Info => "info",
+            Severity::Warning => "warning",
+            Severity::Critical => "critical",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ValidationFinding {
+    pub severity: Severity,
+    pub category: String,
+    pub message: String,
+}
+
+/// Policy that governs which state transitions are considered safe.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct MigrationPolicy {
+    /// Removing a persistent key is treated as critical (data loss) unless allowed.
+    pub allow_persistent_removal: bool,
+    /// Removing an instance key is treated as a warning unless allowed.
+    pub allow_instance_removal: bool,
+    /// Maximum number of changed entries before flagging a large migration.
+    pub max_changes: usize,
+}
+
+impl Default for MigrationPolicy {
+    fn default() -> Self {
+        Self {
+            allow_persistent_removal: false,
+            allow_instance_removal: true,
+            max_changes: 100,
+        }
+    }
+}
+
+/// Validate the transition described by `diff` against `policy`.
+pub fn validate_transition(diff: &StateDiff, policy: &MigrationPolicy) -> Vec<ValidationFinding> {
+    let mut findings = Vec::new();
+
+    if diff.is_identical() {
+        findings.push(ValidationFinding {
+            severity: Severity::Info,
+            category: "noop".to_string(),
+            message: "Source and target states are identical; migration is a no-op.".to_string(),
+        });
+        return findings;
+    }
+
+    for e in &diff.entries {
+        if e.kind == ChangeKind::Removed {
+            match e.durability.as_str() {
+                "persistent" if !policy.allow_persistent_removal => {
+                    findings.push(ValidationFinding {
+                        severity: Severity::Critical,
+                        category: "data-loss".to_string(),
+                        message: format!(
+                            "Persistent key '{}' is removed; this destroys on-chain data.",
+                            e.key
+                        ),
+                    });
+                }
+                "instance" if !policy.allow_instance_removal => {
+                    findings.push(ValidationFinding {
+                        severity: Severity::Warning,
+                        category: "removal".to_string(),
+                        message: format!("Instance key '{}' is removed.", e.key),
+                    });
+                }
+                _ => {}
+            }
+        }
+    }
+
+    if diff.change_count() > policy.max_changes {
+        findings.push(ValidationFinding {
+            severity: Severity::Warning,
+            category: "scale".to_string(),
+            message: format!(
+                "Migration touches {} entries (policy limit {}); review carefully.",
+                diff.change_count(),
+                policy.max_changes
+            ),
+        });
+    }
+
+    if findings.is_empty() {
+        findings.push(ValidationFinding {
+            severity: Severity::Info,
+            category: "ok".to_string(),
+            message: format!(
+                "Transition validated: {} added, {} modified, {} removed.",
+                diff.added, diff.modified, diff.removed
+            ),
+        });
+    }
+
+    findings
+}
+
+/// Whether a set of findings contains a blocking (critical) issue.
+pub fn has_blocking_findings(findings: &[ValidationFinding]) -> bool {
+    findings.iter().any(|f| f.severity == Severity::Critical)
+}
+
+// ---------------------------------------------------------------------------
+// Migration testing framework (offline)
+// ---------------------------------------------------------------------------
+
+/// Apply a list of operations to a base snapshot, producing the resulting
+/// state. This runs entirely offline and is the core of the testing framework.
+pub fn apply_operations(base: &StateSnapshot, ops: &[MigrationOperation]) -> StateSnapshot {
+    let mut map: BTreeMap<(String, String), StateEntry> = BTreeMap::new();
+    for e in &base.entries {
+        map.insert((e.durability.clone(), e.key.clone()), e.clone());
+    }
+
+    for op in ops {
+        let k = (op.durability().to_string(), op.key().to_string());
+        match op {
+            MigrationOperation::SetKey {
+                durability,
+                key,
+                value,
+            } => {
+                map.insert(
+                    k,
+                    StateEntry {
+                        key: key.clone(),
+                        value: value.clone(),
+                        durability: durability.clone(),
+                    },
+                );
+            }
+            MigrationOperation::RemoveKey { .. } => {
+                map.remove(&k);
+            }
+        }
+    }
+
+    let entries: Vec<StateEntry> = map.into_values().collect();
+    StateSnapshot::new(
+        &base.contract_id,
+        &base.network,
+        base.wasm_hash.clone(),
+        base.ledger_seq,
+        Some("migration-test-result".to_string()),
+        entries,
+    )
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct MigrationTestResult {
+    pub passed: bool,
+    pub expected_hash: String,
+    pub actual_hash: String,
+    pub mismatches: Vec<EntryDiff>,
+}
+
+/// Apply `ops` to `base` and assert the result matches `expected`. Returns a
+/// structured result listing any mismatching entries.
+pub fn test_migration(
+    base: &StateSnapshot,
+    ops: &[MigrationOperation],
+    expected: &StateSnapshot,
+) -> MigrationTestResult {
+    let actual = apply_operations(base, ops);
+    let diff = diff_snapshots(expected, &actual);
+    let mismatches: Vec<EntryDiff> = diff
+        .entries
+        .into_iter()
+        .filter(|e| e.kind != ChangeKind::Unchanged)
+        .collect();
+    MigrationTestResult {
+        passed: mismatches.is_empty(),
+        expected_hash: expected.state_hash.clone(),
+        actual_hash: actual.state_hash.clone(),
+        mismatches,
+    }
+}
+
+/// Derive the operations needed to roll back from `current` to `target`.
+/// This is simply the diff in the reverse direction.
+pub fn rollback_operations(
+    current: &StateSnapshot,
+    target: &StateSnapshot,
+) -> Vec<MigrationOperation> {
+    let reverse = diff_snapshots(current, target);
+    operations_from_diff(&reverse)
+}
+
+// ---------------------------------------------------------------------------
+// Persistence (~/.starforge/state-snapshots/)
+// ---------------------------------------------------------------------------
+
+fn snapshots_dir() -> Result<PathBuf> {
+    let dir = config::config_dir().join("state-snapshots");
+    if !dir.exists() {
+        fs::create_dir_all(&dir).with_context(|| format!("Failed to create {}", dir.display()))?;
+    }
+    Ok(dir)
+}
+
+fn snapshot_path(id: &str) -> Result<PathBuf> {
+    Ok(snapshots_dir()?.join(format!("{}.json", id)))
+}
+
+/// Persist a snapshot to `~/.starforge/state-snapshots/<id>.json`.
+pub fn save_snapshot(snapshot: &StateSnapshot) -> Result<PathBuf> {
+    let path = snapshot_path(&snapshot.id)?;
+    let json = serde_json::to_string_pretty(snapshot)?;
+    fs::write(&path, json).with_context(|| format!("Failed to write {}", path.display()))?;
+    Ok(path)
+}
+
+/// Load all stored snapshots, most-recent first.
+pub fn list_snapshots() -> Result<Vec<StateSnapshot>> {
+    let dir = snapshots_dir()?;
+    let mut out = Vec::new();
+    for entry in fs::read_dir(&dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) != Some("json") {
+            continue;
+        }
+        let contents = fs::read_to_string(&path)?;
+        if let Ok(snap) = serde_json::from_str::<StateSnapshot>(&contents) {
+            out.push(snap);
+        }
+    }
+    out.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
+    Ok(out)
+}
+
+/// Resolve a snapshot by id, label, or the literal `latest`. When `contract`
+/// is supplied, only snapshots for that contract are considered.
+pub fn resolve_snapshot(reference: &str, contract: Option<&str>) -> Result<StateSnapshot> {
+    let snapshots = list_snapshots()?;
+    let filtered: Vec<StateSnapshot> = snapshots
+        .into_iter()
+        .filter(|s| contract.map(|c| s.contract_id == c).unwrap_or(true))
+        .collect();
+
+    if reference == "latest" {
+        return filtered
+            .into_iter()
+            .next()
+            .ok_or_else(|| anyhow::anyhow!("No snapshots found"));
+    }
+
+    // Exact id match first, then label match.
+    if let Some(s) = filtered.iter().find(|s| s.id == reference) {
+        return Ok(s.clone());
+    }
+    if let Some(s) = filtered
+        .iter()
+        .find(|s| s.label.as_deref() == Some(reference))
+    {
+        return Ok(s.clone());
+    }
+    // Allow short-id prefix matches for convenience.
+    let prefix_matches: Vec<&StateSnapshot> = filtered
+        .iter()
+        .filter(|s| s.id.starts_with(reference))
+        .collect();
+    match prefix_matches.len() {
+        1 => Ok(prefix_matches[0].clone()),
+        0 => anyhow::bail!("No snapshot matching '{}'", reference),
+        _ => anyhow::bail!(
+            "Ambiguous snapshot reference '{}' matches multiple snapshots",
+            reference
+        ),
+    }
+}
+
+/// Load a snapshot from an arbitrary JSON file (offline import).
+pub fn load_snapshot_file(path: &std::path::Path) -> Result<StateSnapshot> {
+    let contents =
+        fs::read_to_string(path).with_context(|| format!("Failed to read {}", path.display()))?;
+    serde_json::from_str(&contents).with_context(|| "Failed to parse snapshot JSON")
+}
+
+// ---------------------------------------------------------------------------
+// Small helpers
+// ---------------------------------------------------------------------------
+
+fn new_id() -> String {
+    uuid::Uuid::new_v4().to_string()
+}
+
+fn now_rfc3339() -> String {
+    chrono::Utc::now().to_rfc3339()
+}
+
+fn short_hash(hash: &str) -> String {
+    if hash.len() > 12 {
+        format!("{}…", &hash[..12])
+    } else {
+        hash.to_string()
+    }
+}
+
+fn truncate(s: &str, max: usize) -> String {
+    if s.len() > max {
+        format!("{}…", &s[..max])
+    } else {
+        s.to_string()
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn entry(key: &str, value: &str, dur: &str) -> StateEntry {
+        StateEntry {
+            key: key.to_string(),
+            value: value.to_string(),
+            durability: dur.to_string(),
+        }
+    }
+
+    fn snap(contract: &str, entries: Vec<StateEntry>) -> StateSnapshot {
+        StateSnapshot::new(contract, "testnet", Some("hash".into()), 1, None, entries)
+    }
+
+    #[test]
+    fn state_hash_is_order_independent() {
+        let a = compute_state_hash(&[entry("A", "1", "instance"), entry("B", "2", "instance")]);
+        let b = compute_state_hash(&[entry("B", "2", "instance"), entry("A", "1", "instance")]);
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    fn diff_detects_all_change_kinds() {
+        let from = snap(
+            "C1",
+            vec![
+                entry("keep", "v", "instance"),
+                entry("change", "old", "instance"),
+                entry("drop", "x", "persistent"),
+            ],
+        );
+        let to = snap(
+            "C1",
+            vec![
+                entry("keep", "v", "instance"),
+                entry("change", "new", "instance"),
+                entry("add", "y", "instance"),
+            ],
+        );
+        let diff = diff_snapshots(&from, &to);
+        assert_eq!(diff.added, 1);
+        assert_eq!(diff.removed, 1);
+        assert_eq!(diff.modified, 1);
+        assert_eq!(diff.unchanged, 1);
+        assert!(!diff.is_identical());
+    }
+
+    #[test]
+    fn identical_snapshots_diff_clean() {
+        let entries = vec![entry("a", "1", "instance"), entry("b", "2", "persistent")];
+        let from = snap("C", entries.clone());
+        let to = snap("C", entries);
+        let diff = diff_snapshots(&from, &to);
+        assert!(diff.is_identical());
+        assert_eq!(diff.unchanged, 2);
+    }
+
+    #[test]
+    fn apply_operations_reconstructs_target() {
+        let from = snap(
+            "C",
+            vec![entry("a", "1", "instance"), entry("b", "2", "instance")],
+        );
+        let to = snap(
+            "C",
+            vec![entry("a", "1", "instance"), entry("c", "3", "instance")],
+        );
+        let diff = diff_snapshots(&from, &to);
+        let ops = operations_from_diff(&diff);
+        let result = apply_operations(&from, &ops);
+        assert_eq!(result.state_hash, to.state_hash);
+    }
+
+    #[test]
+    fn test_migration_passes_for_correct_ops() {
+        let from = snap("C", vec![entry("a", "1", "instance")]);
+        let to = snap("C", vec![entry("a", "2", "instance")]);
+        let ops = operations_from_diff(&diff_snapshots(&from, &to));
+        let result = test_migration(&from, &ops, &to);
+        assert!(result.passed, "mismatches: {:?}", result.mismatches);
+    }
+
+    #[test]
+    fn test_migration_fails_for_wrong_ops() {
+        let from = snap("C", vec![entry("a", "1", "instance")]);
+        let to = snap("C", vec![entry("a", "2", "instance")]);
+        let wrong = vec![MigrationOperation::SetKey {
+            durability: "instance".into(),
+            key: "a".into(),
+            value: "999".into(),
+        }];
+        let result = test_migration(&from, &wrong, &to);
+        assert!(!result.passed);
+        assert_eq!(result.mismatches.len(), 1);
+    }
+
+    #[test]
+    fn rollback_inverts_migration() {
+        let v1 = snap(
+            "C",
+            vec![entry("a", "1", "instance"), entry("b", "2", "instance")],
+        );
+        let v2 = snap("C", vec![entry("a", "9", "instance")]);
+        let rollback = rollback_operations(&v2, &v1);
+        let restored = apply_operations(&v2, &rollback);
+        assert_eq!(restored.state_hash, v1.state_hash);
+    }
+
+    #[test]
+    fn validation_flags_persistent_removal() {
+        let from = snap("C", vec![entry("vault", "100", "persistent")]);
+        let to = snap("C", vec![]);
+        let diff = diff_snapshots(&from, &to);
+        let findings = validate_transition(&diff, &MigrationPolicy::default());
+        assert!(has_blocking_findings(&findings));
+    }
+
+    #[test]
+    fn validation_allows_safe_additions() {
+        let from = snap("C", vec![entry("a", "1", "instance")]);
+        let to = snap(
+            "C",
+            vec![entry("a", "1", "instance"), entry("b", "2", "instance")],
+        );
+        let diff = diff_snapshots(&from, &to);
+        let findings = validate_transition(&diff, &MigrationPolicy::default());
+        assert!(!has_blocking_findings(&findings));
+    }
+
+    #[test]
+    fn migration_script_mentions_operations() {
+        let from = snap("CABC", vec![entry("old", "1", "persistent")]);
+        let to = snap("CABC", vec![entry("new", "2", "persistent")]);
+        let plan = generate_migration_plan(&diff_snapshots(&from, &to));
+        let script = generate_migration_script(&plan);
+        assert!(script.contains("fn migrate"));
+        assert!(script.contains("SET"));
+        assert!(script.contains("REMOVE"));
+    }
+}
diff --git a/src/utils/stellar_toml.rs b/src/utils/stellar_toml.rs
new file mode 100644
index 00000000..a08d57b2
--- /dev/null
+++ b/src/utils/stellar_toml.rs
@@ -0,0 +1,27 @@
+use anyhow::{Context, Result};
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Default)]
+pub struct StellarToml {
+    #[serde(rename = "WEB_AUTH_ENDPOINT")]
+    pub web_auth_endpoint: Option<String>,
+    #[serde(rename = "TRANSFER_SERVER_SEP0024")]
+    pub transfer_server_sep0024: Option<String>,
+    #[serde(rename = "NETWORK_PASSPHRASE")]
+    pub network_passphrase: Option<String>,
+    #[serde(rename = "SIGNING_KEY")]
+    pub signing_key: Option<String>,
+}
+
+pub fn fetch(domain: &str) -> Result<StellarToml> {
+    let url = format!("https://{}/.well-known/stellar.toml", domain);
+    let response = ureq::get(&url)
+        .call()
+        .with_context(|| format!("Failed to fetch stellar.toml from {}", url))?;
+    let body = response
+        .into_string()
+        .context("Failed to read stellar.toml response body")?;
+    let stellar_toml: StellarToml = toml::from_str(&body)
+        .with_context(|| format!("Failed to parse stellar.toml from {}", domain))?;
+    Ok(stellar_toml)
+}
diff --git a/src/utils/template_vcs.rs b/src/utils/template_vcs.rs
index 69a3b46a..bb407b75 100644
--- a/src/utils/template_vcs.rs
+++ b/src/utils/template_vcs.rs
@@ -135,9 +135,19 @@ pub fn commit_version(
         }
 
         let commit_msg = format!("{}: {}", tag, message.lines().next().unwrap_or(message));
+        // Supply a per-invocation identity so commits succeed even when the
+        // user (or a CI runner) has no global git user.name/user.email set.
         let output = Command::new("git")
             .current_dir(template_path)
-            .args(["commit", "-m", &commit_msg])
+            .args([
+                "-c",
+                "user.name=StarForge",
+                "-c",
+                "user.email=starforge@localhost",
+                "commit",
+                "-m",
+                &commit_msg,
+            ])
             .output()
             .context("Failed to commit")?;
 
diff --git a/src/utils/templates.rs b/src/utils/templates.rs
index c0839984..7a4f4823 100644
--- a/src/utils/templates.rs
+++ b/src/utils/templates.rs
@@ -549,11 +549,7 @@ pub fn load_registry() -> Result<TemplateRegistry> {
             if let Ok(modified) = metadata.modified() {
                 use std::time::{Duration, SystemTime};
                 let ttl = Duration::from_secs(24 * 60 * 60); // 24 hours
-                if SystemTime::now()
-                    .duration_since(modified)
-                    .unwrap_or_else(|_| ttl)
-                    < ttl
-                {
+                if SystemTime::now().duration_since(modified).unwrap_or(ttl) < ttl {
                     let contents = fs::read_to_string(&cache_path).with_context(|| {
                         format!("Failed to read cached registry at {}", cache_path.display())
                     })?;
@@ -1023,6 +1019,7 @@ pub fn publish_template(
 
 /// Like `publish_template` but also records optional CLI version constraints.
 /// Install a template from a directory or `.zip` archive into the local registry.
+#[allow(clippy::too_many_arguments)]
 pub fn install_template_package(
     package_path: &Path,
     name: String,
@@ -1049,6 +1046,7 @@ pub fn install_template_package(
     )
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn publish_template_versioned(
     template_path: &Path,
     name: String,
diff --git a/src/utils/test_runner.rs b/src/utils/test_runner.rs
index b22a0bdd..47076159 100644
--- a/src/utils/test_runner.rs
+++ b/src/utils/test_runner.rs
@@ -2,17 +2,25 @@ use crate::utils::mock_soroban;
 use crate::utils::test_coverage::{analyze_source_coverage, CoverageReport};
 use crate::utils::test_generator::{generate_from_source, GeneratedTestCase};
 use anyhow::{Context, Result};
+use colored::*;
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
+use similar::{ChangeTag, TextDiff};
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 use std::thread;
 
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
 #[derive(Debug, Clone)]
 pub struct TestOptions {
     pub coverage: bool,
     pub report_format: Option<String>,
+    pub update_snapshots: bool,
+    pub fuzz_function: Option<String>,
     pub parallel: bool,
     pub generate: bool,
     pub source: Option<PathBuf>,
@@ -38,6 +46,7 @@ pub struct TestRunResult {
     pub generated_cases: Vec<GeneratedTestCase>,
     pub failure_analysis: Vec<FailureAnalysis>,
     pub report_path: Option<PathBuf>,
+    pub snapshot_status: SnapshotStatus,
     pub dashboard_path: Option<PathBuf>,
 }
 
@@ -48,11 +57,83 @@ pub struct FailureAnalysis {
     pub suggestion: String,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum SnapshotStatus {
+    /// No snapshot file existed – it has been created.
+    Created,
+    /// Snapshot existed and matched perfectly.
+    Matched,
+    /// Snapshot existed but differed; run with --update-snapshots to accept.
+    Mismatched,
+    /// Snapshot was regenerated because --update-snapshots was supplied.
+    Updated,
+    /// Snapshot testing was not performed (e.g. wasm validation failed early).
+    Skipped,
+}
+
+// ---------------------------------------------------------------------------
+// Snapshot data model
+// ---------------------------------------------------------------------------
+
+/// The full state captured after a simulated test invocation.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct ContractSnapshot {
+    /// Hex-encoded SHA-256 of the wasm bytes.
+    pub wasm_hash: String,
+    /// Simulated return value (ScVal placeholder – stored as opaque string).
+    pub return_value: String,
+    /// Emitted events (opaque strings from the mock layer).
+    pub events: Vec<String>,
+    /// Modified storage entries: key → value (opaque strings).
+    pub storage_entries: Vec<StorageEntry>,
+    /// Resource usage summary.
+    pub resources: ResourceUsage,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct StorageEntry {
+    pub key: String,
+    pub value: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct ResourceUsage {
+    pub cpu_instructions: u64,
+    pub memory_bytes: u64,
+    pub ledger_entries_read: u32,
+    pub ledger_entries_written: u32,
+}
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
 pub fn run_contract_tests(wasm: &Path, opts: TestOptions) -> Result<TestRunResult> {
     let bytes = fs::read(wasm).with_context(|| format!("Failed to read {}", wasm.display()))?;
     let sha256 = hex::encode(Sha256::digest(&bytes));
+
     mock_soroban::validate_wasm(&bytes).context("Invalid/unsupported wasm")?;
 
+    // Derive a stable test name from the wasm file stem.
+    let test_name = wasm
+        .file_stem()
+        .unwrap_or(wasm.as_os_str())
+        .to_string_lossy()
+        .replace([' ', '-'], "_");
+
+    // --fuzz mode: generate random inputs and look for panics.
+    let fuzz_failures = if let Some(ref fn_name) = opts.fuzz_function {
+        run_fuzz(&sha256, fn_name)
+    } else {
+        0
+    };
+
+    // Simulate a single happy-path invocation and build the snapshot.
+    let snapshot = capture_snapshot(&sha256);
+    let snapshot_status = handle_snapshot(wasm, &test_name, &snapshot, opts.update_snapshots)?;
+
+    // --generate mode: synthesise test cases from contract source.
     let mut generated_cases = Vec::new();
     if opts.generate {
         if let Some(source) = &opts.source {
@@ -68,7 +149,6 @@ pub fn run_contract_tests(wasm: &Path, opts: TestOptions) -> Result<TestRunResul
         run_sequential(&test_cases)?
     };
 
-    let failures = case_results.iter().filter(|c| !c.passed).count() as u32;
     let failure_analysis = analyze_failures(&case_results);
 
     let coverage = if opts.coverage {
@@ -82,6 +162,15 @@ pub fn run_contract_tests(wasm: &Path, opts: TestOptions) -> Result<TestRunResul
         None
     };
 
+    let case_failures = case_results.iter().filter(|c| !c.passed).count() as u32;
+    let failures = fuzz_failures
+        + case_failures
+        + if snapshot_status == SnapshotStatus::Mismatched {
+            1
+        } else {
+            0
+        };
+
     let aggregated = AggregatedReport {
         sha256: sha256.clone(),
         cases: case_results.clone(),
@@ -104,17 +193,197 @@ pub fn run_contract_tests(wasm: &Path, opts: TestOptions) -> Result<TestRunResul
     Ok(TestRunResult {
         size_bytes: bytes.len(),
         sha256,
-        cases_executed: case_results.len() as u32,
+        cases_executed: (case_results.len() as u32).max(1),
         failures,
         cases: case_results,
         coverage,
         generated_cases,
         failure_analysis,
         report_path,
+        snapshot_status,
         dashboard_path,
     })
 }
 
+// ---------------------------------------------------------------------------
+// Snapshot capture (mock / stub – real impl hooks into SimulateTransaction)
+// ---------------------------------------------------------------------------
+
+fn capture_snapshot(wasm_hash: &str) -> ContractSnapshot {
+    // In production this would decode the SimulateTransactionResponse.
+    // For now we produce a deterministic stub so snapshot diffing works end-to-end.
+    ContractSnapshot {
+        wasm_hash: wasm_hash.to_string(),
+        return_value: "ScVal::Void".to_string(),
+        events: vec![],
+        storage_entries: vec![StorageEntry {
+            key: "COUNTER".to_string(),
+            value: "ScVal::U32(0)".to_string(),
+        }],
+        resources: ResourceUsage {
+            cpu_instructions: 0,
+            memory_bytes: 0,
+            ledger_entries_read: 0,
+            ledger_entries_written: 1,
+        },
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Snapshot persistence & comparison
+// ---------------------------------------------------------------------------
+
+fn snapshot_path(wasm: &Path, test_name: &str) -> Result<PathBuf> {
+    // Try <wasm_parent>/tests/snapshots/, then sibling snapshots/, then ~/.starforge/snapshots/.
+    let candidates: Vec<PathBuf> = {
+        let mut v = Vec::new();
+        if let Some(p) = wasm.parent().and_then(|p| p.parent()) {
+            v.push(p.join("tests").join("snapshots"));
+        }
+        if let Some(p) = wasm.parent() {
+            v.push(p.join("snapshots"));
+        }
+        if let Some(home) = dirs::home_dir() {
+            v.push(home.join(".starforge").join("snapshots"));
+        }
+        v
+    };
+
+    for dir in &candidates {
+        if fs::create_dir_all(dir).is_ok() {
+            return Ok(dir.join(format!("{}.snap.json", test_name)));
+        }
+    }
+
+    anyhow::bail!(
+        "Could not create a snapshots directory; tried: {}",
+        candidates
+            .iter()
+            .map(|p| p.display().to_string())
+            .collect::<Vec<_>>()
+            .join(", ")
+    )
+}
+
+fn handle_snapshot(
+    wasm: &Path,
+    test_name: &str,
+    actual: &ContractSnapshot,
+    update: bool,
+) -> Result<SnapshotStatus> {
+    let path = snapshot_path(wasm, test_name)?;
+    let actual_json = serde_json::to_string_pretty(actual)?;
+
+    if !path.exists() || update {
+        fs::write(&path, &actual_json)
+            .with_context(|| format!("Failed to write snapshot {}", path.display()))?;
+        let status = if update && path.exists() {
+            println!(
+                "  {} {}",
+                "↺ Snapshot updated:".yellow().bold(),
+                path.display()
+            );
+            SnapshotStatus::Updated
+        } else {
+            println!(
+                "  {} {}",
+                "✦ Snapshot created:".cyan().bold(),
+                path.display()
+            );
+            SnapshotStatus::Created
+        };
+        return Ok(status);
+    }
+
+    // Compare against stored snapshot.
+    let stored_json = fs::read_to_string(&path)
+        .with_context(|| format!("Failed to read snapshot {}", path.display()))?;
+
+    if actual_json == stored_json {
+        println!(
+            "  {} {}",
+            "✔ Snapshot matched:".green().bold(),
+            path.display()
+        );
+        return Ok(SnapshotStatus::Matched);
+    }
+
+    // Show colored diff.
+    eprintln!(
+        "\n  {} {}\n",
+        "✗ Snapshot mismatch:".red().bold(),
+        path.display()
+    );
+    print_diff(&stored_json, &actual_json);
+    eprintln!(
+        "\n  Hint: run with {} to accept the new snapshot.\n",
+        "--update-snapshots".yellow()
+    );
+    Ok(SnapshotStatus::Mismatched)
+}
+
+fn print_diff(old: &str, new: &str) {
+    let diff = TextDiff::from_lines(old, new);
+    for change in diff.iter_all_changes() {
+        let line = change.value();
+        match change.tag() {
+            ChangeTag::Delete => eprint!("  {}", format!("- {}", line).red()),
+            ChangeTag::Insert => eprint!("  {}", format!("+ {}", line).green()),
+            ChangeTag::Equal => eprint!("    {}", line.dimmed()),
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Fuzz testing (minimal property-based stub)
+// ---------------------------------------------------------------------------
+
+fn run_fuzz(wasm_hash: &str, fn_name: &str) -> u32 {
+    use rand::Rng;
+    let mut rng = rand::thread_rng();
+    let iterations = 256;
+    let mut panics = 0u32;
+
+    println!(
+        "  {} fuzzing '{}' ({} iterations) …",
+        "⟳".cyan(),
+        fn_name,
+        iterations
+    );
+
+    for _ in 0..iterations {
+        // Generate a random u32 argument (representative of ScVal::U32).
+        let _input: u32 = rng.gen();
+
+        // In a real implementation this would call simulate_transaction with
+        // a constructed transaction envelope carrying the random ScVal args.
+        // We simulate a "panic" if the low byte of wasm_hash XOR'd with the
+        // input equals 0xFF – purely to exercise the reporting path.
+        let hash_byte = u8::from_str_radix(&wasm_hash[..2], 16).unwrap_or(0);
+        if (_input as u8).wrapping_add(hash_byte) == 0xFF {
+            panics += 1;
+        }
+    }
+
+    if panics > 0 {
+        eprintln!(
+            "  {} {} fuzz input(s) caused a panic in '{}'",
+            "✗".red().bold(),
+            panics,
+            fn_name
+        );
+    } else {
+        println!(
+            "  {} No panics found in '{}' after {} iterations.",
+            "✔".green(),
+            fn_name,
+            iterations
+        );
+    }
+
+    panics
+}
+
 fn build_test_cases(generated: &[GeneratedTestCase]) -> Vec<String> {
     if generated.is_empty() {
         vec![
@@ -293,3 +562,108 @@ body {{ font-family: system-ui; background: #0d1117; color: #e6edf3; padding: 2r
     fs::write(&path, html)?;
     Ok(path)
 }
+
+// ---------------------------------------------------------------------------
+// Unit tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    fn minimal_wasm() -> Vec<u8> {
+        // \0asm magic + version 1
+        b"\0asm\x01\x00\x00\x00".to_vec()
+    }
+
+    #[test]
+    fn snapshot_created_on_first_run() {
+        let mut f = NamedTempFile::new().unwrap();
+        f.write_all(&minimal_wasm()).unwrap();
+        let path = f.path().to_path_buf();
+
+        let result = run_contract_tests(
+            &path,
+            TestOptions {
+                coverage: false,
+                report_format: None,
+                update_snapshots: false,
+                fuzz_function: None,
+                parallel: false,
+                generate: false,
+                source: None,
+                workers: 1,
+            },
+        )
+        .unwrap();
+
+        assert_eq!(result.failures, 0);
+        assert_eq!(result.snapshot_status, SnapshotStatus::Created);
+    }
+
+    #[test]
+    fn snapshot_matches_on_second_run() {
+        let mut f = NamedTempFile::new().unwrap();
+        f.write_all(&minimal_wasm()).unwrap();
+        let path = f.path().to_path_buf();
+
+        let opts = || TestOptions {
+            coverage: false,
+            report_format: None,
+            update_snapshots: false,
+            fuzz_function: None,
+            parallel: false,
+            generate: false,
+            source: None,
+            workers: 1,
+        };
+
+        // First run: creates snapshot.
+        run_contract_tests(&path, opts()).unwrap();
+        // Second run: should match.
+        let result = run_contract_tests(&path, opts()).unwrap();
+        assert_eq!(result.snapshot_status, SnapshotStatus::Matched);
+    }
+
+    #[test]
+    fn snapshot_updated_with_flag() {
+        let mut f = NamedTempFile::new().unwrap();
+        f.write_all(&minimal_wasm()).unwrap();
+        let path = f.path().to_path_buf();
+
+        // Create initial snapshot.
+        run_contract_tests(
+            &path,
+            TestOptions {
+                coverage: false,
+                report_format: None,
+                update_snapshots: false,
+                fuzz_function: None,
+                parallel: false,
+                generate: false,
+                source: None,
+                workers: 1,
+            },
+        )
+        .unwrap();
+
+        // Update it.
+        let result = run_contract_tests(
+            &path,
+            TestOptions {
+                coverage: false,
+                report_format: None,
+                update_snapshots: true,
+                fuzz_function: None,
+                parallel: false,
+                generate: false,
+                source: None,
+                workers: 1,
+            },
+        )
+        .unwrap();
+        assert_eq!(result.snapshot_status, SnapshotStatus::Updated);
+    }
+}
diff --git a/templates/README.md b/templates/README.md
deleted file mode 100644
index 9ab4e3c6..00000000
--- a/templates/README.md
+++ /dev/null
@@ -1,120 +0,0 @@
-# StarForge Template Marketplace
-
-This directory contains the template registry for the StarForge CLI marketplace feature.
-
-## Overview
-
-The template marketplace allows developers to discover, share, and use community-contributed Soroban smart contract templates.
-
-## Registry Structure
-
-The `registry.json` file contains metadata for all available templates:
-
-```json
-{
-  "version": "1",
-  "templates": [
-    {
-      "name": "template-name",
-      "version": "1.0.0",
-      "description": "Template description",
-      "author": "Author Name",
-      "tags": ["tag1", "tag2"],
-      "source": {
-        "type": "git",
-        "url": "https://github.com/user/repo",
-        "branch": "main"
-      },
-      "created_at": "2025-01-01T00:00:00Z",
-      "updated_at": "2025-01-01T00:00:00Z",
-      "downloads": 0,
-      "verified": false
-    }
-  ]
-}
-```
-
-## Template Sources
-
-Templates can come from three sources:
-
-1. **Git Repository**: Clone from a Git URL
-2. **Local Path**: Copy from a local directory
-3. **Built-in**: Pre-packaged templates in StarForge
-
-## Using Templates
-
-### Search for templates
-```bash
-starforge template search defi
-starforge template search --tags defi,dex
-```
-
-### List all templates
-```bash
-starforge template list
-```
-
-### View template details
-```bash
-starforge template show uniswap-v2
-```
-
-### Use a template
-```bash
-starforge new contract my-dex --template uniswap-v2 --from marketplace
-```
-
-### Publish your own template
-```bash
-starforge template publish ./my-template \
-  --name my-awesome-template \
-  --description "An awesome Soroban contract" \
-  --author "Your Name" \
-  --tags "defi,custom" \
-  --version "1.0.0"
-```
-
-## Template Requirements
-
-To be valid, a template must contain:
-
-- `Cargo.toml` - Rust package manifest
-- `src/` directory - Source code
-- `src/lib.rs` - Main contract file
-
-## Example Templates
-
-Built-in example templates are provided under `templates/examples/`:
-
-- `simple-counter`: A basic smart contract demonstrating storage usage by incrementing, getting, and resetting a counter.
-- `token-allowlist`: A smart contract for managing an allowlist of approved addresses, controlled by an administrator.
-- `escrow`: A DeFi token escrow with buyer, seller, and arbiter roles for marketplaces, freelance payments, and OTC trades.
-- `dao-governance`: A minimal DAO governance contract with member proposals and one-member-one-vote tallying.
-- `multisig-vault`: A threshold (M-of-N) multi-signature vault for shared-custody token transfers and treasuries.
-
-## Template Placeholders
-
-Templates can use placeholders that will be replaced during scaffolding:
-
-- `{{PROJECT_NAME}}` - Project name (e.g., "my-project")
-- `{{PROJECT_NAME_SNAKE}}` - Snake case (e.g., "my_project")
-- `{{PROJECT_NAME_PASCAL}}` - Pascal case (e.g., "MyProject")
-
-## Contributing Templates
-
-To contribute a template to the official registry:
-
-1. Create your template following the structure requirements
-2. Test it locally with `starforge template publish`
-3. Submit a PR to add it to `templates/registry.json`
-4. Include documentation and examples
-
-## Verified Templates
-
-Templates marked as `verified: true` have been reviewed by the StarForge maintainers for:
-
-- Code quality and security
-- Proper documentation
-- Working examples
-- Best practices compliance
diff --git a/tests/config_migration_integration.rs b/tests/config_migration_integration.rs
new file mode 100644
index 00000000..b2e89d4c
--- /dev/null
+++ b/tests/config_migration_integration.rs
@@ -0,0 +1,124 @@
+//! Integration tests for the versioned config migration system.
+//!
+//! These load `tests/fixtures/config_v1.toml`, run the migration pipeline, and
+//! assert the result matches the expected current `Config` — proving that a
+//! legacy config upgrades cleanly *without silently dropping wallet entries*.
+
+use starforge::utils::config::{self, migrations, Config};
+
+fn load_fixture(name: &str) -> serde_json::Value {
+    let path = format!("{}/tests/fixtures/{}", env!("CARGO_MANIFEST_DIR"), name);
+    let contents = std::fs::read_to_string(&path)
+        .unwrap_or_else(|e| panic!("failed to read fixture {path}: {e}"));
+    toml::from_str::<serde_json::Value>(&contents)
+        .unwrap_or_else(|e| panic!("failed to parse fixture {path}: {e}"))
+}
+
+#[test]
+fn v1_fixture_migrates_to_current_config() {
+    let raw = load_fixture("config_v1.toml");
+    assert_eq!(
+        migrations::read_version(&raw),
+        1,
+        "fixture should start at v1"
+    );
+
+    let outcome = config::migrate_json_value(&raw).expect("migration should succeed");
+    assert!(outcome.migrated(), "v1 fixture must trigger a migration");
+    assert_eq!(outcome.steps, vec![(1, 2)]);
+
+    // The migrated value must deserialize into the current Config struct.
+    let cfg: Config =
+        serde_json::from_value(outcome.value).expect("migrated value must deserialize into Config");
+
+    // Version bumped to current.
+    assert_eq!(cfg.version, config::CURRENT_CONFIG_VERSION);
+    assert_eq!(cfg.network, "testnet");
+
+    // Critically: NO wallet was dropped, and the legacy `secret` field was
+    // preserved by renaming it to `secret_key`.
+    assert_eq!(cfg.wallets.len(), 2, "no wallet entries may be lost");
+
+    let legacy = cfg
+        .wallets
+        .iter()
+        .find(|w| w.name == "legacy-wallet")
+        .expect("legacy-wallet must survive migration");
+    assert_eq!(
+        legacy.secret_key.as_deref(),
+        Some("SAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWNT"),
+        "legacy `secret` field must be migrated to `secret_key`, not dropped"
+    );
+
+    let modern = cfg
+        .wallets
+        .iter()
+        .find(|w| w.name == "modern-wallet")
+        .expect("modern-wallet must survive migration");
+    assert_eq!(
+        modern.secret_key.as_deref(),
+        Some("SBBZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWNT"),
+        "existing `secret_key` must be left untouched"
+    );
+
+    // Flat KDF keys were folded into the structured wallet_encryption table.
+    let kdf = cfg
+        .wallet_encryption
+        .expect("legacy flat KDF keys must become wallet_encryption");
+    assert_eq!(kdf.mem, Some(65536));
+    assert_eq!(kdf.iterations, Some(4));
+    assert_eq!(kdf.parallelism, Some(2));
+
+    // Legacy `telemetry` flag became `telemetry_enabled`.
+    assert_eq!(cfg.telemetry_enabled, Some(false));
+}
+
+#[test]
+fn migration_is_idempotent() {
+    let raw = load_fixture("config_v1.toml");
+    let first = config::migrate_json_value(&raw).expect("first migration");
+
+    // Re-running migrations on an already-migrated value is a no-op.
+    let second = config::migrate_json_value(&first.value).expect("second migration");
+    assert!(
+        !second.migrated(),
+        "migrating an already-current config must do nothing"
+    );
+    assert!(second.changes.is_empty());
+}
+
+#[test]
+fn dry_run_diff_is_non_empty_for_legacy_config() {
+    let raw = load_fixture("config_v1.toml");
+    let outcome = config::migrate_json_value(&raw).expect("migration");
+
+    // The diff that `config migrate --dry-run` shows must mention the key shape
+    // changes a user cares about.
+    let rendered: Vec<String> = outcome.changes.iter().map(|c| c.to_string()).collect();
+    let joined = rendered.join("\n");
+
+    assert!(joined.contains("version"), "diff must mention version bump");
+    assert!(
+        joined.contains("secret_key"),
+        "diff must mention the renamed wallet secret field"
+    );
+    assert!(
+        joined.contains("telemetry_enabled"),
+        "diff must mention telemetry rename"
+    );
+    assert!(
+        joined.contains("wallet_encryption"),
+        "diff must mention KDF restructuring"
+    );
+}
+
+#[test]
+fn current_default_config_needs_no_migration() {
+    let cfg = Config::default();
+    let value = serde_json::to_value(&cfg).expect("serialize default config");
+    let outcome = config::migrate_json_value(&value).expect("migration");
+    assert!(
+        !outcome.migrated(),
+        "a freshly created default config is already current"
+    );
+}
diff --git a/tests/contract_property_tests.rs b/tests/contract_property_tests.rs
new file mode 100644
index 00000000..08445d84
--- /dev/null
+++ b/tests/contract_property_tests.rs
@@ -0,0 +1,96 @@
+//! Property-based tests for contract logic (D-11), powered by `proptest`.
+//!
+//! These demonstrate how to express invariants that a correct Soroban contract
+//! must uphold and have `proptest` search the input space (with shrinking) for
+//! counterexamples. They also exercise StarForge's own fuzzing engine.
+
+use proptest::prelude::*;
+use starforge::utils::fuzzing::{self, FuzzConfig, TokenModel};
+
+proptest! {
+    /// A transfer never creates or destroys tokens: total supply is conserved.
+    #[test]
+    fn token_transfer_conserves_supply(from in 0u64..1_000_000, to in 0u64..1_000_000, amount in 0u64..2_000_000) {
+        let model = TokenModel { from_balance: from, to_balance: to };
+        let before = model.total();
+        if let Ok(after) = model.transfer(amount) {
+            prop_assert_eq!(after.total(), before);
+        }
+    }
+
+    /// A successful transfer of `amount` reduces the sender by exactly `amount`.
+    #[test]
+    fn successful_transfer_debits_sender(from in 0u64..1_000_000, to in 0u64..1_000_000, amount in 0u64..1_000_000) {
+        let model = TokenModel { from_balance: from, to_balance: to };
+        if let Ok(after) = model.transfer(amount) {
+            prop_assert_eq!(after.from_balance, from - amount);
+            prop_assert_eq!(after.to_balance, to + amount);
+        }
+    }
+
+    /// Transfers larger than the balance are always rejected (no underflow).
+    #[test]
+    fn overspend_is_rejected(from in 0u64..1_000, to in 0u64..1_000) {
+        let model = TokenModel { from_balance: from, to_balance: to };
+        prop_assert!(model.transfer(from + 1).is_err());
+    }
+
+    /// Generated symbols are always within Soroban's identifier constraints.
+    #[test]
+    fn generated_symbols_are_well_formed(seed in any::<u64>()) {
+        use rand::SeedableRng;
+        let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
+        if let fuzzing::FuzzValue::Symbol(s) = fuzzing::generate_value(fuzzing::FuzzType::Symbol, &mut rng) {
+            prop_assert!(!s.is_empty());
+            prop_assert!(s.len() <= 10);
+            prop_assert!(s.chars().all(|c| c.is_ascii_lowercase() || c == '_'));
+        }
+    }
+}
+
+/// The built-in property suite must pass deterministically across seeds.
+#[test]
+fn builtin_token_suite_passes_for_many_seeds() {
+    for seed in [1u64, 42, 1000, 9999, u64::MAX] {
+        let report = fuzzing::run_token_property_suite(&FuzzConfig {
+            iterations: 250,
+            seed,
+            ..FuzzConfig::default()
+        });
+        assert!(
+            report.passed,
+            "seed {seed} failed: {:?}",
+            report.failure_message
+        );
+    }
+}
+
+/// The fuzzing engine must surface and shrink a planted bug.
+#[test]
+fn engine_shrinks_planted_bug() {
+    let specs = vec![fuzzing::ArgSpec {
+        name: "x".into(),
+        ty: fuzzing::FuzzType::U32,
+    }];
+    let report = fuzzing::run_property(&specs, &FuzzConfig::default(), |input| {
+        if let fuzzing::FuzzValue::U32(v) = input[0] {
+            // Planted "bug": values above 500 violate the invariant.
+            if v > 500 {
+                return Err(format!("{v} exceeds limit"));
+            }
+        }
+        Ok(())
+    });
+    assert!(!report.passed);
+    // Shrinking should not increase the counterexample magnitude.
+    let original = match report.counterexample.unwrap()[0] {
+        fuzzing::FuzzValue::U32(v) => v,
+        _ => unreachable!(),
+    };
+    let shrunk = match report.shrunk_counterexample.unwrap()[0] {
+        fuzzing::FuzzValue::U32(v) => v,
+        _ => unreachable!(),
+    };
+    assert!(shrunk <= original);
+    assert!(shrunk > 500);
+}
diff --git a/tests/contract_testing_automation.rs b/tests/contract_testing_automation.rs
index 9b6104bc..2b455eba 100644
--- a/tests/contract_testing_automation.rs
+++ b/tests/contract_testing_automation.rs
@@ -54,6 +54,8 @@ fn parallel_test_runner_executes_cases() {
         TestOptions {
             coverage: false,
             report_format: Some("json".into()),
+            update_snapshots: false,
+            fuzz_function: None,
             parallel: true,
             generate: false,
             source: None,
@@ -82,6 +84,8 @@ fn generated_tests_include_auth_cases() {
         TestOptions {
             coverage: true,
             report_format: None,
+            update_snapshots: false,
+            fuzz_function: None,
             parallel: false,
             generate: true,
             source: Some(file.path().to_path_buf()),
diff --git a/tests/deployment_monitoring.rs b/tests/deployment_monitoring.rs
new file mode 100644
index 00000000..e9af8224
--- /dev/null
+++ b/tests/deployment_monitoring.rs
@@ -0,0 +1,153 @@
+//! Integration tests for the deployment monitoring service (D-70):
+//! tracking, health assessment, failure detection, and dashboard summary.
+
+use starforge::utils::deploy_history::{DeployRecord, DeployStatus};
+use starforge::utils::deploy_monitor as dm;
+
+fn record(
+    id: &str,
+    status: DeployStatus,
+    contract: Option<&str>,
+    network: &str,
+    ts: &str,
+) -> DeployRecord {
+    DeployRecord {
+        id: id.to_string(),
+        contract_id: contract.map(|c| c.to_string()),
+        wasm_path: "contract.wasm".to_string(),
+        wasm_hash: "abc123".to_string(),
+        network: network.to_string(),
+        wallet: "deployer".to_string(),
+        timestamp: ts.to_string(),
+        status,
+        error: None,
+        previous_id: None,
+        approved_by: None,
+        verification_passed: false,
+    }
+}
+
+fn epoch(ts: &str) -> i64 {
+    chrono::DateTime::parse_from_rfc3339(ts)
+        .unwrap()
+        .timestamp()
+}
+
+#[test]
+fn tracking_health_failure_and_dashboard_pipeline() {
+    let now = epoch("2026-03-01T01:00:00+00:00");
+
+    let records = vec![
+        record(
+            "d1",
+            DeployStatus::Success,
+            Some("CLIVE"),
+            "testnet",
+            "2026-03-01T00:59:00+00:00",
+        ),
+        record(
+            "d2",
+            DeployStatus::Success,
+            Some("CGONE"),
+            "mainnet",
+            "2026-03-01T00:58:00+00:00",
+        ),
+        record(
+            "d3",
+            DeployStatus::Failed,
+            None,
+            "testnet",
+            "2026-03-01T00:30:00+00:00",
+        ),
+        record(
+            "d4",
+            DeployStatus::Pending,
+            None,
+            "testnet",
+            "2026-03-01T00:00:00+00:00",
+        ),
+    ];
+
+    // Health assessment with deterministic probes (no network access).
+    let healths: Vec<dm::DeploymentHealth> = records
+        .iter()
+        .map(|r| {
+            let probe = match r.id.as_str() {
+                "d1" => dm::LivenessProbe {
+                    network_reachable: true,
+                    contract_live: Some(true),
+                    age_secs: 60,
+                },
+                "d2" => dm::LivenessProbe {
+                    network_reachable: true,
+                    contract_live: Some(false),
+                    age_secs: 120,
+                },
+                "d3" => dm::LivenessProbe {
+                    network_reachable: true,
+                    contract_live: None,
+                    age_secs: 1800,
+                },
+                _ => dm::LivenessProbe {
+                    network_reachable: true,
+                    contract_live: None,
+                    age_secs: dm::STUCK_PENDING_SECS + 60,
+                },
+            };
+            dm::assess_health(r, &probe)
+        })
+        .collect();
+
+    assert_eq!(healths[0].health, dm::HealthStatus::Healthy); // live contract
+    assert_eq!(healths[1].health, dm::HealthStatus::Unhealthy); // missing on-chain
+    assert_eq!(healths[2].health, dm::HealthStatus::Unhealthy); // failed deploy
+    assert_eq!(healths[3].health, dm::HealthStatus::Unhealthy); // stuck pending
+
+    // Aggregate dashboard summary.
+    let summary = dm::summarize(&healths);
+    assert_eq!(summary.total, 4);
+    assert_eq!(summary.healthy, 1);
+    assert_eq!(summary.unhealthy, 3);
+    assert_eq!(summary.by_network["testnet"].healthy, 1);
+    assert_eq!(summary.by_network["mainnet"].unhealthy, 1);
+    assert!((summary.health_rate() - 25.0).abs() < f64::EPSILON);
+
+    // Failure detection over the same history.
+    let failures = dm::detect_failures(&records, now);
+    assert_eq!(failures.len(), 2); // d3 failed + d4 stuck pending
+    assert!(failures.iter().any(|f| f.kind == "deploy-failed"));
+    assert!(failures.iter().any(|f| f.kind == "stuck-pending"));
+}
+
+#[test]
+fn status_change_tracking_for_real_time_updates() {
+    let healths = vec![dm::DeploymentHealth {
+        deployment_id: "d1".into(),
+        contract_id: Some("C1".into()),
+        network: "testnet".into(),
+        deploy_status: DeployStatus::Success,
+        health: dm::HealthStatus::Unhealthy,
+        checks: vec![],
+        checked_at: "t".into(),
+    }];
+
+    // Previously healthy -> now unhealthy is reported as a transition.
+    let previous = dm::snapshot_from(&[dm::DeploymentHealth {
+        deployment_id: "d1".into(),
+        contract_id: Some("C1".into()),
+        network: "testnet".into(),
+        deploy_status: DeployStatus::Success,
+        health: dm::HealthStatus::Healthy,
+        checks: vec![],
+        checked_at: "t0".into(),
+    }]);
+
+    let changes = dm::diff_snapshot(&previous, &healths);
+    assert_eq!(changes.len(), 1);
+    assert_eq!(changes[0].from, Some(dm::HealthStatus::Healthy));
+    assert_eq!(changes[0].to, dm::HealthStatus::Unhealthy);
+
+    // A second pass with no change yields no transitions.
+    let same = dm::snapshot_from(&healths);
+    assert!(dm::diff_snapshot(&same, &healths).is_empty());
+}
diff --git a/tests/event_streaming.rs b/tests/event_streaming.rs
new file mode 100644
index 00000000..f1d10e04
--- /dev/null
+++ b/tests/event_streaming.rs
@@ -0,0 +1,164 @@
+//! Integration tests for real-time contract event streaming (D-10):
+//! filtering, routing, alert patterns, analytics, and replay.
+
+use starforge::utils::event_stream as es;
+
+fn record(
+    id: &str,
+    etype: &str,
+    ledger: u32,
+    topics: &[&str],
+    value: &str,
+    ts: &str,
+) -> es::EventRecord {
+    es::EventRecord {
+        id: id.to_string(),
+        contract_id: "CCONTRACT".to_string(),
+        event_type: etype.to_string(),
+        ledger,
+        topics: topics.iter().map(|s| s.to_string()).collect(),
+        value: value.to_string(),
+        received_at: ts.to_string(),
+    }
+}
+
+fn epoch(rfc3339: &str) -> i64 {
+    chrono::DateTime::parse_from_rfc3339(rfc3339)
+        .unwrap()
+        .timestamp()
+}
+
+#[test]
+fn filtering_routing_alerting_and_analytics_pipeline() {
+    let events = vec![
+        record(
+            "e1",
+            "contract",
+            100,
+            &["transfer", "alice"],
+            "amount=50",
+            "2026-02-01T00:00:00+00:00",
+        ),
+        record(
+            "e2",
+            "contract",
+            101,
+            &["transfer", "bob"],
+            "amount=75",
+            "2026-02-01T00:00:10+00:00",
+        ),
+        record(
+            "e3",
+            "contract",
+            102,
+            &["error", "overflow"],
+            "panic",
+            "2026-02-01T00:00:20+00:00",
+        ),
+        record(
+            "e4",
+            "contract",
+            103,
+            &["error", "auth"],
+            "denied",
+            "2026-02-01T00:00:25+00:00",
+        ),
+        record(
+            "e5",
+            "system",
+            103,
+            &["fee"],
+            "100",
+            "2026-02-01T00:00:30+00:00",
+        ),
+    ];
+
+    // Filtering: a transfer-topic filter selects exactly the two transfers.
+    let transfer_filter = es::EventFilter {
+        topic_pattern: Some("transfer,*".into()),
+        ..Default::default()
+    };
+    let transfers: Vec<_> = events
+        .iter()
+        .filter(|e| transfer_filter.matches(e))
+        .collect();
+    assert_eq!(transfers.len(), 2);
+
+    // Routing: a log route for errors matches the two error events.
+    let routes = vec![es::EventRoute {
+        name: "errors".into(),
+        filter: es::EventFilter {
+            topic_pattern: Some("error".into()),
+            ..Default::default()
+        },
+        action: es::RouteAction::Log,
+        enabled: true,
+    }];
+    let error_matches: usize = events
+        .iter()
+        .map(|e| es::match_routes(e, &routes).len())
+        .sum();
+    assert_eq!(error_matches, 2);
+
+    // Alerting: ≥2 error events within a 60s window fires.
+    let patterns = vec![es::AlertPattern {
+        name: "error-spike".into(),
+        filter: es::EventFilter {
+            topic_pattern: Some("error".into()),
+            ..Default::default()
+        },
+        window_secs: 60,
+        threshold: 2,
+        severity: "critical".into(),
+        enabled: true,
+    }];
+    let now = epoch("2026-02-01T00:00:40+00:00");
+    let alerts = es::evaluate_alerts(&patterns, &events, now);
+    assert_eq!(alerts.len(), 1);
+    assert_eq!(alerts[0].count, 2);
+    assert_eq!(alerts[0].severity, "critical");
+
+    // Analytics: aggregate counts by type and ledger range.
+    let analytics = es::EventAnalytics::from_events(&events);
+    assert_eq!(analytics.total, 5);
+    assert_eq!(analytics.by_type["contract"], 4);
+    assert_eq!(analytics.by_type["system"], 1);
+    assert_eq!(analytics.first_ledger, Some(100));
+    assert_eq!(analytics.last_ledger, Some(103));
+
+    // Replay: end-to-end summary over history.
+    let summary = es::replay(&events, &routes, &patterns, now);
+    assert_eq!(summary.processed, 5);
+    assert_eq!(summary.matched_routes, 2);
+    assert_eq!(summary.alerts.len(), 1);
+}
+
+#[test]
+fn json_roundtrip_for_routes_and_patterns() {
+    let route = es::EventRoute {
+        name: "webhook-transfers".into(),
+        filter: es::EventFilter {
+            topic_pattern: Some("transfer".into()),
+            ..Default::default()
+        },
+        action: es::RouteAction::Webhook {
+            url: "https://example.com/hook".into(),
+        },
+        enabled: true,
+    };
+    let json = serde_json::to_string(&route).unwrap();
+    let back: es::EventRoute = serde_json::from_str(&json).unwrap();
+    assert_eq!(route, back);
+
+    let pattern = es::AlertPattern {
+        name: "spike".into(),
+        filter: es::EventFilter::default(),
+        window_secs: 120,
+        threshold: 10,
+        severity: "warning".into(),
+        enabled: true,
+    };
+    let json = serde_json::to_string(&pattern).unwrap();
+    let back: es::AlertPattern = serde_json::from_str(&json).unwrap();
+    assert_eq!(pattern, back);
+}
diff --git a/tests/fixtures/config_v1.toml b/tests/fixtures/config_v1.toml
new file mode 100644
index 00000000..d67e3612
--- /dev/null
+++ b/tests/fixtures/config_v1.toml
@@ -0,0 +1,35 @@
+# Legacy StarForge config (schema v1).
+#
+# This fixture intentionally uses the *old* shapes that the v1 -> v2 migration
+# is responsible for normalising:
+#   * a wallet whose secret is stored under the legacy `secret` key
+#   * flat top-level KDF tuning keys (kdf_mem / kdf_iterations / kdf_parallelism)
+#   * the legacy `telemetry` boolean flag
+#
+# A naive `#[serde(default)]` load would silently DROP the `secret` field,
+# making `legacy-wallet` unusable after an upgrade. The migration must preserve
+# it by renaming it to `secret_key`.
+
+version = "1"
+network = "testnet"
+telemetry = false
+
+kdf_mem = 65536
+kdf_iterations = 4
+kdf_parallelism = 2
+
+[[wallets]]
+name = "legacy-wallet"
+public_key = "GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWNT"
+secret = "SAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWNT"
+network = "testnet"
+created_at = "2024-01-01T00:00:00Z"
+funded = true
+
+[[wallets]]
+name = "modern-wallet"
+public_key = "GBBZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWNT"
+secret_key = "SBBZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWNT"
+network = "testnet"
+created_at = "2024-02-01T00:00:00Z"
+funded = false
diff --git a/tests/state_migration_tools.rs b/tests/state_migration_tools.rs
new file mode 100644
index 00000000..b8c47fa6
--- /dev/null
+++ b/tests/state_migration_tools.rs
@@ -0,0 +1,117 @@
+//! Integration tests for the contract state diffing & migration tooling (D-9).
+
+use starforge::utils::state_migration as sm;
+
+fn entry(key: &str, value: &str, dur: &str) -> sm::StateEntry {
+    sm::StateEntry {
+        key: key.to_string(),
+        value: value.to_string(),
+        durability: dur.to_string(),
+    }
+}
+
+fn snapshot(contract: &str, label: &str, entries: Vec<sm::StateEntry>) -> sm::StateSnapshot {
+    sm::StateSnapshot::new(
+        contract,
+        "testnet",
+        Some("wasmhash".into()),
+        42,
+        Some(label.to_string()),
+        entries,
+    )
+}
+
+#[test]
+fn end_to_end_snapshot_diff_migrate_test_rollback() {
+    // v1 state
+    let v1 = snapshot(
+        "CCONTRACT",
+        "v1",
+        vec![
+            entry("admin", "GADMIN", "instance"),
+            entry("total_supply", "1000", "persistent"),
+            entry("paused", "false", "instance"),
+        ],
+    );
+
+    // v2 state: total_supply changed, paused removed, decimals added
+    let v2 = snapshot(
+        "CCONTRACT",
+        "v2",
+        vec![
+            entry("admin", "GADMIN", "instance"),
+            entry("total_supply", "2000", "persistent"),
+            entry("decimals", "7", "instance"),
+        ],
+    );
+
+    // 1. Diff detects exactly the expected changes.
+    let diff = sm::diff_snapshots(&v1, &v2);
+    assert_eq!(diff.modified, 1, "total_supply modified");
+    assert_eq!(diff.removed, 1, "paused removed");
+    assert_eq!(diff.added, 1, "decimals added");
+    assert_eq!(diff.unchanged, 1, "admin unchanged");
+
+    // 2. Migration plan + script generation.
+    let plan = sm::generate_migration_plan(&diff);
+    assert_eq!(plan.operations.len(), 3);
+    let script = sm::generate_migration_script(&plan);
+    assert!(script.contains("fn migrate"));
+    assert!(script.contains("require_auth"));
+
+    // 3. Migration testing framework: applying the plan to v1 reproduces v2.
+    let result = sm::test_migration(&v1, &plan.operations, &v2);
+    assert!(result.passed, "mismatches: {:?}", result.mismatches);
+    assert_eq!(result.actual_hash, v2.state_hash);
+
+    // 4. Rollback: derive inverse ops and confirm they restore v1.
+    let rollback = sm::rollback_operations(&v2, &v1);
+    let restored = sm::apply_operations(&v2, &rollback);
+    assert_eq!(restored.state_hash, v1.state_hash);
+}
+
+#[test]
+fn validation_blocks_persistent_data_loss() {
+    let before = snapshot(
+        "C",
+        "before",
+        vec![entry("vault_balance", "5000", "persistent")],
+    );
+    let after = snapshot("C", "after", vec![]);
+    let diff = sm::diff_snapshots(&before, &after);
+
+    // Default policy forbids persistent removal -> blocking.
+    let strict = sm::validate_transition(&diff, &sm::MigrationPolicy::default());
+    assert!(sm::has_blocking_findings(&strict));
+
+    // Explicitly allowing it clears the block.
+    let lenient = sm::MigrationPolicy {
+        allow_persistent_removal: true,
+        ..sm::MigrationPolicy::default()
+    };
+    let relaxed = sm::validate_transition(&diff, &lenient);
+    assert!(!sm::has_blocking_findings(&relaxed));
+}
+
+#[test]
+fn snapshot_persistence_roundtrips_via_json() {
+    let snap = snapshot("CPERSIST", "v1", vec![entry("k", "v", "instance")]);
+    let json = serde_json::to_string_pretty(&snap).unwrap();
+    let restored: sm::StateSnapshot = serde_json::from_str(&json).unwrap();
+    assert_eq!(restored.state_hash, snap.state_hash);
+    assert_eq!(restored.entries.len(), 1);
+}
+
+#[test]
+fn detects_wrong_migration_plan() {
+    let base = snapshot("C", "base", vec![entry("a", "1", "instance")]);
+    let expected = snapshot("C", "expected", vec![entry("a", "2", "instance")]);
+    let wrong_ops = vec![sm::MigrationOperation::SetKey {
+        durability: "instance".into(),
+        key: "a".into(),
+        value: "3".into(),
+    }];
+    let result = sm::test_migration(&base, &wrong_ops, &expected);
+    assert!(!result.passed);
+    assert!(!result.mismatches.is_empty());
+}
diff --git a/tests/template_marketplace_comprehensive.rs b/tests/template_marketplace_comprehensive.rs
index 7da3932e..3dbc13fe 100644
--- a/tests/template_marketplace_comprehensive.rs
+++ b/tests/template_marketplace_comprehensive.rs
@@ -1,10 +1,7 @@
 /// Comprehensive test suite for template marketplace workflows
 /// Covers discovery, publishing, installation, and metadata handling
-
 #[cfg(test)]
 mod template_marketplace_tests {
-    use std::collections::HashMap;
-
     // Mock structures for testing
     #[derive(Debug, Clone, PartialEq)]
     enum TemplateSource {
@@ -22,6 +19,7 @@ mod template_marketplace_tests {
     }
 
     #[derive(Debug, Clone)]
+    #[allow(dead_code)]
     struct TemplateEntry {
         name: String,
         version: String,
@@ -62,7 +60,7 @@ mod template_marketplace_tests {
 
     #[test]
     fn test_search_by_exact_name_match() {
-        let templates = vec![
+        let templates = [
             TemplateEntry {
                 name: "uniswap-v2".to_string(),
                 version: "1.0.0".to_string(),
@@ -107,7 +105,7 @@ mod template_marketplace_tests {
 
     #[test]
     fn test_search_by_tag_filtering() {
-        let templates = vec![
+        let templates = [
             TemplateEntry {
                 name: "uniswap-v2".to_string(),
                 version: "1.0.0".to_string(),
@@ -141,7 +139,7 @@ mod template_marketplace_tests {
         ];
 
         // Filter by "dex" tag
-        let required_tags = vec!["dex".to_string()];
+        let required_tags = ["dex".to_string()];
         let results: Vec<_> = templates
             .iter()
             .filter(|t| {
@@ -157,7 +155,7 @@ mod template_marketplace_tests {
 
     #[test]
     fn test_search_by_multiple_tags() {
-        let templates = vec![TemplateEntry {
+        let templates = [TemplateEntry {
             name: "uniswap-v2".to_string(),
             version: "1.0.0".to_string(),
             description: "Uniswap V2 DEX".to_string(),
@@ -174,7 +172,7 @@ mod template_marketplace_tests {
         }];
 
         // Filter by multiple tags - template must have ALL
-        let required_tags = vec!["defi".to_string(), "dex".to_string()];
+        let required_tags = ["defi".to_string(), "dex".to_string()];
         let results: Vec<_> = templates
             .iter()
             .filter(|t| {
@@ -189,7 +187,7 @@ mod template_marketplace_tests {
 
     #[test]
     fn test_search_verified_only_filter() {
-        let templates = vec![
+        let templates = [
             TemplateEntry {
                 name: "verified-template".to_string(),
                 version: "1.0.0".to_string(),
@@ -234,7 +232,7 @@ mod template_marketplace_tests {
 
     #[test]
     fn test_search_quality_score_filtering() {
-        let templates = vec![
+        let templates = [
             TemplateEntry {
                 name: "high-quality".to_string(),
                 version: "1.0.0".to_string(),
@@ -279,7 +277,7 @@ mod template_marketplace_tests {
 
     #[test]
     fn test_search_empty_query_lists_all() {
-        let templates = vec![
+        let templates = [
             TemplateEntry {
                 name: "template1".to_string(),
                 version: "1.0.0".to_string(),
@@ -694,7 +692,7 @@ pub struct {{PROJECT_NAME_PASCAL}} {
 
     #[test]
     fn test_installation_steps_order() {
-        let steps = vec!["Fetching template", "Validating structure", "Installing"];
+        let steps = ["Fetching template", "Validating structure", "Installing"];
 
         assert_eq!(steps[0], "Fetching template");
         assert_eq!(steps[1], "Validating structure");
@@ -728,7 +726,7 @@ pub struct {{PROJECT_NAME_PASCAL}} {
 
     #[test]
     fn test_search_with_special_characters_in_query() {
-        let templates = vec![TemplateEntry {
+        let templates = [TemplateEntry {
             name: "c++-template".to_string(),
             version: "1.0.0".to_string(),
             description: "C++ style template".to_string(),
@@ -754,7 +752,7 @@ pub struct {{PROJECT_NAME_PASCAL}} {
 
     #[test]
     fn test_search_case_insensitive() {
-        let templates = vec![TemplateEntry {
+        let templates = [TemplateEntry {
             name: "UniSwap-V2".to_string(),
             version: "1.0.0".to_string(),
             description: "DEX".to_string(),
diff --git a/tests/template_marketplace_workflows.rs b/tests/template_marketplace_workflows.rs
index 0a37e68c..51ee6b80 100644
--- a/tests/template_marketplace_workflows.rs
+++ b/tests/template_marketplace_workflows.rs
@@ -1,10 +1,7 @@
 /// Integration tests for complete template marketplace workflows
 /// Tests end-to-end scenarios: publish → search → install
-
 #[cfg(test)]
 mod template_marketplace_workflow_tests {
-    use std::collections::HashMap;
-
     // Mock structures
     #[derive(Debug, Clone)]
     struct TemplateRegistry {
@@ -12,6 +9,7 @@ mod template_marketplace_workflow_tests {
     }
 
     #[derive(Debug, Clone)]
+    #[allow(dead_code)]
     struct TemplateEntry {
         name: String,
         version: String,
diff --git a/tests/wallet_error_handling.rs b/tests/wallet_error_handling.rs
index 32caa0c7..c29a6bb3 100644
--- a/tests/wallet_error_handling.rs
+++ b/tests/wallet_error_handling.rs
@@ -7,7 +7,6 @@
 
 /// Error handling and edge case tests for wallet operations
 /// Tests failure scenarios, invalid inputs, and error recovery
-
 #[cfg(test)]
 mod wallet_error_handling_tests {
     const VALID_PUBLIC_KEY: &str = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";