nostr-bray 1.19.0 → 1.21.0

package/README.md

@@ -8,7 +8,7 @@
 [![licence](https://img.shields.io/npm/l/nostr-bray)](./LICENSE)
 [![TypeScript](https://img.shields.io/badge/TypeScript-ESM-blue)](./tsconfig.json)
 
-An MCP server that gives AI agents a full Nostr identity — not just a key pair, but a hierarchical identity tree with personas, attestations, ring signatures, encrypted DMs, and duress detection. 74 tools across 10 groups.
+An MCP server that gives AI agents a full Nostr identity — not just a key pair, but a hierarchical identity tree with personas, attestations, ring signatures, encrypted DMs, and duress detection. 77 tools across 10 groups.
 
 ## The Problem
 
@@ -16,6 +16,41 @@ AI agents interacting with Nostr today are handed a single key pair with no sepa
 
 nostr-bray solves this with nsec-tree hierarchical derivation. A single master secret generates unlimited child identities, each with its own key pair, purpose, and relay set. Private keys are zeroed from memory on eviction. Agents can switch personas mid-conversation, prove they control the master without revealing the derivation path, and activate a duress identity if compromised.
 
+## How It Works
+
+Every tool operates as the "active identity." Derive a persona, switch to it, and everything you do is signed by that persona's key — cryptographically unlinkable to the master unless you publish a proof.
+
+```
+identity-derive-persona("work")    → npub1abc...
+identity-switch("work")            → now operating as work persona
+social-post("Hello from work!")    → signed by npub1abc...
+identity-switch("master")          → back to master
+social-post("Back to main")       → signed by master npub
+```
+
+This is not just key management — it is context isolation. Each persona has its own relay set, its own contact list, and its own attestation chain. Compromise one and the others remain intact.
+
+## Comparison
+
+| Feature | nostr-bray | nak | nostr-mcp | nostr-tools |
+|---------|-----------|-----|-----------|-------------|
+| MCP server | 77 tools | [via `nak mcp`](https://github.com/fiatjaf/nak) | 5–23 tools | — |
+| CLI | 77 commands | ✓ (mature) | — | — |
+| Hierarchical identity (nsec-tree) | ✓ | — | — | — |
+| Persona switching | ✓ | — | — | — |
+| Ring signatures (anonymous proofs) | ✓ | — | — | — |
+| Shamir backup (BIP-39 words) | ✓ | — | — | — |
+| Duress detection | ✓ | — | — | — |
+| NIP-VA attestations (kind 31000) | ✓ | — | — | — |
+| Linkage proofs (blind/full) | ✓ | — | — | — |
+| NIP-46 bunker (server + client) | ✓ | ✓ (client) | partial | — |
+| NIP-17 encrypted DMs | ✓ | ✓ | ✓ | ✓ |
+| NWC Lightning payments | ✓ | — | — | — |
+| Blossom media | ✓ | ✓ | — | — |
+| NIP-29 groups | ✓ | — | — | — |
+| Tor routing (SOCKS5h) | ✓ | — | — | — |
+| 329 tests, 96% coverage | ✓ | — | — | — |
+
 ## Quick Start — CLI
 
 ```bash
@@ -68,143 +103,133 @@ Or with a secret file (recommended):
 
 ## Tool Groups
 
-### Identity (11 tools)
+### Identity (12 tools) — create, derive, switch, prove, backup, and migrate Nostr identities
 
 | Tool | Description |
 |------|-------------|
-| `identity_create` | Generate a fresh identity with BIP-39 mnemonic |
-| `identity_derive` | Derive a child identity by purpose and index |
-| `identity_derive_persona` | Derive a named persona (work, personal, anonymous) |
-| `identity_switch` | Switch active identity — all tools operate as the new identity |
-| `identity_list` | List all known identities (public info only) |
-| `identity_prove` | Create blind/full linkage proof |
-| `identity_backup_shamir` | Split master secret into Shamir shard files |
-| `identity_restore_shamir` | Reconstruct secret from shard files |
-| `identity_backup` | Fetch profile, contacts, relay list as portable bundle |
-| `identity_restore` | Re-sign migratable events under the active identity |
-| `identity_migrate` | Full migration with preview, confirmation, and linkage proof |
-
-### Social (14 tools)
+| `whoami` | Returns the active identity's npub |
+| `identity-create` | Generate a fresh identity with BIP-39 mnemonic |
+| `identity-derive` | Derive a child identity by purpose and index |
+| `identity-derive-persona` | Derive a named persona (work, personal, anonymous) |
+| `identity-switch` | Switch active identity — all tools operate as the new identity |
+| `identity-list` | List all known identities (public info only) |
+| `identity-prove` | Create blind/full linkage proof |
+| `identity-backup-shamir` | Split master secret into Shamir shard files |
+| `identity-restore-shamir` | Reconstruct secret from shard files |
+| `identity-backup` | Fetch profile, contacts, relay list as portable bundle |
+| `identity-restore` | Re-sign migratable events under the active identity |
+| `identity-migrate` | Full migration with preview, confirmation, and linkage proof |
+
+### Social (14 tools) — post, reply, react, DM, follow, and read feeds
 
 | Tool | Description |
 |------|-------------|
-| `social_post` | Post a text note (kind 1) |
-| `social_reply` | Reply with correct e-tag and p-tag threading |
-| `social_react` | React to an event (kind 7) |
-| `social_delete` | Request deletion of your event (kind 5) |
-| `social_repost` | Repost/boost an event (kind 6) |
-| `social_profile_get` | Fetch and parse a kind 0 profile |
-| `social_profile_set` | Set profile with overwrite safety guard |
-| `dm_send` | Send encrypted DM (NIP-17 default, NIP-04 opt-in) |
-| `dm_read` | Read and decrypt received DMs |
-| `contacts_get` | Fetch contact list (kind 3 follows) |
-| `contacts_follow` | Follow a pubkey (publishes updated kind 3) |
-| `contacts_unfollow` | Unfollow a pubkey |
-| `social_notifications` | Fetch mentions, replies, reactions, zap receipts |
-| `social_feed` | Fetch kind 1 text note feed |
-
-### Trust (11 tools)
+| `social-post` | Post a text note (kind 1) |
+| `social-reply` | Reply with correct e-tag and p-tag threading |
+| `social-react` | React to an event (kind 7) |
+| `social-delete` | Request deletion of your event (kind 5) |
+| `social-repost` | Repost/boost an event (kind 6) |
+| `social-profile-get` | Fetch and parse a kind 0 profile |
+| `social-profile-set` | Set profile with overwrite safety guard |
+| `dm-send` | Send encrypted DM (NIP-17 default, NIP-04 opt-in) |
+| `dm-read` | Read and decrypt received DMs |
+| `contacts-get` | Fetch contact list (kind 3 follows) |
+| `contacts-follow` | Follow a pubkey (publishes updated kind 3) |
+| `contacts-unfollow` | Unfollow a pubkey |
+| `social-notifications` | Fetch mentions, replies, reactions, zap receipts |
+| `social-feed` | Fetch kind 1 text note feed |
+
+### Trust (11 tools) — attestations, ring signatures, linkage proofs, spoken verification
 
 | Tool | Description |
 |------|-------------|
-| `trust_attest` | Create kind 31000 verifiable attestation |
-| `trust_read` | Read attestations by subject/type/attestor |
-| `trust_verify` | Validate attestation structure |
-| `trust_revoke` | Revoke an attestation (identity check) |
-| `trust_request` | Send attestation request via NIP-17 |
-| `trust_request_list` | Scan DMs for attestation requests |
-| `trust_proof_publish` | Publish linkage proof (kind 30078) with confirmation |
-| `trust_ring_prove` | Anonymous group membership proof (ring signature) |
-| `trust_ring_verify` | Verify ring signature proof |
-| `trust_spoken_challenge` | Generate spoken verification token |
-| `trust_spoken_verify` | Verify spoken token response |
-
-### Relay (4 tools)
+| `trust-attest` | Create kind 31000 verifiable attestation |
+| `trust-read` | Read attestations by subject/type/attestor |
+| `trust-verify` | Validate attestation structure |
+| `trust-revoke` | Revoke an attestation (identity check) |
+| `trust-request` | Send attestation request via NIP-17 |
+| `trust-request-list` | Scan DMs for attestation requests |
+| `trust-proof-publish` | Publish linkage proof (kind 30078) with confirmation |
+| `trust-ring-prove` | Anonymous group membership proof (ring signature) |
+| `trust-ring-verify` | Verify ring signature proof |
+| `trust-spoken-challenge` | Generate spoken verification token |
+| `trust-spoken-verify` | Verify spoken token response |
+
+### Relay (5 tools) — per-identity relay lists, NIP-65 management, direct queries
 
 | Tool | Description |
 |------|-------------|
-| `relay_list` | List relays with shared-relay warnings |
-| `relay_set` | Publish kind 10002 relay list |
-| `relay_add` | Add relay to active identity (in-memory) |
-| `relay_info` | Fetch NIP-11 relay information document |
+| `relay-list` | List relays with shared-relay warnings |
+| `relay-set` | Publish kind 10002 relay list |
+| `relay-add` | Add relay to active identity (in-memory) |
+| `relay-query` | Query events from relays by kind, author, tags, or time range |
+| `relay-info` | Fetch NIP-11 relay information document |
 
-### Zap (7 tools)
+### Zap (7 tools) — Lightning payments and invoices via Nostr Wallet Connect
 
 | Tool | Description |
 |------|-------------|
-| `zap_send` | Pay a Lightning invoice via NWC |
-| `zap_balance` | Request wallet balance via NWC |
-| `zap_make_invoice` | Generate a Lightning invoice via NWC |
-| `zap_lookup_invoice` | Check invoice payment status via NWC |
-| `zap_list_transactions` | List recent Lightning transactions |
-| `zap_receipts` | Parse zap receipts (amount, sender, message) |
-| `zap_decode` | Decode bolt11 invoice fields |
+| `zap-send` | Pay a Lightning invoice via NWC |
+| `zap-balance` | Request wallet balance via NWC |
+| `zap-make-invoice` | Generate a Lightning invoice via NWC |
+| `zap-lookup-invoice` | Check invoice payment status via NWC |
+| `zap-list-transactions` | List recent Lightning transactions |
+| `zap-receipts` | Parse zap receipts (amount, sender, message) |
+| `zap-decode` | Decode bolt11 invoice fields |
 
-### Safety (2 tools)
+### Safety (2 tools) — duress personas for coercion resistance
 
 | Tool | Description |
 |------|-------------|
-| `safety_configure` | Configure an alternative identity persona |
-| `safety_activate` | Switch to alternative identity |
+| `safety-configure` | Configure an alternative identity persona |
+| `safety-activate` | Switch to alternative identity |
 
-### Blossom (3 tools)
+### Blossom (3 tools) — media uploads and management
 
 | Tool | Description |
 |------|-------------|
-| `blossom_upload` | Upload file to a blossom media server |
-| `blossom_list` | List blobs for a pubkey |
-| `blossom_delete` | Delete a blob by SHA-256 hash |
+| `blossom-upload` | Upload file to a blossom media server |
+| `blossom-list` | List blobs for a pubkey |
+| `blossom-delete` | Delete a blob by SHA-256 hash |
 
-### Groups — NIP-29 (4 tools)
+### Groups — NIP-29 (4 tools) — group chat, metadata, and membership
 
 | Tool | Description |
 |------|-------------|
-| `group_info` | Fetch group metadata |
-| `group_chat` | Read group chat messages |
-| `group_send` | Send message to a group |
-| `group_members` | List group members |
+| `group-info` | Fetch group metadata |
+| `group-chat` | Read group chat messages |
+| `group-send` | Send message to a group |
+| `group-members` | List group members |
 
-### Community NIPs (2 tools)
+### Community NIPs (2 tools) — publish and read community-proposed NIPs
 
 | Tool | Description |
 |------|-------------|
-| `nip_publish` | Publish a community NIP (kind 30817) |
-| `nip_read` | Fetch community NIPs |
+| `nip-publish` | Publish a community NIP (kind 30817) |
+| `nip-read` | Fetch community NIPs |
 
-### Utility (16 tools)
+### Utility (18 tools) — encode, decode, encrypt, verify, filter, fetch, browse NIPs
 
 | Tool | Description |
 |------|-------------|
 | `decode` | Decode npub/nsec/note/nevent/nprofile/naddr |
-| `encode_npub` | Encode hex pubkey as npub |
-| `encode_note` | Encode hex event ID as note |
-| `encode_nprofile` | Encode pubkey + relays as nprofile |
-| `encode_nevent` | Encode event ID + relays as nevent |
-| `encode_naddr` | Encode addressable event as naddr |
-| `encode_nsec` | Encode hex private key as nsec |
-| `key_public` | Derive pubkey from secret key |
-| `verify_event` | Verify event hash and signature |
+| `encode-npub` | Encode hex pubkey as npub |
+| `encode-note` | Encode hex event ID as note |
+| `encode-nprofile` | Encode pubkey + relays as nprofile |
+| `encode-nevent` | Encode event ID + relays as nevent |
+| `encode-naddr` | Encode addressable event as naddr |
+| `encode-nsec` | Encode hex private key as nsec |
+| `key-public` | Derive pubkey from secret key |
+| `key-encrypt` | Encrypt a secret key with a password (NIP-49 ncryptsec) |
+| `key-decrypt` | Decrypt an ncryptsec (NIP-49) with a password |
+| `verify-event` | Verify event hash and signature |
 | `filter` | Test if an event matches a filter |
-| `nip44_encrypt` | NIP-44 encrypt for a recipient |
-| `nip44_decrypt` | NIP-44 decrypt from a sender |
+| `nip44-encrypt` | NIP-44 encrypt for a recipient |
+| `nip44-decrypt` | NIP-44 decrypt from a sender |
 | `count` | Count events matching a filter |
 | `fetch` | Fetch events by nip19 code |
-| `nip_list` | List all official NIPs |
-| `nip_show` | Show a specific NIP's content |
-
-## Identity Switching
-
-The killer feature. Every tool operates as the "active identity." Switch with a single call:
-
-```
-identity_derive_persona("work")    → npub1abc...
-identity_switch("work")            → now operating as work persona
-social_post("Hello from work!")    → signed by npub1abc...
-identity_switch("master")          → back to master
-social_post("Back to main")       → signed by master npub
-```
-
-Derived identities are cryptographically unlinkable unless you publish a linkage proof.
+| `nip-list` | List all official NIPs |
+| `nip-show` | Show a specific NIP's content |
 
 ## Configuration
 

package/dist/catalog.d.ts

@@ -0,0 +1,35 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+type ToolHandler = (args: any) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+/**
+ * Holds non-promoted tool definitions and exposes them via search-actions
+ * and execute-action meta-tools. This keeps the primary tool list lean
+ * (context-window economics) while still making every action discoverable.
+ */
+export declare class ActionCatalog {
+    private readonly entries;
+    add(name: string, definition: any, handler: ToolHandler): void;
+    get size(): number;
+    search(intent: string): Array<{
+        name: string;
+        description: string;
+        parameters?: Record<string, string>;
+    }>;
+    execute(name: string, params: Record<string, unknown>): Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+    }>;
+    registerMetaTools(server: McpServer): void;
+}
+/**
+ * Create a proxy around McpServer that intercepts registerTool calls.
+ * Promoted tools go to the real server; everything else goes to the catalog.
+ */
+export declare function createCatalogProxy(server: McpServer, catalog: ActionCatalog, promoted: Set<string>): McpServer;
+export {};

package/dist/catalog.js

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+/**
+ * Holds non-promoted tool definitions and exposes them via search-actions
+ * and execute-action meta-tools. This keeps the primary tool list lean
+ * (context-window economics) while still making every action discoverable.
+ */
+export class ActionCatalog {
+    entries = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    add(name, definition, handler) {
+        this.entries.set(name, {
+            name,
+            description: definition.description ?? '',
+            inputSchema: definition.inputSchema,
+            annotations: definition.annotations,
+            handler,
+        });
+    }
+    get size() {
+        return this.entries.size;
+    }
+    search(intent) {
+        const tokens = intent.toLowerCase().split(/[\s\-_]+/).filter(t => t.length > 1);
+        const scored = [];
+        for (const entry of this.entries.values()) {
+            const haystack = `${entry.name} ${entry.description}`.toLowerCase();
+            let score = 0;
+            for (const token of tokens) {
+                if (haystack.includes(token))
+                    score++;
+            }
+            if (score > 0)
+                scored.push({ entry, score });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, 10).map(({ entry }) => ({
+            name: entry.name,
+            description: entry.description,
+            parameters: extractParams(entry.inputSchema),
+        }));
+    }
+    async execute(name, params) {
+        const entry = this.entries.get(name);
+        if (!entry) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Unknown action "${name}". Use search-actions to find available actions.`,
+                        }),
+                    }],
+            };
+        }
+        if (entry.inputSchema && Object.keys(entry.inputSchema).length > 0) {
+            const schema = z.object(entry.inputSchema);
+            const result = schema.safeParse(params);
+            if (!result.success) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'Invalid parameters',
+                                action: name,
+                                issues: result.error.issues.map(i => `${i.path.join('.')}: ${i.message}`),
+                                expected: extractParams(entry.inputSchema),
+                            }, null, 2),
+                        }],
+                };
+            }
+            return entry.handler(result.data);
+        }
+        return entry.handler(params);
+    }
+    registerMetaTools(server) {
+        const catalog = this;
+        server.registerTool('search-actions', {
+            description: `Search ${catalog.size} additional actions by describing what you want to do. ` +
+                'Returns matching actions with names, descriptions, and parameter schemas. ' +
+                'Use this when the promoted tools (whoami, social-post, social-reply, social-feed, ' +
+                'dm-send, dm-read, zap-send, zap-balance, identity-switch, relay-query) ' +
+                'do not cover what you need.',
+            inputSchema: {
+                intent: z.string().describe('Describe what you want to do (e.g. "upload a file", "verify an attestation", ' +
+                    '"encrypt a message", "manage contacts", "ring signature")'),
+            },
+            annotations: { readOnlyHint: true },
+        }, async ({ intent }) => {
+            const matches = catalog.search(intent);
+            if (matches.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                matches: [],
+                                hint: 'No matches found. Try different keywords or broader terms.',
+                            }, null, 2),
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ matches }, null, 2),
+                    }],
+            };
+        });
+        server.registerTool('execute-action', {
+            description: 'Execute an action found via search-actions. Pass the exact action name and its parameters.',
+            inputSchema: {
+                action: z.string().describe('Action name from search-actions results'),
+                params: z.record(z.string(), z.unknown()).default({}).describe('Parameters for the action (see search-actions results for expected params)'),
+            },
+            annotations: { openWorldHint: true },
+        }, async ({ action, params }) => {
+            return catalog.execute(action, params);
+        });
+    }
+}
+/**
+ * Create a proxy around McpServer that intercepts registerTool calls.
+ * Promoted tools go to the real server; everything else goes to the catalog.
+ */
+export function createCatalogProxy(server, catalog, promoted) {
+    return new Proxy(server, {
+        get(target, prop, receiver) {
+            if (prop === 'registerTool') {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return (name, definition, handler) => {
+                    if (promoted.has(name)) {
+                        return target.registerTool(name, definition, handler);
+                    }
+                    catalog.add(name, definition, handler);
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extractParams(schema) {
+    if (!schema || Object.keys(schema).length === 0)
+        return undefined;
+    const params = {};
+    for (const [key, zodType] of Object.entries(schema)) {
+        params[key] = zodType?.description ?? '(no description)';
+    }
+    return params;
+}

package/dist/cli.js

@@ -130,7 +130,8 @@ Social:
   group-members <group-id>           List group members
 
 Trust:
-  attest <type> <identifier> [subject]  Create kind 31000 attestation
+  attest <event-id>                     Verify someone's assertion (assertion-first)
+  claim <type>                          Make a direct claim (endorsement, vouch, review)
   trust-read [--subject X] [--type X]   Read attestations
   trust-verify <event-json>             Validate attestation structure
   trust-revoke <type> <identifier>      Revoke an attestation
@@ -473,13 +474,27 @@ async function run(cmdArgs) {
             out(await handleNotifications(ctx, pool, { limit: parseInt(flag('limit', '50'), 10) }), fmt.formatNotifications);
             break;
         // === Trust ===
-        case 'attest':
+        case 'attest': {
+            const assertionId = req(1, 'attest <assertion-event-id> [--subject <hex>] [--type <type>] [--summary <text>]');
             out(await handleTrustAttest(ctx, pool, {
-                type: req(1, 'attest <type> <identifier> [subject]'),
-                identifier: cmdArgs[2],
-                subject: cmdArgs[3],
+                assertionId,
+                subject: flag('subject'),
+                type: flag('type'),
+                summary: flag('summary'),
+                assertionRelay: flag('relay'),
             }));
             break;
+        }
+        case 'claim': {
+            const type = req(1, 'claim <type> [--subject <hex>] [--identifier <string>] [--summary <text>]');
+            out(await handleTrustAttest(ctx, pool, {
+                type,
+                subject: flag('subject'),
+                identifier: flag('identifier'),
+                summary: flag('summary'),
+            }));
+            break;
+        }
         case 'trust-read':
             out(await handleTrustRead(pool, ctx.activeNpub, {
                 subject: flag('subject'),

package/dist/identity/tools.js

@@ -14,7 +14,7 @@ export function registerIdentityTools(server, deps) {
             content: [{ type: 'text', text: deps.ctx.activeNpub }],
         };
     });
-    server.registerTool('identity_create', {
+    server.registerTool('identity-create', {
         description: 'Generate a fresh Nostr identity with a BIP-39 mnemonic seed. Returns { npub, mnemonic }. Store the mnemonic securely — it will not be shown again. Use this when the user needs a brand new identity unrelated to the current one.',
         annotations: { readOnlyHint: false },
     }, async () => {
@@ -23,7 +23,7 @@ export function registerIdentityTools(server, deps) {
             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
         };
     });
-    server.registerTool('identity_derive', {
+    server.registerTool('identity-derive', {
         description: 'Derive a child Nostr identity from the master key by purpose and index. Deterministic — same inputs always produce the same npub. Returns { npub, purpose, index }. Use identity_switch after deriving to operate as the new identity.',
         inputSchema: {
             purpose: z.string().describe('Purpose string for derivation (e.g. "messaging", "signing")'),
@@ -36,7 +36,7 @@ export function registerIdentityTools(server, deps) {
             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
         };
     });
-    server.registerTool('identity_derive_persona', {
+    server.registerTool('identity-derive-persona', {
         description: 'Derive a named persona (e.g. "work", "personal", "anonymous"). Like identity_derive but uses a human-readable name. Returns { npub, personaName, index }. Follow with identity_switch to activate.',
         inputSchema: {
             name: z.string().describe('Persona name (e.g. "work", "personal", "anonymous")'),
@@ -49,7 +49,7 @@ export function registerIdentityTools(server, deps) {
             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
         };
     });
-    server.registerTool('identity_switch', {
+    server.registerTool('identity-switch', {
         description: 'Switch the active Nostr identity. ALL subsequent tool calls will sign events and query relays as the new identity. Pass "master" to return to root. Returns { npub } of the now-active identity. This is the key tool for multi-persona workflows.',
         inputSchema: {
             target: z.string().describe('Purpose, persona name, or "master" to switch to'),
@@ -62,7 +62,7 @@ export function registerIdentityTools(server, deps) {
             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
         };
     });
-    server.registerTool('identity_list', {
+    server.registerTool('identity-list', {
         description: 'List all known identities (master + all derived). Returns array of { npub, purpose, index, personaName }. Never includes private keys. Use this to see what identities are available before switching.',
         inputSchema: {
             output: z.enum(['json', 'human']).default('human').describe('Response format'),
@@ -72,7 +72,7 @@ export function registerIdentityTools(server, deps) {
         const result = handleIdentityList(deps.ctx);
         return toolResponse(result, output, fmt.formatIdentityList);
     });
-    server.registerTool('identity_prove', {
+    server.registerTool('identity-prove', {
         description: 'Create a cryptographic linkage proof between the master key and the active identity. "blind" (default) proves they share a master without revealing how the child was derived. "full" also reveals the purpose and index. Returns a LinkageProof object that can be verified by anyone with nsec-tree. Use trust_proof_publish to make it permanent on relays.',
         inputSchema: {
             mode: z.enum(['blind', 'full']).default('blind').describe('Proof mode: "blind" hides derivation path, "full" reveals purpose and index'),
@@ -84,7 +84,7 @@ export function registerIdentityTools(server, deps) {
             content: [{ type: 'text', text: JSON.stringify(proof, null, 2) }],
         };
     });
-    server.registerTool('identity_backup_shamir', {
+    server.registerTool('identity-backup-shamir', {
         description: 'Split the active identity\'s private key into Shamir shard files using threshold secret sharing. Any "threshold" shards can reconstruct the key. Files written with 0600 permissions via atomic rename. Returns file paths only — shard content never appears in the response.',
         inputSchema: {
             threshold: z.number().int().min(2).describe('Minimum shards needed to reconstruct'),
@@ -106,7 +106,7 @@ export function registerIdentityTools(server, deps) {
                     }, null, 2) }],
         };
     });
-    server.registerTool('identity_restore_shamir', {
+    server.registerTool('identity-restore-shamir', {
         description: 'Reconstruct a secret from Shamir shard files. Returns the restored npub for verification.',
         inputSchema: {
             files: z.array(z.string()).describe('Paths to shard files'),
@@ -129,7 +129,7 @@ export function registerIdentityTools(server, deps) {
                     }, null, 2) }],
         };
     });
-    server.registerTool('identity_backup', {
+    server.registerTool('identity-backup', {
         description: 'Fetch profile, contacts, relay list, and attestations for a pubkey. Returns a portable JSON bundle (no private keys).',
         inputSchema: {
             pubkeyHex: hexId.describe('Hex pubkey to back up'),
@@ -147,7 +147,7 @@ export function registerIdentityTools(server, deps) {
                     }, null, 2) }],
         };
     });
-    server.registerTool('identity_restore', {
+    server.registerTool('identity-restore', {
         description: 'Re-sign migratable events (profile, contacts, relay list) under the active identity. Skips attestations (trust chain protection).',
         inputSchema: {
             pubkeyHex: hexId.describe('Hex pubkey of the original identity to restore from'),
@@ -162,7 +162,7 @@ export function registerIdentityTools(server, deps) {
             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
         };
     });
-    server.registerTool('identity_migrate', {
+    server.registerTool('identity-migrate', {
         description: 'Migrate from an old identity to the active one. Shows preview first — set confirm: true to execute. Publishes linkage proof and re-signs migratable events.',
         inputSchema: {
             oldPubkeyHex: z.string().describe('Hex pubkey of the old identity'),