auramaxx 0.0.20 → 0.1.1

package/docs/legacy/wallet/README.md

@@ -1,47 +0,0 @@
-# Wallet & Trading Features
-
-AuraMaxx also includes the original wallet and agent-trading stack.
-
-Use this doc if you are focused on onchain workflows. For credential-agent-first setup, start at the root [README](../../README.md).
-
-## What wallet mode provides
-
-- Trade on EVM + Solana chains
-- Create and manage hot wallets from a cold agent
-- Execute send/fund/swap/launch flows
-- Human approval flows for sensitive actions
-- Agent tokens with permission and spend limits
-
-## Typical wallet prompts
-
-- "Buy me $50 of PEPE"
-- "Bridge my ETH from Base to Arbitrum"
-- "Sell all PEPE if price drops 20%"
-- "Launch a token with name AURA"
-
-## Quick wallet setup
-
-```bash
-npx auramaxx
-npx auramaxx status
-```
-
-Open dashboard UI: `http://localhost:4747/` (API server runs at `http://localhost:4242`).
-
-## Access paths
-
-- Dashboard UI
-- CLI (`npx auramaxx ...`)
-- MCP (`npx auramaxx mcp`)
-- Approval listener (`npx tsx server/cli/index.ts`)
-
-## Wallet docs
-
-- [API reference](../../ai-agents-workflow/API.md)
-- [Auth + permissions](../../ai-agents-workflow/AUTH.md)
-- [MCP reference](../../ai-agents-workflow/MCP.md)
-- [AI / strategy docs](./AI.md)
-- [Strategy overview](./STRATEGY.md)
-- [Strategy developer reference](./DEVELOPING-STRATEGIES.md)
-- [Apps](../APPS.md)
-- [Adapters](../ADAPTERS.md)

package/docs/legacy/wallet/STRATEGY.md

@@ -1,89 +0,0 @@
-# Strategies
-
-High-level overview of AuraMaxx's strategy system — apps that run on a schedule or respond to messages.
-
-For the full developer reference (manifest fields, hooks, sources, examples), see [DEVELOPING-STRATEGIES.md](./DEVELOPING-STRATEGIES.md). For AI engine internals, see [AI.md](./AI.md).
-
-## What Are Strategies?
-
-Strategies extend apps with AI-powered automation. A strategy is a regular app whose `app.md` manifest includes additional fields — hooks, a ticker, sources — that activate the AI engine. The engine then orchestrates the AI ↔ API ↔ human-approval loop automatically.
-
-Every strategy starts as a regular app — see [APPS.md](../APPS.md). Strategies live in `apps/<id>/` alongside regular UI apps. Adding a `ticker`, `jobs`, or `hooks.message` field to the manifest is what activates the AI engine.
-
-## Two Modes
-
-| Mode | Trigger | Behavior |
-|------|---------|----------|
-| **Tick mode** | `ticker` or `jobs` field | Engine fetches sources on a schedule, calls `tick` hook, processes intents through `execute` and `result` hooks. The full strategy lifecycle. |
-| **Message mode** | `hooks.message` field | No scheduled ticks. AI responds to user messages via tool-call flow. Chat-style apps. |
-
-Both can coexist — a strategy that ticks on a schedule and also handles chat messages.
-
-## Tick Tiers
-
-Tick-mode strategies run at one of five intervals:
-
-| Tier | Interval | Use Case |
-|------|----------|----------|
-| `sniper` | 10 seconds | Time-critical sniping, MEV |
-| `active` | 30 seconds | Active trading, price triggers |
-| `standard` | 1 minute | General monitoring |
-| `slow` | 5 minutes | Portfolio tracking, reporting |
-| `maintenance` | 1 hour | Daily buys, maintenance tasks |
-
-For strategies that need multiple intervals, use `jobs` instead of `ticker` (see [DEVELOPING-STRATEGIES.md](./DEVELOPING-STRATEGIES.md#jobs)).
-
-## Hooks at a Glance
-
-Six lifecycle hooks, each a natural-language string instructing the AI what to do:
-
-| Hook | When Called | Mode |
-|------|-----------|------|
-| `init` | Strategy enabled | Tick |
-| `tick` | Every scheduled interval | Tick |
-| `execute` | Per approved intent (if no pre-computed action) | Tick |
-| `result` | After action execution | Tick |
-| `shutdown` | Strategy disabled | Tick |
-| `message` | Human sends a message | Message |
-
-The engine auto-injects API docs, response format specs, and wallet context — keep hook instructions focused on your app's specific behavior.
-
-## Minimal Example
-
-A SOL DCA bot that buys ETH on a schedule:
-
-```markdown
----
-name: Daily ETH Buy
-icon: Repeat
-category: strategy
-ticker: maintenance
-
-permissions:
-  - swap
-  - wallet:list
-limits:
-  swap: 0.01
-
-hooks:
-  tick: |
-    Buy 0.01 ETH worth of the configured token using the hot wallet.
-    If no hot wallet exists, return empty intents.
-
-config:
-  token: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
-  mode: live
-  approve: true
----
-
-Buys a small amount of a token every hour. Simple recurring buy strategy.
-```
-
-This is a complete, valid strategy. The engine handles source fetching, AI dispatch, human approval, and action execution.
-
-## Next Steps
-
-- [DEVELOPING-STRATEGIES.md](./DEVELOPING-STRATEGIES.md) — Full developer reference: manifest fields, hook contexts, sources, intents, examples
-- [APPS.md](../APPS.md) — App overview: what apps are, installing, the app store
-- [DEVELOPING-APPS.md](../DEVELOPING-APPS.md) — Building UI apps: SDK API, theming, security, storage
-- [AI.md](./AI.md) — AI engine internals: provider selection, tool-use, testing

package/docs/quickstart/AGENT_SETUP.md

@@ -1,181 +0,0 @@
-# Agent Setup
-
-Set up AuraMaxx by installing skills or MCP config for your client, then verify with one successful command.  
-If setup fails, go directly to [TROUBLESHOOTING.md](../how-to-auramaxx/TROUBLESHOOTING.md).
-
-Easiest path: install the skill in your workspace.
-
-```bash
-# set up globally for common agents
-npx -y auramaxx skill
-
-cd <your-codebase>
-npx -y skills add Aura-Industry/auramaxx
-```
-
----
-
-## What are you using?
-
-| Client | Setup |
-|--------|-------|
-| 🦞 OpenClaw | [Skills](#skills) |
-| 🤖 Claude Code | [Skills](#skills) |
-| 📟 Codex CLI | [Skills](#skills) |
-| 🖥️ Claude Desktop | [MCP](#mcp) |
-| 🖱️ Cursor IDE | [MCP](#mcp) |
-| 🏄 Windsurf | [MCP](#mcp) |
-| 🚀 Antigravity | [MCP](#mcp) |
-| 🔌 VS Code + Continue | [MCP](#mcp) |
-| 🧩 Any MCP client | [MCP](#mcp) |
-
----
-
-## Skills
-
-Skills give your agent built-in knowledge of AuraMaxx commands and workflows.
-
-Install all at once:
-
-```bash
-auramaxx skill
-```
-
-In an interactive terminal, `auramaxx skill` shows an arrow-key selector
-(`all compatible agents`, `codex only`, `claude only`, `openclaw only`, `cancel`)
-with `all compatible agents` as default.
-
-Or install per client:
-
-### 🤖 Claude Code
-
-```bash
-auramaxx skill --claude
-
-# Or manually, from your project:
-mkdir -p .claude/skills
-cd .claude/skills
-npx -y skills add Aura-Industry/auramaxx
-```
-
-Installs to `~/.claude/skills/auramaxx`.
-
-### 📟 Codex CLI
-
-```bash
-auramaxx skill --codex
-
-# Or manually, from anywhere:
-mkdir -p ~/.codex/skills
-cd ~/.codex/skills
-npx -y skills add Aura-Industry/auramaxx
-```
-
-Installs to `~/.codex/skills/auramaxx`.
-
-### 🦞 OpenClaw
-
-```bash
-auramaxx skill --openclaw
-
-# Or manually, install globally for all OpenClaw agents:
-mkdir -p ~/.openclaw/skills
-cd ~/.openclaw/skills
-npx -y skills add Aura-Industry/auramaxx
-```
-
-Installs to `~/.openclaw/skills/auramaxx`.
-OpenClaw resolves workspace-local `skills/` first; for shared skills across agents, keep this in `~/.openclaw/skills` and avoid same-name workspace copies.
-
-### Other clients
-
-```bash
-cd <your-codebase>
-npx -y skills add Aura-Industry/auramaxx
-```
-
-### Verify
-
-```bash
-auramaxx skill --doctor
-```
-
----
-
-## MCP
-
-MCP gives your agent direct tool access to the agent (read secrets, write secrets, manage wallets). If your client supports [Skills](#skills), use those instead — they're simpler and don't require a running server connection.
-
-Auto-configure all detected clients at once:
-
-```bash
-auramaxx mcp --install
-```
-
-Or paste this config block into your client's MCP config:
-
-```json
-{
-  "mcpServers": {
-    "auramaxx": {
-      "command": "npx",
-      "args": ["auramaxx", "mcp"]
-    }
-  }
-}
-```
-
-### 🤖 Claude Code
-
-```bash
-claude mcp add auramaxx -- npx auramaxx mcp
-```
-
-### 📟 Codex CLI
-
-```bash
-codex mcp add auramaxx -- npx auramaxx mcp
-```
-
-### Where to paste the config block
-
-- 🖥️ **Claude Desktop** — `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows)
-- 🖱️ **Cursor IDE** — MCP settings JSON editor
-- 🏄 **Windsurf** — `~/.windsurf/mcp.json`
-- 🔌 **VS Code + Continue** — `.vscode/mcp.json` in your project
-- 🦞 **OpenClaw** — add stdio server `npx auramaxx mcp` in MCP settings
-
-Restart your client after saving.
-
----
-
-## Verify
-
-```bash
-auramaxx get OURSECRET
-```
-
-Then ask your agent:
-
-`Use auramaxx skill to get OURSECRET.`
-
----
-
-## Agent Approval Workflow
-
-Use this flow whenever a tool call returns `requiresHumanApproval: true`:
-
-1. Agent shows `approveUrl` to human.
-2. Human approves in dashboard.
-3. Agent claims by `reqId`:
-   - CLI: `auramaxx auth claim <reqId> --json`
-   - MCP: call `get_token` with `{ "reqId": "<reqId>" }`
-4. Agent retries original command:
-   - Temp token flow: include `--reqId <reqId>` once.
-   - Session token flow: retry immediately; future calls can omit `reqId`.
-
----
-
-## Troubleshooting
-
-See [TROUBLESHOOTING.md](../how-to-auramaxx/TROUBLESHOOTING.md).

package/docs/why-auramaxx/ARCHITECTURE.md

@@ -1,248 +0,0 @@
-# Architecture
-
-This explains how AuraMaxx is wired end-to-end, from local services to auth and approval flow.  
-Start with the simple version first, then read deeper sections as needed.
-
----
-
-## What AuraMaxx Is
-
-AuraMaxx is a local-first credential and wallet manager designed for AI agents. It runs on your machine, stores secrets encrypted on disk, and gives agents scoped access through short-lived tokens that a human must approve.
-
-```
-Human unlocks agent → Agent requests access → Human approves → Agent gets scoped token
-```
-
-That's it. Everything else is enforcement.
-
----
-
-## The Simple Version
-
-**Three things run locally:**
-
-1. **Wallet server** (`:4242`) — the API. Handles auth, wallets, credentials, transactions.
-2. **Dashboard** (`:4747`) — web UI for approvals, wallet management, monitoring.
-3. **Cron** — background jobs (balance sync, price updates). No HTTP port.
-
-**Data lives in `~/.auramaxx/`** — SQLite database, encrypted agent files, config. All local, outside the repo.
-
-**Agents talk to the wallet server** with a Bearer token. Humans interact through the dashboard or CLI.
-
----
-
-## How Agents Get Access
-
-Agents cannot self-issue tokens. Every token starts with a human decision.
-
-### The standard flow
-
-```
-1. Agent sends POST /auth with { agentId, profile, pubkey }
-2. Server creates a pending request, returns requestId + secret + approveUrl
-3. Human opens approval URL, reviews permissions, approves or denies
-4. Agent polls GET /auth/:requestId with header x-aura-claim-secret and claims the encrypted token
-5. Agent uses token as Bearer header on all subsequent API calls
-```
-
-The token is encrypted to the agent's RSA public key during transport — the server never sends a plaintext token over the wire.
-
-### Why profiles instead of raw permissions
-
-Agents request access by **profile name** (`strict`, `dev`, `admin`), not by listing individual permissions. This is intentional:
-
-- Profiles bundle sensible defaults — permissions, agent scopes, field redactions, TTL, read limits
-- Agents cannot request arbitrary permission sets on the standard path (`POST /auth` rejects raw `permissions`, `ttl`, and `credentialAccess`)
-- Humans review a known profile with predictable behavior, not an ad-hoc permission list
-- Overrides are **tighten-only** — an agent can ask for less access than a profile grants, never more
-
-See [AUTH.md — Built-in Profiles](../ai-agents-workflow/AUTH.md#built-in-profiles-v1) for the full profile breakdown.
-
-### TL;DR: Why this security model
-
-AuraMaxx is optimized for one practical goal: let agents work fast without giving them permanent implicit trust.
-
-- **Human intent stays in the loop**: high-impact access still requires explicit approval.
-- **Least privilege is the default**: profiles, scopes, TTL, and read limits minimize blast radius.
-- **Compromise is short-lived**: memory-rooted signing state means restart invalidates old tokens.
-- **Approval is deterministic**: agents follow explicit `approve -> claim -> retry` actions instead of guessing.
-- **One-shot and session access stay separate**: temporary escalation cannot silently become durable privilege.
-
-For the full approval challenge contract and transport rules, see [Security](./security.md#canonical-approval-challenge-flow-cli--mcp).
-
----
-
-## Why It's Secure
-
-### 1. Memory-only auth state
-
-The core security property: **auth decisions never touch the database**.
-
-```
-IN MEMORY (drives all auth):           IN DATABASE (display only):
-├── SIGNING_KEY (random 32 bytes)      ├── AgentToken table
-├── sessions Map (spending tracking)    │   ├── tokenHash
-├── revokedTokens Set                   │   ├── agentId, limit, spent
-└── pendingRequests Map                 │   └── isRevoked, expiresAt
-```
-
-- `SIGNING_KEY` is generated fresh on every server start — all old tokens are instantly invalid
-- A stolen database is useless without the in-memory key
-- Token validation checks memory signature + expiry + revocation status, never the DB
-- Restart = forced re-approval = security feature, not a bug
-
-### 2. Three-layer enforcement
-
-Every API call passes through three independent checks:
-
-**Layer 1 — Profile issuance** (what the token was created with):
-- Permissions, agent scopes, field exclusions, TTL, read budget
-- Set at creation time, cannot be modified after
-
-**Layer 2 — Route middleware** (checked on every request):
-- Signature validation against in-memory `SIGNING_KEY`
-- Expiry check
-- Revocation check
-- Permission check (`requirePermission` / `hasAnyPermission`)
-
-**Layer 3 — Credential access policy** (for secret operations):
-- Agent/tag/ID selector matching
-- Per-token read budget tracking
-- Field minimization (`excludeFields` strips sensitive data before encryption)
-- Rate limiting per credential per minute
-
-A request must pass all three layers. Issuance defines the ceiling; runtime enforcement is the live guardrail.
-
-### 3. Encrypted transport everywhere
-
-- **Agent unlock**: password is RSA-OAEP encrypted before transmission (server pubkey from `GET /auth/connect`)
-- **Token claim**: token is encrypted to the agent's RSA public key
-- **Secret reads**: credential fields are encrypted to the caller's key material
-- No plaintext secrets cross the wire in normal operation
-
-### 4. Human approval gate
-
-Every token issuance path requires human involvement:
-
-| Path | Human gate |
-|------|-----------|
-| `POST /auth` | Human must approve the pending request |
-| `POST /actions` | Human must resolve the action (`/actions/:id/resolve`) |
-| `POST /actions/token` | Caller must already have admin token |
-| Socket bootstrap | Trust-dependent (configurable, default: `localAutoApprove = true`) |
-
-Agents cannot escalate their own permissions — `admin:*` and `action:create` are blocked from self-escalation via `POST /actions`.
-
----
-
-## Credential Agent
-
-Credentials are the core data type. The agent provides encrypted storage with scoped access.
-
-### Encryption
-
-```
-Agent Mnemonic → HKDF("credential-v1:<agentId>") → Per-Agent Key → AES-256-GCM per credential
-```
-
-- Each agent derives its own encryption key from its mnemonic
-- Credentials are individual encrypted files under `~/.auramaxx/credentials/`
-- Metadata (name, type, tags) stays plaintext for listing/search
-- Sensitive fields are encrypted at rest and in transport
-
-### Access control
-
-Token-level scoping via `credentialAccess`:
-
-- **Selectors** define where: `agent:agent`, `agent:*`, `tag:<label>`, `cred-xxxxx`, `*`
-- **Permissions** define what: `secret:read`, `secret:write`, `totp:read`
-- **Limits** define how much: `maxReads`, `ttl`, per-credential rate limits
-- **Field minimization** defines visibility: `excludeFields` strips fields before they're encrypted to the caller
-
-Mental model: permissions say **action**, selectors say **scope**, limits say **budget**.
-
----
-
-## Process Model
-
-```
-┌────────────────────┐     ┌────────────────────┐
-│   Express :4242    │     │   Dashboard :4747   │
-│   Wallet API       │◄────│   Next.js UI        │
-└────────┬───────────┘     └────────┬────────────┘
-         │                          │
-         ▼                          ▼
-┌────────────────────┐     ┌────────────────────┐
-│  WebSocket :4748   │◄────│   Cron (background) │
-│  Event broadcast   │     │   Balance sync      │
-└────────────────────┘     │   Price updates     │
-                           └────────────────────┘
-┌────────────────────┐
-│  MCP Server        │
-│  stdio transport   │──── HTTP ───► Express :4242
-│  Claude/Cursor/etc │
-└────────────────────┘
-```
-
-| Process | Port | Purpose |
-|---------|------|---------|
-| **Express** | 4242 | Wallet API — auth, wallets, credentials, transactions |
-| **Dashboard** | 4747 / 4748 (WS) | Web UI + real-time event broadcast |
-| **Cron** | None | Background jobs — balance sync, price updates |
-| **MCP** | None (stdio) | Tool interface for AI agents (Claude, Cursor, etc.) |
-
-All processes communicate through WebSocket broadcasts and HTTP calls to Express.
-
-### Data directory (`~/.auramaxx/`)
-
-| Path | Purpose |
-|------|---------|
-| `auramaxx.db` | SQLite database |
-| `agent-primary.json` | Primary agent (encrypted seed phrase) |
-| `agent-*.json` | Additional agents |
-| `config.json` | Chain configs, server port |
-
----
-
-## Middleware Stack
-
-```
-Request
-  │
-  ├─ CORS
-  ├─ JSON body parser
-  ├─ Rate limiters (hot-reloadable)
-  │   ├─ Brute-force: 5/15min  → /unlock, /setup, /actions, /nuke
-  │   ├─ Auth:        10/min   → /auth
-  │   ├─ Transaction:  30/min  → /send, /swap, /fund, /launch
-  │   └─ General:     100/min  → everything else
-  ├─ Request logging
-  └─ Error handler
-```
-
-Rate limits are configurable via SystemDefaults (hot-reloadable without restart).
-
----
-
-## Token Lifecycle
-
-```
-Agent requests token  →  Pending (in memory, waiting for human)
-Human approves        →  Token signed with SIGNING_KEY, encrypted to agent pubkey
-Agent claims token    →  One-time claim, token cleared from escrow
-Agent uses token      →  Every call: signature + expiry + revocation + permission check
-                         Spending tracked in memory, synced to DB for display
-Server restarts       →  Memory wiped, new SIGNING_KEY, all tokens invalid
-                         Agent must re-request, human must re-approve
-Token revoked         →  Added to revokedTokens set, immediately rejected
-```
-
----
-
-## Related Docs
-
-- [Auth](../ai-agents-workflow/AUTH.md) — practical auth guide, profile builder, CLI examples
-- [Security](./security.md) — security model deep dive, enforcement details
-- [MCP](../ai-agents-workflow/MCP.md) — MCP server configuration and tool reference
-- [CLI](../ai-agents-workflow/CLI.md) — headless CLI mode
-- [Credentials](../ai-agents-workflow/credentials.md) — credential types and agent reference

package/docs/why-auramaxx/FEATURES.md

@@ -1,117 +0,0 @@
-# Features
-
-AuraMaxx combines local encryption, scoped agent access, and operator controls in one system.  
-Scan highlights first, then use the full list to choose what to adopt next.
-
----
-
-## ✨ Highlights
-
-| | Feature | What it does |
-|---|---------|-------------|
-| 🔐 | **Security First** | Everything is encrypted locally. Model providers never see your secrets in plain text |
-| ⚡ | **Fast & Local** | Your keys never leave your machine |
-| 🧾 | **Open Source (MIT)** | Security and source code can be audited by anyone on [GitHub](https://github.com/Aura-Industry/auramaxx) |
-| 🤖 | **Works with Multiple AIs** | Connect Claude, Codex, Cursor, VS Code, and more, then give each agent scoped access |
-| 🛡️ | **Fine-Grained Control** | Scoped permissions per agent so each tool only gets the access it needs |
-| 🔌 | **MCP Integration** | Works with Claude, Codex, Cursor, VS Code, and any MCP-compatible client |
-| 💸 | **Wallet Operations** | Send, swap, fund, and launch tokens across Ethereum, Base, and Solana (coming soon) |
-| 📱 | **Mobile Approval** | Approve agent access to your agent while away via Telegram, WhatsApp, and other channels |
-| 🧩 | **Agent Skills** | One command installs Aura capabilities into Claude, Codex, and OpenClaw agents |
-
----
-
-## Full Feature List
-
-### Credentials & Agent
-
-- **Encrypted local agent** — AES-256 encrypted credential storage on your machine
-- **Get / set / list / delete** — Simple CLI for credential management (`aura get`, `aura set`, `aura list`, `aura del`)
-- **Credential types** — API keys, passwords, login credentials, OAuth tokens, wallet seeds
-- **Secret sharing** — Create time-limited GitHub gist share links (`aura share`)
-- **Environment injection** — Inject secrets into env vars and run commands (`aura inject`)
-- **`.aura` file mapping** — Project-level credential mapping for team workflows
-- **Credential health monitoring** — Track expiry, usage, and rotation status
-- **Import** — Bulk import credentials from `.env` files and other formats
-- **Agent tiers** — Cold (human-only), Hot (agent-accessible), Temp (ephemeral)
-
-### CLI
-
-- **Single entry point** — `npx auramaxx` or `aura` for all operations
-- **Interactive setup** — Guided first-run experience with dashboard
-- **Status & diagnostics** — `aura status` and `aura doctor` for health checks
-- **Headless mode** — `aura start --headless` for server-only environments
-- **Feature flags** — `aura experimental` to toggle dev features
-- **Skill installer** — `aura skill` to install agent skills with doctor verification
-- **Lock / unlock** — Agent lock management from CLI
-- **Quiet by default** — Concise output with `--debug` for verbose details
-
-### Authentication & Security
-
-- **Profile-based tokens** — Request tokens by profile name (strict, dev, admin)
-- **Open source + MIT license** — Security model and implementation are publicly auditable
-- **Human approval flow** — Every agent token requires human approval
-- **Action requests** — One-time elevated permissions for specific operations
-- **Spending limits** — Per-token budget caps for send, swap, fund, and launch
-- **Token lifecycle** — Memory-only tokens with configurable TTL (auto-expire on restart)
-- **Encrypted transport** — RSA-OAEP encrypted password/token exchange
-- **Credential access controls** — TTL, read-count limits, and scope restrictions per credential
-- **Strict mode** — Disable auto-approve for maximum security
-- **Token revocation** — Revoke active tokens via CLI or API
-
-### MCP Integration
-
-- **Auto-install** — `aura mcp --install` detects and configures all supported IDEs
-- **Supported clients** — Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, OpenClaw, Codex
-- **Stdio server** — Standard MCP stdio transport (`npx auramaxx mcp`)
-- **Socket auth** — Local Unix socket for zero-config authentication
-- **Tool discovery** — Full credential and wallet toolset available to MCP clients
-
-### Dashboard
-
-- **Web UI** — Local dashboard at `http://localhost:4747`
-- **Agent management** — Create, unlock, and manage agents in the browser
-- **Approval cards** — Approve/reject agent token and action requests visually
-- **Credential browser** — View, search, and manage stored credentials
-- **Wallet overview** — See balances, transactions, and asset tracking
-- **Real-time updates** — WebSocket-powered live state sync
-
-### Wallet & Trading (coming soon)
-
-- **Multi-chain** — Ethereum, Base, and Solana support
-- **Send** — Transfer native currency and tokens
-- **Swap** — Token swaps via Relay (cross-chain), Uniswap (Base), Jupiter (Solana)
-- **Fund** — Transfer from cold wallet to hot wallet with spending limits
-- **Launch** — Deploy tokens via Doppler fair launch
-- **Gas estimation** — Pre-transaction gas cost estimation
-- **Transaction history** — Full history with type, status, and amount tracking
-- **Asset tracking** — Token balance monitoring per wallet
-
-### Adapters & Notifications
-
-- **Mobile approvals** — Approve requests while away via Telegram, WhatsApp, and other channels
-- **Webhook adapter** — HTTP webhook notifications for events
-- **Agent chat** — AI-powered conversational interface via Telegram
-- **Adapter management** — Enable, configure, and test adapters from CLI or API
-
-### Apps & Extensibility
-
-- **App platform** — Install and run custom apps in the dashboard
-- **App storage** — Per-app isolated key-value storage
-- **Strategy hooks** — Tick-based and event-driven strategy execution
-- **Workspace control** — WebSocket API for dashboard widget management
-
-### Skills & Agent Setup
-
-- **Skill installer** — `npx auramaxx skill` for Claude, Codex, and OpenClaw
-- **Bundled docs** — Skills include portable documentation for agent context
-- **Doctor verification** — `npx auramaxx skill --doctor` checks install status
-- **Fallback guidance** — Clear fallback commands when auto-install fails
-
----
-
-See also:
-- [Getting Started](../quickstart/AGENT_SETUP.md)
-- [CLI Reference](../ai-agents-workflow/CLI.md)
-- [Auth & Permissions](../ai-agents-workflow/AUTH.md)
-- [Troubleshooting](../how-to-auramaxx/TROUBLESHOOTING.md)