rename: aldabra → aldabra (per Sulkta 2026-05-04)

Aldabra giant tortoise (Aldabrachelys gigantea) — endemic to the
Aldabra atoll, up to 250 kg, 150-year lifespan. Long-lived,
defended, slow but unstoppable. Better metaphor for the wallet
than 'aldabra' which was on-the-tin descriptive.

All renames in one pass:
- repo: Sulkta-Coop/aldabra → Sulkta-Coop/aldabra (via gitea API)
- workspace dir: aldabra → aldabra
- crate dirs: wallet-{core,chain,mcp} → aldabra-{core,chain,mcp}
- crate names + path imports in Cargo.toml workspace + each crate
- binary name: aldabra → aldabra
- README, ROADMAP, docs/architecture: all references swept

crates/aldabra-mcp/src/main.rs

@@ -0,0 +1,74 @@
+//! aldabra — MCP server entry point.
+//!
+//! Speaks MCP over stdio. Any MCP client (e.g. Claude Code)
+//! launches this as a subprocess and gets a wallet's worth of tools.
+//!
+//! ## Phase 1 tools
+//!
+//! - `wallet.address` — return the derived base address (placeholder
+//!   until aldabra-core's CIP-1852 derivation lands)
+//! - `wallet.balance` — query balance via the configured chain backend
+//!
+//! ## Phase 2-4 tools (TODO)
+//!
+//! See ROADMAP.md at the repo root.
+//!
+//! ## Config
+//!
+//! For now: hardcoded mainnet + a stub Koios client. Real config
+//! loading + mnemonic-from-encrypted-file lands once the core
+//! derivation API is real.
+//!
+//! ## Logging
+//!
+//! Stderr only — stdout is the MCP transport, must stay clean.
+
+use anyhow::Result;
+use tracing_subscriber::EnvFilter;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Stderr only — stdout is MCP transport
+    tracing_subscriber::fmt()
+        .with_writer(std::io::stderr)
+        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()))
+        .init();
+
+    tracing::info!("aldabra starting (phase 1 scaffold)");
+
+    // TODO(phase 1):
+    //   1. Load config (network, koios url, mnemonic path)
+    //   2. Bootstrap mnemonic (interactive on first run, age-decrypt thereafter)
+    //   3. Derive root key
+    //   4. Build the chain backend
+    //   5. Construct the MCP server with tool handlers
+    //   6. Run it on stdio
+
+    // For now: a smoke-test print so the binary actually does something
+    // when invoked manually (not through MCP).
+    tracing::info!(
+        target_address = %aldabra_core::derive_base_address(
+            &dummy_root_key()?,
+            aldabra_core::Network::Mainnet,
+            0,
+            0,
+        )?,
+        "scaffold smoke test — derived placeholder address",
+    );
+
+    Ok(())
+}
+
+/// Phase 1 only — produces a zero-bytes RootKey so the placeholder
+/// address derivation runs. Will be deleted once real mnemonic loading
+/// lands.
+fn dummy_root_key() -> Result<aldabra_core::RootKey> {
+    // Need a way to construct one from this crate without exposing
+    // private fields. Phase 1: temporary public constructor on
+    // aldabra-core, gated behind a #[cfg(test)] or feature flag and
+    // removed before phase 2.
+    //
+    // For tonight: this fn is a TODO marker — the smoke test won't
+    // actually run until we finish aldabra-core::Mnemonic::into_root_key.
+    anyhow::bail!("phase 1 scaffold: real mnemonic loading not yet implemented")
+}