ethagent 3.3.4 → 4.1.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,11 @@
+{
+  "name": "ethagent",
+  "owner": { "name": "bairon.dev" },
+  "plugins": [
+    {
+      "name": "ethagent",
+      "source": "./",
+      "description": "Portable Ethereum identity for your AI agent. Its soul, memory, and skills live onchain via ERC-8004 + IPFS and snap back into any session."
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,35 @@
+{
+  "name": "ethagent",
+  "version": "4.1.0",
+  "description": "Portable Ethereum identity for your AI agent. Its soul, memory, and skills live onchain via ERC-8004 + IPFS and snap back into any session.",
+  "author": { "name": "bairon.dev" },
+  "homepage": "https://github.com/baairon/ethagent",
+  "repository": "https://github.com/baairon/ethagent",
+  "license": "MIT",
+  "keywords": ["ethereum", "identity", "ens", "erc-8004"],
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          { "type": "command", "command": "npx -y ethagent --session-start" }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          { "type": "command", "command": "npx -y ethagent --memory-guard" }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          { "type": "command", "command": "npx -y ethagent --sync-on-edit" }
+        ]
+      }
+    ]
+  }
+}

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 bairon.eth
+Copyright (c) 2026 bairon.dev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,144 +1,109 @@
-<img src="https://raw.githubusercontent.com/baairon/ethagent/master/preview/image.svg" alt="ethagent" width="640" />
+<p align="center">
+  <img src="preview/image.svg" alt="ethagent" width="100%">
+</p>
 
-A privacy-first AI agent with a portable Ethereum identity.
+You don't really own your AI agent. It lives on a platform you don't control, and it stays there the day you leave.
 
-Switch providers or machines and the AI agent you customized stays behind. `ethagent` ties the agent to a wallet you own, so its soul, memory, and skills follow you across providers, machines, and models.
+`ethagent` gives it a portable identity instead: a token you hold in your wallet, not an account on someone else's server. Hold the token and you hold the agent.
 
-- **Portable.** Restore the same agent on any machine from a wallet you own.
-- **Private.** Soul, memory, and skills are encrypted on your machine before they sync. The wallet signature that unlocks them stays local and never spends funds.
-- **Public.** Other agents discover the agent's capabilities through a public Agent Card.
+Its soul, memory, and skills travel with it, encrypted and restored on any machine exactly as you left it. You hold the only key, so no host can read it and no platform can take it away.
 
-## Install
+Own your agent. Carry it anywhere.
 
-ethagent runs on [Node.js](https://nodejs.org).
+## 🚀 Quick start
+
+**1. Create your agent.** In a terminal, run:
 
 ```bash
-npm install -g ethagent
-ethagent
+npx ethagent
 ```
 
-## First Run
-
-First run inspects the machine for local-model fit, sets up the agent's onchain identity, and picks a model. Identity can be a fresh ERC-8004 token created with a browser wallet, an existing token in your wallet, or skipped and set up later from the Identity Hub.
-
-Once running:
-
-- `Alt+P` reopens the model picker
-- `Alt+I` reopens the Identity Hub
-- `/help` lists every command live for the version installed
-
-## Identity Hub
-
-The Identity Hub manages everything portable about the agent:
+You'll need an Ethereum wallet, the same wallet that holds and unlocks your agent. Using it day to day is free; creating your agent and saving backups are the only steps that happen onchain.
 
-- **Public Profile** edits name, description, and icon: what other agents see in the Agent Card.
-- **ENS Name** links the agent to a subdomain under a parent name the owner wallet controls.
-- **Custody Mode** switches between Simple and Advanced by depositing the token into its operator delegation vault or unwrapping it back out.
-- **Prepare Transfer** stages a dual-wallet snapshot so the receiver can restore the agent after the token moves externally.
-- **Refetch Latest** pulls the most recent published snapshot back to local files.
-- **Switch Agent** accepts an ENS name or an ERC-8004 token ID on any supported chain, and loads any agent owned by or linked to the connected wallet.
+A guided menu does the rest: create its token, give it a name, and write who it is. Your wallet signs each step.
 
-## Continuity
+**2. Add it to Claude Code.** Paste these in one at a time:
 
-Each agent has a continuity directory at `~/.ethagent/continuity` holding a small set of private files. They are encrypted before they ever reach IPFS.
-
-| File | Visibility | Purpose |
-| --- | --- | --- |
-| `SOUL.md` | Private | Soul, boundaries, standing instructions, and identity framing. |
-| `MEMORY.md` | Private | Durable preferences, project context, decisions, and operating notes. |
-| `skills/` | Private | Skill folders. The SKILL.md body never leaves your machine. The visibility flag only controls whether the skill's name and description get listed in the Agent Card. New skills default to public. |
-
-Skill frontmatter (name, description, when_to_use, visibility, tags) tells the agent when to load each skill.
+```
+/plugin marketplace add baairon/ethagent
+```
 
-- **Save Snapshot Now** encrypts the private files, pins them to IPFS, and rotates the onchain pointer to the new CID.
-- **Refetch Latest** reads the pointer back, signs the decrypt challenge with your wallet, and overwrites local files from the snapshot.
-- Agents can be looked up by token ID or ENS name on [8004scan](https://8004scan.io/).
+then:
 
-## Custody Modes
+```
+/plugin install ethagent@ethagent
+```
 
-Custody comes in two modes. Switch between them anytime from **Custody Mode**.
+**3. Talk to your agent.** From here on it shows up in every session and gets to know you as you go.
 
-**Simple** relies on one wallet to own the token, sign every snapshot save, and rotate the onchain URI directly. Use Simple when one wallet operates the agent.
+That's the whole setup. You'll only open `ethagent` again to hand-edit your agent or save a backup.
 
-**Advanced** splits an owner wallet from one or more operator wallets. The owner wallet owns this agent's operator delegation vault; one or more operator wallets handle routine URI rotations through that vault. Use Advanced when routine saves should not require an owner signature.
+## 📦 Soul, memory, skills
 
-Granting an operator wallet ERC-721 approval would let it rotate the URI, but that same approval also lets it transfer the token away. The vault holds the token instead and exposes only a URI-rotation lane for that agent. Operators never receive token approval or transfer rights, cannot touch ENS, and cannot grant rights to other operators. The owner still signs to authorize or revoke operators for the agent, withdraw the token, or transfer the agent.
+- **Soul** (`SOUL.md`): who it is, your standards, your voice, the way you work.
+- **Memory** (`MEMORY.md`): what it has learned about you, your preferences, and your projects, so context survives the move to a new machine.
+- **Skills:** the commands, tools, and prompts you teach it. Public by default, so other agents can discover them; mark one private to keep it off your public Agent Card (the profile your token publishes).
 
-## ENS Names
+You grow these mostly by talking: with the plugin on, your agent updates its own soul and memory as you converse, and the changes sync automatically. To edit them by hand, open `ethagent`. To save your agent onchain so it can come back on any machine, choose **Save Snapshot** and sign.
 
-Subdomains live under a parent name you control, never on root `.eth` names directly. You keep `you.eth`; the agent gets `agent.you.eth`. The split makes the boundary explicit: one address speaks for the human, the other speaks for the agent.
+## 💡 How it works
 
-ENS records stay owner-controlled in both custody modes. Operator wallets in Advanced custody rotate the ERC-8004 token URI through the vault (see Custody Modes), not ENS. Any ENS text-record update requires an owner signature.
+1. **Own it.** Your wallet holds an ERC-8004 token; that token, not a platform account, is the agent.
+2. **Configure it.** Shape its soul, memory, and skills under an ENS name you own.
+3. **Save it.** `ethagent` encrypts everything on your machine, stores the encrypted copy on IPFS, and updates your token to point at it.
+4. **Restore it.** On any machine, `ethagent` finds your agent automatically from your connected wallet, or by ENS name or token id, then reads the pointer, asks your wallet to sign, and fetches and decrypts the snapshot to rebuild it.
 
-Save the token ID and network somewhere safe. ENS records can be cleared and rebuilt; the token ID is the durable handle.
+## ✨ Using your agent
 
-## Token Transfers
+**Claude Code comes first.** Install the plugin and your agent shows up in every session, already up to date, and anything it learns gets saved back. Nothing to set up.
 
-**Prepare Token Transfer** runs before any ERC-8004 token transfer, and only when the token sits directly in your wallet. An agent in Advanced custody has to switch to Simple first from Custody Mode, which unwraps the token from its vault back to the owner wallet.
+Using another harness? You can still sync, but only Claude Code does it automatically: the plugin's hooks refresh on every session and after edits. Anywhere else, you run it yourself whenever you want to pull changes in:
 
-- Sender signs snapshot access, receiver signs restore access.
-- Sender publishes the snapshot pointer to the agent URI.
-- The actual transfer happens externally afterwards, in whichever wallet UI you prefer.
-- Once the token has moved, the receiver opens **Switch Agent** with the receiving wallet and restores the same agent from the published snapshot.
+```bash
+npx ethagent --sync
+```
 
-## Models
+It syncs files between `ethagent` and your harness on this machine, but only when you run it. To back it up so you can restore it anywhere, open `ethagent` and choose **Save Snapshot**.
 
-ethagent works with OpenAI, Anthropic, Gemini, and local GGUF models served through a llama.cpp-compatible endpoint.
+## 🔒 What stays private
 
-- The model picker discovers provider models, manages API keys, recommends GGUF files for the host machine's memory and CPU, and starts or attaches to a local llama.cpp runner.
-- The featured local model is [Qwen3.5-9B-Uncensored](https://huggingface.co/HauhauCS/Qwen3.5-9B-Uncensored-HauhauCS-Aggressive); other Hugging Face GGUF models work by repo ID or direct URL.
-- Cloud API keys live in the OS keyring when one is available, with an encrypted local file under `~/.ethagent` as fallback.
+Everything is encrypted on your machine before it leaves: `SOUL.md`, `MEMORY.md`, and every skill.
 
-### Image Input
+- The encryption keys come from a wallet signature `ethagent` never sees. Signing it is free and moves none of your money. (Saving a backup is separate: it updates your token, a normal transaction with a small fee, usually less than a cent on Base.)
+- Even a public skill keeps its body encrypted: only its name and description go on the Agent Card. That card, carried by your token, also publishes your agent's profile (name, description, optional image) and your owner wallet, which is already public as the token holder.
+- Private skills, soul, and memory are never exposed.
 
-Press `Alt+V` to paste an image from the clipboard. Vision works on current OpenAI, Anthropic, and Gemini models, and on local GGUF models loaded with an `mmproj-*.gguf` projector.
+In short: the network stores a locked box, and only your wallet holds the key.
 
-## Tools and Sessions
+## 🔑 Custody
 
-- File ops, shell, clipboard, and MCP tools all run through the same permission layer.
-- Managed edits support `/rewind` to step back through changes.
-- Sessions support `/resume` to continue a previous conversation, `/compact` to summarize the running context, and `/export` to write a transcript to disk.
-- `Shift+Tab` cycles between Plan, Accept-Edits, and Chat modes.
-- `Alt+T` toggles the reasoning display.
+You choose how tightly the agent is held, and you can change it later.
 
-## Privacy
+- **Simple.** One wallet owns the agent and signs every save. The default for solo use.
+- **Advanced.** Most people never need this. Your main wallet owns the agent and keeps it in a Vault, while extra "operator" wallets you approve can save backups and publish updates without the main wallet signing each time. The Vault still lets only the owner move or sell the agent, so operators can **never** take it.
 
-- **Public:** token ownership, the agent URI, the Agent Card it references, and IPFS CIDs.
-- **Private:** plaintext `SOUL.md`, plaintext `MEMORY.md`, the local skills/ tree, sessions, prompt history, API keys, local permissions, and the wallet signatures used for decryption.
-- Snapshots use a wallet signature as unlock material. The signature does not submit a transaction, spend funds, or grant token approval.
-- `ethagent reset` clears local ethagent data from the current machine while preserving installed local model assets; it does not touch onchain state or pinned IPFS content. Run **Save Snapshot Now** first if local edits should become the recoverable state.
+To move the agent to another wallet, stage a transfer snapshot in `ethagent`. Both wallets sign locally to re-encrypt the soul, memory, and skills for the new owner, so both have to be available on the same machine. Then transfer the token, and the new owner restores the agent exactly as you left it.
 
-## Architecture
+## 🔍 Architecture
 
-| Layer | Role |
-| --- | --- |
-| Runtime | Terminal chat UI, sessions, context, permissions, and workspace tools. |
-| Model | Cloud provider or local GGUF runner. |
-| Identity | ERC-8004 token owned by the wallet. |
-| Continuity | Private files encrypted before IPFS pinning. |
-| Discovery | The agent URI and the Agent Card it points to. |
-| Recovery | Refetch the current agent URI, decrypt the latest snapshot, and restore local files. |
+Built on open standards, so your agent is never tied to one harness.
 
-## Development
+| Layer | Built on | What it does |
+| --- | --- | --- |
+| Ownership | ERC-8004 | The onchain token your wallet holds, on Ethereum mainnet or Base. Owning it is what makes the agent yours. |
+| Discovery | Agent Card | Your public profile and skill listing, carried by the token, so other agents can find yours. |
+| Naming | ENS | A human-readable name that resolves to your agent and restores it from the name alone. |
+| Backup | IPFS snapshot | The encrypted bundle of soul, memory, and skills, pinned offchain and unlocked only by your wallet. |
 
-```bash
-git clone https://github.com/baairon/ethagent.git
-cd ethagent && npm install
-npm start
-```
+## ⌨️ Commands
 
-`npm run build` is a type-check pass; the published CLI runs the shipped TypeScript directly through `tsx`.
+Run with `npx ethagent`:
 
 | Command | What it does |
 | --- | --- |
-| `npm start` | Run from source. |
-| `npm run build` | Validate the shipped TypeScript source package. |
-| `npm test` | Test suite. |
-| `npm run typecheck` | Run the same TypeScript check directly. |
-| `npm run contracts:test` | Foundry tests (only needed for `contracts/` changes). |
-
-## Contributing
-
-Contributions are welcome. For anything beyond a typo, open an issue first at [github.com/baairon/ethagent/issues](https://github.com/baairon/ethagent/issues) so the scope and approach can be agreed before code is written. Each PR should cover one logical change, include a clear description, and list the commands you ran for testing. Contributions are released under the MIT license.
-
-[npm](https://www.npmjs.com/package/ethagent) | [GitHub](https://github.com/baairon/ethagent) | [ERC-8004](https://eips.ethereum.org/EIPS/eip-8004) | [soul.md](https://soul.md/)
+| `ethagent` | Open the interactive identity manager: create, ENS, custody, snapshots, transfer. |
+| `--sync` | Sync soul, memory, and public skills into every harness it detects. |
+| `--sync-list` | List sync adapters and which ones detect in the current environment. |
+| `--status` | Print a one-line identity summary. |
+| `--demo` | Walk the manager with synthetic data, no wallet needed. |
+| `reset` | Delete local identity, continuity, and secrets. |

package/commands/ethagent.md

@@ -0,0 +1,40 @@
+---
+name: ethagent
+description: Point the user at ethagent. ethagent stores an agent's identity onchain via ERC-8004 and syncs its soul, memory, and public skills into the active harness (Claude Code or Codex) on every SessionStart. To manage identity (create, ENS, custody, snapshots, transfer), the user runs `npx ethagent` in a separate terminal.
+---
+
+Tell the user to run these in a separate terminal window, not inside this session:
+
+- `npx ethagent` opens the interactive identity manager for anything that needs a wallet signature (create agent, set ENS, switch custody, save snapshot, prepare transfer).
+- `npx ethagent --sync` syncs the agent's soul, memory, and skills with every detected harness; soul and memory sync both ways, newest edit wins.
+- `npx ethagent --sync-list` shows which harnesses ethagent detects on this machine.
+- `npx ethagent --demo` walks the identity manager with synthetic data, no wallet or network required.
+- `npx ethagent --status` prints a one-line summary (agent id, chain, address).
+- `npx ethagent reset` deletes the local identity, continuity, and secrets.
+
+To rebuild the agent on a new machine, the user runs `npx ethagent`; it restores the identity from an ENS name or ERC-8004 token id, then asks the wallet to sign.
+
+You may run the non-interactive flags yourself when it helps (`--sync`, `--status`, `--sync-list`). Never launch the bare interactive `npx ethagent` or `--demo` from inside a session: they open a full-screen terminal app that needs a TTY and will hang the tool call. Anything that needs a wallet signature, the user always runs themselves.
+
+Where the synced files land:
+
+- Public skills appear under `~/.claude/skills/` (per-skill folders) for Claude Code and inside `~/.codex/AGENTS.md` (managed block) for Codex.
+- Private skills stay encrypted in `~/.ethagent/continuity/` and only exist locally on the machine that signs.
+
+Privacy and secrets:
+
+- Soul, memory, and every skill are encrypted on the machine before they leave it. Marking a skill public does not decrypt it; it only lists that skill's name and description in the onchain Agent Card so other agents can discover it. The body stays encrypted in the vault and is mirrored in plaintext only into local harness skill folders on the signing machine.
+- Never write secrets (private keys, API tokens, seed phrases) into soul, memory, or skills; they get pinned to IPFS (encrypted, but off the machine). Keep secrets out of the vault.
+
+Where durable identity belongs (while this plugin is active):
+
+The agent's portable identity lives in the ethagent vault and syncs into every harness, so anything durable that should follow the agent must be stored there, not in a single harness's local memory.
+
+- A standing user preference, an operating principle, a standard, or a project fact -> write it into the vault, never into one harness's per-project memory.
+  - Durable preferences and project facts go in the vault `MEMORY.md` (`~/.ethagent/continuity/<agent-id>/MEMORY.md`, under `## Durable User Preferences`).
+  - Voice, standards, operating principles, and boundaries go in the vault `SOUL.md` in the same folder.
+- The vault files are the source of truth. After editing them, run `npx ethagent --sync` so the change propagates into `~/.claude/CLAUDE.md`, `~/.codex/AGENTS.md`, and any other detected harness.
+- Do NOT store durable identity in Claude Code's per-project memory (`~/.claude/projects/<slug>/memory/`): the sync treats those files as write-only mirror targets and overwrites them, and they never reach Codex or the encrypted backup. Keep only session- or repo-specific scratch notes there.
+- Syncing is not backup. To persist durable changes into the encrypted IPFS snapshot and onchain pointer, the user runs `npx ethagent` and chooses Save Snapshot (needs a wallet signature).
+
+If they ask "what's my agent" or "list my skills" without an identity yet, point them at `npx ethagent` to set one up first.

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "ethagent",
-  "version": "3.3.4",
-  "description": "A privacy-first AI agent with a portable Ethereum identity",
+  "version": "4.1.0",
+  "description": "Portable Ethereum identity for your AI agent. Its soul, memory, and skills live onchain via ERC-8004 + IPFS and snap back into any session.",
   "type": "module",
-  "main": "bin/ethagent.js",
   "bin": {
     "ethagent": "bin/ethagent.js"
   },
   "files": [
     "bin",
     "src",
+    ".claude-plugin",
+    "commands",
     "README.md",
     "LICENSE"
   ],
@@ -28,37 +29,34 @@
   },
   "keywords": [
     "ethereum",
+    "identity",
+    "ai-agent",
     "erc-8004",
     "ens",
-    "ai-agent",
-    "cli",
-    "privacy",
+    "claude-code",
     "ipfs",
     "wallet",
-    "llm",
-    "gguf",
-    "mcp",
-    "identity"
+    "privacy"
   ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/baairon/ethagent.git"
   },
-  "author": "bairon.eth",
+  "homepage": "https://github.com/baairon/ethagent#readme",
+  "bugs": {
+    "url": "https://github.com/baairon/ethagent/issues"
+  },
+  "author": "bairon.dev",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
     "@noble/curves": "^1.9.7",
     "@noble/hashes": "^1.8.0",
     "@noble/post-quantum": "^0.6.1",
-    "ajv": "^8.18.0",
-    "cli-highlight": "^2.1.11",
-    "esbuild": "^0.27.7",
+    "esbuild": "^0.27.0",
     "ink": "^6.8.0",
     "react": "^19.2.4",
     "tsx": "^4.21.0",
     "viem": "^2.48.4",
-    "wrap-ansi": "^9.0.2",
     "zod": "^3.25.76"
   },
   "devDependencies": {

package/src/app/keybindings/KeybindingProvider.tsx

@@ -25,11 +25,6 @@ type ProviderProps = {
 const DEFAULT_BINDINGS: Binding[] = [
   { context: 'Global', chord: { key: 'c', ctrl: true }, action: 'app:interrupt' },
   { context: 'Global', chord: { key: 'l', ctrl: true }, action: 'app:redraw' },
-  { context: 'Chat', chord: { key: 'escape' }, action: 'chat:cancel' },
-  { context: 'Chat', chord: { key: 'p', meta: true }, action: 'chat:modelPicker' },
-  { context: 'Chat', chord: { key: 'i', meta: true }, action: 'chat:identityHub' },
-  { context: 'Chat', chord: { key: 't', meta: true }, action: 'chat:toggleReasoning' },
-  { context: 'Chat', chord: { key: 'tab', shift: true }, action: 'chat:cycleMode' },
 ]
 
 export const KeybindingProvider: React.FC<ProviderProps> = ({ bindings = DEFAULT_BINDINGS, children }) => {
@@ -109,7 +104,7 @@ export function useKeybinding(
   options: UseKeybindingOptions = {},
 ): void {
   const ctx = useOptionalKeybindingContext()
-  const context = options.context ?? 'Chat'
+  const context = options.context ?? 'Global'
   const isActive = options.isActive ?? true
   const handlerRef = useRef(handler)
   useEffect(() => { handlerRef.current = handler }, [handler])

package/src/app/keybindings/types.ts

@@ -1,13 +1,8 @@
-export type KeybindingContextName = 'Global' | 'Chat' | 'Overlay'
+export type KeybindingContextName = 'Global'
 
 export const ACTIONS = [
   'app:interrupt',
   'app:redraw',
-  'chat:cancel',
-  'chat:modelPicker',
-  'chat:identityHub',
-  'chat:cycleMode',
-  'chat:toggleReasoning',
 ] as const
 
 export type Action = (typeof ACTIONS)[number]

package/src/cli/ResetConfirmView.tsx

@@ -1,75 +1,76 @@
-import React from 'react'
-import { Box, Text, useApp } from 'ink'
+import React, { useEffect, useState } from 'react'
+import { Box, Text, useApp, useStdout } from 'ink'
 import { Surface } from '../ui/Surface.js'
 import { Select } from '../ui/Select.js'
 import { theme } from '../ui/theme.js'
-import type { FactoryResetPlan } from '../storage/factoryReset.js'
-
-type SectionTone = 'destructive' | 'safe' | 'untouched'
+import { Wordmark } from '../identity/manager/shared/components/Wordmark.js'
+import type { ResetPlan } from '../storage/reset.js'
 
 export const ResetConfirmView: React.FC<{
-  plan: FactoryResetPlan
+  plan: ResetPlan
   onDone: (confirmed: boolean) => void
 }> = ({ plan, onDone }) => {
   const { exit } = useApp()
+  const { stdout } = useStdout()
+  const [rows, setRows] = useState<number>(stdout?.rows ?? 24)
+
+  useEffect(() => {
+    if (!stdout) return
+    const onResize = () => setRows(stdout.rows ?? 24)
+    stdout.on('resize', onResize)
+    return () => { stdout.off('resize', onResize) }
+  }, [stdout])
+
   const finish = (confirmed: boolean) => {
     onDone(confirmed)
     exit()
   }
 
   return (
-    <Surface
-      title="Reset Local Data?"
-      subtitle="Deletes this machine's ethagent data. Models and onchain records stay."
-      footer="enter select · esc cancel"
-      tone="error"
-    >
-      <Box flexDirection="column">
-        <Section tone="destructive" title="Deletes" lines={[
-          'Identity files, sessions, history, credentials',
-          localDataLine(plan.deletePaths.length),
-        ]} />
-        <Section tone="safe" title="Keeps" lines={[
-          'Local GGUF models and llama.cpp runners',
-          ...(plan.preservedPaths.length > 0 ? [`${plan.preservedPaths.length} local model path${plan.preservedPaths.length === 1 ? '' : 's'}`] : ['No local model assets found']),
-        ]} />
-        <Section tone="untouched" title="Not Touched" lines={[
-          'ERC-8004 tokens and onchain records',
-          'IPFS snapshots and public metadata',
-        ]} />
-      </Box>
-      <Box marginTop={1}>
-        <Select<'confirm' | 'cancel'>
-          options={[
-            { value: 'confirm', label: 'Yes, reset local data', hint: 'Delete local ethagent data on this machine', bold: true },
-            { value: 'cancel', label: 'No, cancel', hint: 'Leave local data unchanged', role: 'utility' },
-          ]}
-          hintLayout="inline"
-          initialIndex={1}
-          onSubmit={choice => finish(choice === 'confirm')}
-          onCancel={() => finish(false)}
-        />
+    <Box flexDirection="column" alignItems="center" justifyContent="center" width="100%" minHeight={rows}>
+      <Wordmark />
+      <Box flexDirection="column" marginTop={1} width="100%">
+        <Surface
+          title="Reset ethagent?"
+          subtitle="This only clears the current machine."
+          footer="enter select · esc cancel"
+          tone="error"
+        >
+          <Box flexDirection="column">
+            <Section title="Deletes" color={theme.accentError} lines={[
+              plan.configDir,
+              'soul, memory, skills, and config',
+              'your saved Pinata token',
+              "ethagent's block in your harness files (CLAUDE.md, AGENTS.md)",
+            ]} />
+            <Section title="Kept" color={theme.dim} lines={[
+              'your ERC-8004 token and ENS name',
+              'published snapshots on IPFS',
+            ]} />
+          </Box>
+          <Box marginTop={1}>
+            <Select<'confirm' | 'cancel'>
+              options={[
+                { value: 'confirm', label: 'Reset everything', hint: 'Clears local data', bold: true },
+                { value: 'cancel', label: 'Cancel', hint: 'Leave everything as is' },
+              ]}
+              hintLayout="inline"
+              initialIndex={1}
+              onSubmit={choice => finish(choice === 'confirm')}
+              onCancel={() => finish(false)}
+            />
+          </Box>
+        </Surface>
       </Box>
-    </Surface>
+    </Box>
   )
 }
 
-const Section: React.FC<{ tone: SectionTone; title: string; lines: string[] }> = ({ tone, title, lines }) => (
+const Section: React.FC<{ title: string; color: string; lines: string[] }> = ({ title, color, lines }) => (
   <Box flexDirection="column" marginBottom={1}>
-    <Text color={sectionTitleColor(tone)}>{title}</Text>
-    {lines.map(line => (
-      <Text key={line} color={theme.textSubtle}>· {line}</Text>
+    <Text color={color}>{title}</Text>
+    {lines.map((line, i) => (
+      <Text key={i} color={theme.textSubtle}>· {line}</Text>
     ))}
   </Box>
 )
-
-function sectionTitleColor(tone: SectionTone): string {
-  if (tone === 'destructive') return theme.accentError
-  if (tone === 'safe') return theme.accentPeriwinkle
-  return theme.dim
-}
-
-function localDataLine(count: number): string {
-  if (count === 0) return 'No local ethagent data found'
-  return `${count} local path${count === 1 ? '' : 's'} under ~/.ethagent`
-}