Accounts from the header, snapshot-first Spending restore, name ownership grants.

Header buttons always leave the current feature screen; an account with
no remembered nostr identity opens Accounts instead of nothing. Logout
confirms in place. A scan finishing after logout or an account switch no
longer drops the new session into offline mode (stateGeneration guards in
sync + ark). Spending restores from the snapshot first. A migration grant
names the identity that owns an address; its manager may register it
without becoming that identity (names/ownership.js). Browser tests for
account access, profile retry, spending restore, thread reply focus,
custom-emoji reactions and registry ownership.

Co-Authored-By: Claude Fable 5.1 <[email protected]>

13 files changed, 641 insertions, 70 deletions

diff --git a/dev.js b/dev.js
index 54a88a2..347ef41 100644
--- a/dev.js
+++ b/dev.js
@@ -6,12 +6,13 @@
 // localhost or from a phone over the LAN/Tailscale — no per-device config, no
 // CORS. HTTP backends by path prefix; WebSocket backends by exact path.
 
-import { buildHtml, buildJsQr } from './build.js';
+import { buildHtml, buildJsQr, buildNip46, buildVerifyWorker } from './build.js';
 
 const port = Number(process.env.PORT || 5173);
 
 const HTTP_PROXY = { '/boltz': 'http://localhost:9001', '/esplora': 'http://localhost:3000', '/sp': 'http://localhost:8888' };
 const WS_PROXY = { '/electrum': 'ws://localhost:50003', '/sp/ws': 'ws://localhost:8888/ws' };
+const JS_ASSETS = { '/jsqr.js': buildJsQr, '/nip46.js': buildNip46, '/verify-worker.js': buildVerifyWorker };
 const CORS = { 'access-control-allow-origin': '*', 'access-control-allow-methods': 'GET,POST,OPTIONS', 'access-control-allow-headers': 'content-type' };
 
 Bun.serve({
@@ -40,11 +41,22 @@ Bun.serve({
           return new Response(await r.arrayBuffer(), { status: r.status, headers: { 'content-type': r.headers.get('content-type') || 'application/json', ...CORS } });
         }
       }
-      if (path === '/jsqr.js') {
-        return new Response(await buildJsQr({ minify: false }), {
+      if (Object.hasOwn(JS_ASSETS, path)) {
+        return new Response(await JS_ASSETS[path]({ minify: false }), {
           headers: { 'content-type': 'text/javascript; charset=utf-8', 'cache-control': NO_STORE },
         });
       }
+      if (/^\/(punks|punks-sm)\//.test(path)) {
+        // These are bundled images, not app routes. Returning index.html here
+        // produces broken avatars and rebuilds the app for every face.
+        if (!/^\/(punks|punks-sm)\/([1-9]|[1-5][0-9]|6[0-4])\.webp$/.test(path)) {
+          return new Response('Not found', { status: 404 });
+        }
+        const file = Bun.file('static' + path);
+        return await file.exists()
+          ? new Response(file, { headers: { 'content-type': 'image/webp', 'cache-control': NO_STORE } })
+          : new Response('Not found', { status: 404 });
+      }
       const loc = path.match(/^\/locales\/([a-z]{2})\.json$/);
       if (loc) {
         const f = Bun.file('src/locales/' + loc[1] + '.json');
diff --git a/names/ownership.js b/names/ownership.js
new file mode 100644
index 0000000..19ae4ef
--- /dev/null
+++ b/names/ownership.js
@@ -0,0 +1,10 @@
+// A migration grant names the identity that owns the address. Its manager
+// may submit the registration without becoming that identity.
+export function registrationIdentity({ existing, signer, manager, grant, granted }) {
+  const pubkey = existing?.pubkey || (granted ? grant.pubkey : signer);
+  const nominated = /^[0-9a-f]{64}$/.test(manager || '') && manager !== pubkey;
+  return {
+    pubkey,
+    manager: nominated ? manager : existing?.manager || (granted ? grant.manager : undefined),
+  };
+}
diff --git a/names/server.js b/names/server.js
index ed44ad3..97ac662 100644
--- a/names/server.js
+++ b/names/server.js
@@ -31,6 +31,7 @@ import { decodeAddress } from '../src/ark/proto.js';
 import { decodeNoffer } from '../src/noffer.js';
 import { decodeBolt11 } from '../src/ark/lightning.js';
 import { decodeOffer } from '../src/bolt12.js';
+import { registrationIdentity } from './ownership.js';
 
 const CFG = JSON.parse(readFileSync(process.env.NAMES_CONFIG
   || join(import.meta.dir, 'config.json'), 'utf8'));
@@ -1624,10 +1625,7 @@ Bun.serve({
 
       const recordId = await cfWrite(name, domain, published, existing?.recordId);
       state.names[key] = {
-        pubkey: existing?.pubkey || auth.pubkey,
-        // the owner may nominate a key that manages the record from here on
-        manager: (claim.manager && /^[0-9a-f]{64}$/.test(claim.manager) && auth.pubkey !== claim.manager)
-          ? claim.manager : existing?.manager,
+        ...registrationIdentity({ existing, signer: auth.pubkey, manager: claim.manager, grant, granted }),
         uri: published, recordId, updated: Date.now(), domain,
         // the wallet's CLINK offer key, so LNURL can ask it for invoices
         offerPk: (claim.offerPk && /^[0-9a-f]{64}$/.test(claim.offerPk)) ? claim.offerPk : existing?.offerPk,
diff --git a/src/app.js b/src/app.js
index 0e5ed9c..16f0595 100644
--- a/src/app.js
+++ b/src/app.js
@@ -756,7 +756,7 @@ window.addEventListener('popstate', (e) => {
   // in the browser's history. Walking Back into one with a wallet open showed
   // the start page over a perfectly open session — which reads as "I got
   // logged out". With a wallet open, those entries become the wallet home.
-  if (snap.screen && snap.screen !== 'wallet' && activeAccount() && ui.screen === 'wallet') {
+  if (['unlock', 'vault'].includes(snap.screen) && activeAccount() && ui.screen === 'wallet') {
     snap = Object.fromEntries(NAV_FIELDS.map((f) => [f, null]));
     snap.screen = 'wallet'; snap.tab = ui.tab ?? null;
     try { history.replaceState({ nav: snap, i: st && typeof st.i === 'number' ? st.i : navIndex }, ''); } catch {}
@@ -1381,6 +1381,7 @@ async function activateAccount(acc, opts = {}) {
   // reflow when the name lookup proves Spending a beat later.
   if (opts.spendingHint && !acc.spendingSetup) { acc.spendingSetup = Date.now(); }
   const netName = acc.network;
+  const stillActive = () => activeAccount() === acc && getNetwork() === netName;
   if (netName !== getNetwork()) {
     setNetwork(netName);
     for (const f of FEATURES) { try { f.networkChanged && f.networkChanged(netName); } catch {} }
@@ -1481,15 +1482,19 @@ async function activateAccount(acc, opts = {}) {
     // with no synced state); that's what discovers the used addresses. Otherwise
     // the socket + frontier poll keep us current with no refresh-time burst.
     const hadNostr = wallet.watchOnly || !wallet.syncFromNostr ? false : await wallet.syncFromNostr();
+    if (!stillActive()) return;
     if (!hadCache && !hadNostr) {
       await wallet.scan({ silent: false });
     }
+    if (!stillActive()) return;
     // Re-baseline a fresh open against the final frontier (Nostr or the discovery
     // scan may have advanced it) so payments that predate the open don't celebrate.
     if (opts.fresh) { ack = wallet.nextReceiveIndex; wallet.setReceiveAck(ack); ui.receiveSeenIndex = ack; }
     wallet.retrack(); // re-subscribe to the latest frontier (Nostr/scan may have moved it)
   } catch {
-    enterOfflineFallback();
+    // A scan can finish after logout or an account switch. Its failure must
+    // not put the new session (or an empty wallet) into offline mode.
+    if (stillActive()) enterOfflineFallback();
   }
 }
 
@@ -2267,7 +2272,8 @@ function lock({ offerPassword = false } = {}) {
 function avatarMenu() {
   const me = (featureHook('nostrLoginIdentity') || {}).pubkey || (wallet.nostrPubkey && wallet.nostrPubkey())
     || (activeAccount() || {}).nostrPk;
-  // No identity (watch-only wallet): a neutral face with nowhere to go.
+  // Older watch-only accounts may have no remembered Nostr identity. Keep
+  // account access available even when there is no profile to open.
   const node = (me && featureHook('headerAvatar', me))
     || h('span', {
       class: 'chat-avatar header-ava fallback',
@@ -2275,8 +2281,15 @@ function avatarMenu() {
     });
   return h('button', {
     class: 'header-avatar',
-    title: me ? t('profYourProfile') : undefined,
-    onClick: me ? () => { featureHook('showProfile', me); render(); } : undefined,
+    title: me ? t('profYourProfile') : t('accounts'),
+    'aria-label': me ? t('profYourProfile') : t('accounts'),
+    onClick: () => {
+      clearFeatureNav(); ui.screen = 'wallet';
+      if (!me || !featureHook('showProfile', me)) {
+        ui.screen = 'accounts';
+      }
+      render();
+    },
   }, node);
 }
 
@@ -2284,7 +2297,7 @@ function settingsBtn() {
   return h('button', {
     class: 'header-msgs', title: t('tabSettings'), 'aria-label': t('tabSettings'),
     onClick: () => {
-      ui.chatOpen = false; ui.profilePk = null; ui.userSearch = null; ui.noteThread = null;
+      clearFeatureNav();
       ui.screen = 'wallet'; ui.tab = 'settings'; ui.settingsPage = null; render();
     },
   }, h('span', {
@@ -2371,7 +2384,7 @@ function messagesBtn() {
     class: 'header-msgs' + (unread ? ' unread' : ''),
     title: t('msgDmsTitle'),
     'aria-label': t('msgDmsTitle'),
-    onClick: () => { ui.profilePk = null; ui.userSearch = null; ui.noteThread = null; ui.zapSetup = null; ui.chatOpen = true; ui.msgView = 'home'; render(); },
+    onClick: () => { clearFeatureNav(); ui.screen = 'wallet'; ui.chatOpen = true; ui.msgView = 'home'; render(); },
   }, h('span', {
     class: 'hm-ico',
     html: '<svg width="21" height="21" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"><path d="M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z"/></svg>',
@@ -2386,6 +2399,7 @@ function searchBtn() {
     title: t('searchUsers'),
     'aria-label': t('searchUsers'),
     onClick: () => {
+      clearFeatureNav(); ui.screen = 'wallet';
       featureHook('openUserSearch');
       render();
       setTimeout(() => document.querySelector('.user-search-input')?.focus(), 60);
@@ -2800,6 +2814,15 @@ function claimTargets() {
 // Account switcher: pick a wallet, add another, or lock the session.
 function accountsScreen() {
   if (ui.pw) return h('div', { class: 'col', style: 'gap:16px' }, brandHeader(false), pwPromptCard());
+  if (ui.logoutConfirm) {
+    return h('div', { class: 'col', style: 'gap:16px' },
+      brandHeader(false),
+      h('div', { class: 'card col' },
+        h('h3', {}, t('logout') + '?'),
+        h('p', { class: 'small muted' }, t('logoutPopBlurb')),
+        h('button', { class: 'btn-primary btn-block', onClick: () => { ui.logoutConfirm = null; ctx.logout(); } }, t('logout')),
+        h('button', { class: 'btn-ghost btn-block', onClick: () => { ui.logoutConfirm = null; render(); } }, t('back'))));
+  }
   if (ui.addWallet) {
     const aw = ui.addWallet;
     const fulls = accounts.filter((x) => x.type === 'full' && x.mnemonic);
@@ -2866,7 +2889,7 @@ function accountsScreen() {
     // Reached from an open wallet this is a page, not a boot screen — the
     // header icons (search, messages, settings, lock, avatar) stay put.
     // Cold boot lands here with nothing loaded yet, and then they hide.
-    brandHeader(wallet.loaded),
+    brandHeader(!!activeAccount()),
     h('div', { class: 'card col' },
       h('h3', {}, t('accounts')),
       h('div', { class: 'col', style: 'gap:0' },
@@ -2909,6 +2932,8 @@ function accountsScreen() {
         ])
       ),
       h('button', { class: 'btn-block', onClick: () => { ui.addWallet = { kind: 'spending', from: 'new' }; render(); } }, t('addWallet')),
+      h('button', { class: 'btn-block', onClick: signInAnother }, t('signInAnother')),
+      activeAccount() ? h('button', { class: 'btn-ghost btn-block', onClick: () => { ui.logoutConfirm = true; render(); } }, t('logout')) : null,
       hasVault() ? h('button', { class: 'btn-ghost btn-block', onClick: startChangePw }, t('changePassword')) : null,
       h('button', { class: 'btn-ghost btn-block', onClick: () => { ui.confirmClear = true; render(); } }, t('clearAll'))
     ),
@@ -3447,7 +3472,7 @@ function onboardScreen() {
           // a relative path; kind 0 needs the absolute URL (a relative one
           // once replaced a real profile picture with a broken string).
           const picked = o.avatar && !/^https?:/i.test(o.avatar) ? 'https://v3.coinos.io/' + o.avatar : o.avatar;
-          const picture = picked || (me ? 'https://v3.coinos.io/' + punkUrl(me) : undefined);
+          const picture = picked || (me ? new URL(punkUrl(me), 'https://v3.coinos.io/').href : undefined);
           const fields = { name: addr ? addr.split('@')[0] : undefined, picture };
           // Publishing the profile is a nicety — a signer that can't sign
           // right now (a sleeping phone bunker) must not trap the wizard.
diff --git a/src/features/ark.js b/src/features/ark.js
index 93578da..22ba5fd 100644
--- a/src/features/ark.js
+++ b/src/features/ark.js
@@ -144,11 +144,11 @@ export function installArkWallet(wallet) {
   });
 }
 
-// A slim projection of ark state for the sync snapshot — the sync relay caps
-// events at 64 KB and the full state (deep-genesis vtxo bytes + done-action
-// hex) blew past it, so publishes silently failed and nothing synced. Another
+// A slim projection of ark state for the sync snapshot. Oversized domains
+// now travel as encrypted Blossom blobs, so preserve the complete history
+// and spent-coin stubs instead of rebuilding them from the mailbox. Another
 // device needs, per vtxo: id/amount/state (+ bytes ONLY for spendable/pending,
-// which it might spend/exit); the movement log (capped) for ark history; and
+// which it might spend/exit); the movement log for ark history; and
 // done board/offboard/exit actions (stripped of hex) so on-chain rows still
 // label. In-flight actions and their signing material stay device-local.
 export function slimArkForSync(s) {
@@ -156,22 +156,20 @@ export function slimArkForSync(s) {
   const HEAVY = ['bytes', 'destBytes', 'changeBytes', 'vtxoBytes', 'txHex', 'fundingTxHex', 'outputVtxos'];
   return {
     v: s.v, serverPubkey: s.serverPubkey, mailboxCheckpoint: s.mailboxCheckpoint, nextKeyIndex: s.nextKeyIndex, receiveAckTs: s.receiveAckTs,
-    // Spent stubs and done actions are pure history and grow forever — cap
-    // them (newest kept) so the sync event's size is bounded for life.
+    // Spent stubs keep old snapshots/mailbox messages from resurrecting coins.
     vtxos: (() => {
       // On the wire the bytes stay HEX for now: a device still on a build
       // that only reads hex would otherwise fail to decode every coin merged
       // from this one. Flip to base64 once builds before 2026-09-10 are gone.
       const live = (s.vtxos || []).filter((v) => v.state !== 'spent')
         .map((v) => (v.bytes ? { ...v, bytes: vtxoBytesToHex(v.bytes) } : v));
-      const stubs = (s.vtxos || []).filter((v) => v.state === 'spent').slice(-200)
+      const stubs = (s.vtxos || []).filter((v) => v.state === 'spent')
         .map((v) => ({ id: v.id, amountSat: v.amountSat, state: 'spent', keyIndex: v.keyIndex, expiryHeight: v.expiryHeight }));
       return [...live, ...stubs];
     })(),
     actions: (() => {
       const done = (s.actions || []).filter((a) => a.step === 'done');
       const core = done.filter((a) => ['board', 'offboard', 'exit'].includes(a.type))
-        .slice(-50)
         .map((a) => { const c = { ...a }; for (const k of HEAVY) delete c[k]; return c; });
       // Spends travel as SLIVERS — id, net amount, and which coins they
       // consumed. That last field is what lets ANOTHER device recognize a
@@ -179,14 +177,13 @@ export function slimArkForSync(s) {
       // another device" row beside the synced Sent movement (one spend was
       // showing twice, at input magnitude the second time).
       const spends = done.filter((a) => ['send', 'ln-pay'].includes(a.type))
-        .slice(-100)
         .map((a) => ({
           id: a.id, type: a.type, step: 'done', amountSat: a.amountSat,
-          inputIds: (a.parts || []).map((p) => p.inputId).concat(a.inputId ? [a.inputId] : []).filter(Boolean),
+          inputIds: [...new Set([...(a.inputIds || []), ...(a.parts || []).map((p) => p.inputId), a.inputId].filter(Boolean))],
         }));
       return [...core, ...spends];
     })(),
-    movements: (s.movements || []).slice(-200).map((m, i, arr) =>
+    movements: (s.movements || []).map((m, i, arr) =>
       // Older rows only need to render a history line; the bolt11 (~400 chars
       // each) and preimage are what pushed snapshots past relay size limits.
       (arr.length - i <= 50 ? m : (({ invoice, preimage, ...rest }) => rest)(m))),
@@ -285,7 +282,12 @@ export function mergeArkStates(a, b) {
   // skips every message this device never processed — balance appears (the
   // vtxo unions in) but its receive movement and celebration never happen.
   // Keep the local checkpoint; re-read messages dedupe harmlessly.
-  out.mailboxCheckpoint = a.mailboxCheckpoint || 0;
+  const pristine = !a.mailboxCheckpoint && !a.vtxos?.length && !a.movements?.length
+    && !a.actions?.length && !a.scheduled?.length;
+  // A manager's empty shell is not local history. Restore the snapshot's
+  // cursor with its coins/history, just as the !a case above does, rather
+  // than replaying the entire mailbox on a first login.
+  out.mailboxCheckpoint = pristine ? b.mailboxCheckpoint || 0 : a.mailboxCheckpoint || 0;
   out.nextKeyIndex = Math.max(a.nextKeyIndex || 1, b.nextKeyIndex || 1);
   out.nextLnRecvIndex = Math.max(a.nextLnRecvIndex || 0, b.nextLnRecvIndex || 0);
   out.receiveAckTs = Math.max(a.receiveAckTs || 0, b.receiveAckTs || 0);
@@ -397,6 +399,7 @@ export function arkFeature(ctx) {
     for (const f of [...arkPersistFlushers]) { try { f(); } catch {} }
     arkPersistFlushers.clear();
     arkInitGen++;
+    lastAutoInit = 0;
     if (arkTimer) clearInterval(arkTimer);
     arkTimer = null;
     if (ark) ark.stopMailboxStream();
@@ -430,7 +433,6 @@ export function arkFeature(ctx) {
   function initArk() {
     stopArk();
     ui.arkError = '';
-    lastAutoInit = Date.now();
     // The ark store is IndexedDB — asynchronous to OPEN, synchronous to read
     // once it has. A boot that beats it open reads no state at all: no
     // Spending balance, no Spending history, and nothing here that looks
@@ -441,7 +443,7 @@ export function arkFeature(ctx) {
       store.open().then(() => { ctx.forgetAmountAnim && ctx.forgetAmountAnim(); render(); initArk(); }).catch(() => {});
       return;
     }
-    if (arkAvailable() && arkWanted()) connectArk().catch(() => {});
+    if (arkAvailable() && arkWanted()) { lastAutoInit = Date.now(); connectArk().catch(() => {}); }
   }
 
   // Automatic re-inits (a synced snapshot arriving) must not restart a
@@ -453,7 +455,9 @@ export function arkFeature(ctx) {
   function maybeInitArk() {
     if (ark || arkConnectPromise) return;
     if (Date.now() - lastAutoInit < 20000) return;
-    initArk();
+    // A fresh snapshot may be held under its server pubkey, so arkWanted()
+    // cannot see it until the handshake identifies the server and adopts it.
+    if (arkAvailable()) { lastAutoInit = Date.now(); connectArk().catch(() => {}); }
   }
 
   // Operator console rescue for a round participation stranded server-side
@@ -524,10 +528,13 @@ export function arkFeature(ctx) {
         const tx = (wallet.txs || []).find((t2) => t2.txid === txid2);
         return tx && tx.confirmed ? { confirmed: true, block_height: tx.blockHeight || NaN } : null;
       },
-      onUpdate: (m) => { maybeAutoSelectSpending(); scheduleLnTag(m); render(); },
+      onUpdate: (m) => { if (gen !== arkInitGen) return; maybeAutoSelectSpending(); scheduleLnTag(m); render(); },
     });
     ui.arkError = '';
-    arkConnectPromise = mgr.init().then(() => {
+    // Open the server connection while Nostr restores, but do not replay the
+    // mailbox before the snapshot's history and cursor have arrived.
+    const restored = Promise.resolve(wallet.nostrRestoreReady || wallet.syncFromNostr?.()).catch(() => false);
+    arkConnectPromise = Promise.all([mgr.init(), restored]).then(() => {
       if (gen !== arkInitGen) throw new Error('superseded'); // wallet switched mid-connect
       ark = mgr;
       // Sync may have arrived while init awaited the server handshake.
@@ -556,20 +563,24 @@ export function arkFeature(ctx) {
       // A failed mailbox read must not starve the action drives: boards and
       // refreshes progress on chain state alone, so push them even when the
       // sync itself errored.
-      const tick = () => mgr.sync().catch(() => mgr.resumePending().catch(() => {}))
+      let ticking = null;
+      const tick = () => ticking || (ticking = mgr.sync().catch(async () => {
+        // Even when mailbox catch-up fails, independently check stale coins
+        // and advance recoverable local actions.
+        await mgr.reconcile().catch(() => {});
+        await mgr.resumePending().catch(() => {});
+      })
         .then(() => driveExits(mgr)).catch(() => {})
         .then(() => { if (ark === mgr) return maybeAutoRefresh(mgr); }).catch(() => {})
-        .then(() => { if (ark === mgr) return maybeAutoWithdraw(mgr); }).catch(() => {});
-      tick();
-      // Reconcile once on connect: a vtxo synced in from another device (or
-      // one this device held while a spend happened elsewhere) is checked
-      // against the server, so a stale spendable is caught here rather than
-      // only at send time.
-      mgr.reconcile().catch(() => {});
+        .then(() => { if (ark === mgr) return maybeAutoWithdraw(mgr); }).catch(() => {})
+        .finally(() => { ticking = null; }));
+      // sync() already reconciles on its first pass. Start the live stream
+      // afterwards, at the caught-up cursor: running both together replayed
+      // the backlog one message/render at a time alongside the batch read.
+      tick().finally(() => { if (ark === mgr) mgr.startMailboxStream(); });
       mergeBgWorkerState(mgr).catch(() => {}); // absorb what the SW did while we were closed
       // Receives arrive in real time over the mailbox stream; the poll is the
       // fallback and what drives in-flight boards/refreshes forward.
-      mgr.startMailboxStream();
       scheduleLnTag(mgr); // receives that landed while this device was closed
       arkTimer = setInterval(() => { if (ark === mgr) tick(); }, getNetwork() === 'regtest' ? 5000 : 30000);
       render();
@@ -577,7 +588,7 @@ export function arkFeature(ctx) {
     }).catch((e) => {
       if (gen === arkInitGen) { ui.arkError = e.message; render(); }
       throw e;
-    }).finally(() => { arkConnectPromise = null; });
+    }).finally(() => { if (gen === arkInitGen) arkConnectPromise = null; });
     render();
     return arkConnectPromise;
   }
@@ -1543,22 +1554,28 @@ export function arkFeature(ctx) {
     // way this goes, say so, so the chip settles instead of pulsing until it
     // times out. (A handover to the Lightning flow doesn't report — that flow
     // is still carrying the same zap, and reports for itself.)
-    const bail = () => {
+    const bail = (error) => {
       if (!z.autoSat) return; // a form zap: the card keeps the screen and its own status
       ctx.hook('zapSettled', z.eventId, false);
-      z.autoSat = 0; ctx.showSend();
+      z.autoSat = 0;
+      if (z.eventId) {
+        if (ui.arkZap === z) ui.arkZap = null;
+        toast('⚡ ' + (error || t('arkZapNoArk')), 4000);
+        return true;
+      } else ctx.showSend();
     };
     // an instant zap: resolution succeeded — pay the default amount now, no
-    // form, and report by toast; failures fall back to the classic form
+    // form. Post zaps settle in place; other payments retain their form.
     const auto = async (label) => {
       try {
         await performArkZap(z, z.autoSat);
         if (ui.arkZap === z) ui.arkZap = null;
         ctx.hook('zapSettled', z.eventId, true, z.autoSat);
-        toast('⚡ ' + t('zapSentShort', { n: fmtAmount(z.autoSat) + ' ' + unitLabel() }));
+        if (!z.eventId) toast('⚡ ' + t('zapSentShort', { n: fmtAmount(z.autoSat) + ' ' + unitLabel() }));
         render();
       } catch (e) {
-        bail(); ui.sendError = e.message; render();
+        if (!bail(e.message)) ui.sendError = e.message;
+        render();
       }
     };
     (async () => {
@@ -1567,7 +1584,7 @@ export function arkFeature(ctx) {
       const adv = await lookupArkZapTarget(pk).catch(() => ({ status: 'noark' }));
       if (!live()) return;
       if (adv.status === 'ready') { Object.assign(z, adv); if (z.autoSat) return auto(); render(); return; }
-      if (adv.status === 'wrongnet') { Object.assign(z, adv); bail(); render(); return; }
+      if (adv.status === 'wrongnet') { Object.assign(z, adv); bail(t('arkGiftWrongNet', { net: adv.net })); render(); return; }
       // 1b. BIP-353 with an ark instruction; remember on-chain as last resort
       const uris = [];
       try {
@@ -1605,6 +1622,7 @@ export function arkFeature(ctx) {
       }
       // 3. on-chain fallback
       if (onchain) {
+        if (z.autoSat && z.eventId) { bail(); render(); return; }
         ui.arkZap = null;
         ui.send.recipients[0].address = onchain;
         bail();
@@ -1612,7 +1630,7 @@ export function arkFeature(ctx) {
         return;
       }
       if (live()) { z.status = 'noark'; bail(); render(); }
-    })().catch((e) => { if (live()) { z.status = 'noark'; bail(); ui.sendError = e.message; render(); } });
+    })().catch((e) => { if (live()) { z.status = 'noark'; if (!bail(e.message)) ui.sendError = e.message; render(); } });
   }
 
   // shared by the ark and lightning zap flows (see zaps.js for the twin)
diff --git a/src/features/sync.js b/src/features/sync.js
index 415717f..ed22322 100644
--- a/src/features/sync.js
+++ b/src/features/sync.js
@@ -247,8 +247,25 @@ export function installSyncWallet(wallet, { outbox = syncOutbox() } = {}) {
     },
   });
 
+  // Account activation, Spending connect and the live subscription all need
+  // the same initial restore. Share it so history is merged newest-first
+  // before either live source starts delivering an old backlog piecemeal.
+  const restore = wallet.syncFromNostr.bind(wallet);
+  let restoring = null;
+  wallet.syncFromNostr = () => {
+    const pk = wallet.nostr.pk, net = wallet.netName;
+    if (restoring && restoring.pk === pk && restoring.net === net) return restoring.promise;
+    const run = { pk, net, promise: null };
+    run.promise = restore().finally(() => { if (restoring === run) restoring = null; });
+    restoring = run;
+    wallet.nostrRestoreReady ||= run.promise;
+    return run.promise;
+  };
+
   // identity follows the open wallet
   wallet.registerLoadHook(() => {
+    restoring = null;
+    wallet.nostrRestoreReady = null;
     if (wallet.mnemonic) wallet.nostr.load(wallet.mnemonic, wallet.passphrase, wallet.accountIndex || 0);
     else wallet.nostr.unload();
     outbox?.wake();
@@ -305,24 +322,32 @@ export function installSyncWallet(wallet, { outbox = syncOutbox() } = {}) {
   // vtxos union) applies live; full snapshots stay a load-time affair. With
   // per-device slots no device overwrites another's, so this only ever adds.
   let stateUnsub = null;
+  let stateGeneration = 0;
   wallet.registerRealtimeHook({
     start: () => {
       const sync = getSyncConfig();
       if (!sync.enabled || !wallet.nostr.pk) return;
       wallet.nostr.setRelays(sync.relays);
       if (stateUnsub) { try { stateUnsub(); } catch {} }
-      stateUnsub = wallet.nostr.subscribeStates((v, dtag) => {
-        if (!v.netName || v.netName !== wallet.netName) return;
-        if (!isOurDtag(dtag, wallet.netName)) return;
-        if (isOwnDeviceDtag(dtag, wallet.netName) && (v.savedAt || 0) === (wallet._savedAt || 0)) return; // our own echo
-        if (!v.blob) { wallet._mergeSnapshotExtensions(v); return; }
-        const pk = wallet.nostr.pk;
-        resolveStates([{ state: v, dtag }]).then((r) => {
-          if (r[0] && wallet.nostr.pk === pk && wallet.netName === r[0].state.netName) wallet._mergeSnapshotExtensions(r[0].state);
-        }).catch(() => {});
-      });
+      stateUnsub = null;
+      const generation = ++stateGeneration;
+      const identity = wallet.nostr.pk, network = wallet.netName;
+      Promise.resolve(wallet.nostrRestoreReady || wallet.syncFromNostr()).then(() => {
+        if (generation !== stateGeneration || wallet.nostr.pk !== identity || wallet.netName !== network) return;
+        stateUnsub = wallet.nostr.subscribeStates((v, dtag) => {
+          if (generation !== stateGeneration || wallet.nostr.pk !== identity) return;
+          if (!v.netName || v.netName !== wallet.netName) return;
+          if (!isOurDtag(dtag, wallet.netName)) return;
+          if (isOwnDeviceDtag(dtag, wallet.netName) && (v.savedAt || 0) === (wallet._savedAt || 0)) return; // our own echo
+          if (!v.blob) { wallet._mergeSnapshotExtensions(v); return; }
+          const pk = wallet.nostr.pk;
+          resolveStates([{ state: v, dtag }]).then((r) => {
+            if (generation === stateGeneration && r[0] && wallet.nostr.pk === pk && wallet.netName === r[0].state.netName) wallet._mergeSnapshotExtensions(r[0].state);
+          }).catch(() => {});
+        });
+      }).catch(() => {});
     },
-    stop: () => { if (stateUnsub) { try { stateUnsub(); } catch {} stateUnsub = null; } },
+    stop: () => { stateGeneration++; if (stateUnsub) { try { stateUnsub(); } catch {} stateUnsub = null; } },
   });
 
   // Capture and sign changed domains NOW, under the saving wallet's identity.
diff --git a/src/recipient-search.js b/src/recipient-search.js
index be3c70e..e0339ca 100644
--- a/src/recipient-search.js
+++ b/src/recipient-search.js
@@ -16,23 +16,28 @@ import { queryOn, parseNostrPubkey, npubOf, PROFILE_RELAYS } from './nostr.js';
 // Self-hosted (dist/punks) — coinos.io's own copies 502 for a third of the
 // set. Same deterministic formula the coinos app uses.
 const punkN = (pk) => Math.floor((parseInt(pk.slice(-2), 16) / 256) * 64) + 1;
-export const punkUrl = (pk) => `punks/${punkN(pk)}.webp`;
+export const punkImageUrl = (n, small = false) =>
+  `${typeof location !== 'undefined' && location.protocol === 'file:' ? '' : '/'}punks${small ? '-sm' : ''}/${n}.webp`;
+export const punkUrl = (pk) => punkImageUrl(punkN(pk));
 // The art is 240px, which is what a punk published as someone's nostr
 // picture should be — and eight times what a 30px circle needs. We ship a
 // 128px copy of each (a fifth of the bytes, 20KB → 4KB) and paint the circles
 // from that, so a brand-new wallet with nothing cached fills its faces in
 // straight away. Only the 64px profile avatar takes the full-size one.
-export const punkSmallUrl = (pk) => `punks-sm/${punkN(pk)}.webp`;
-export const punkSmallN = (n) => `punks-sm/${n}.webp`;
+export const punkSmallUrl = (pk) => punkImageUrl(punkN(pk), true);
+export const punkSmallN = (n) => punkImageUrl(n, true);
 
-export const fallbackAvatar = (h, pk, name, cls) =>
-  h('div', { class: cls + ' fallback' },
-    h('img', {
+const failedPunks = new Map();
+export const fallbackAvatar = (h, pk, name, cls) => {
+  const src = cls.includes('profile-avatar') ? punkUrl(pk) : punkSmallUrl(pk);
+  return h('div', { class: cls + ' fallback' },
+    Date.now() - (failedPunks.get(src) || 0) < 60_000 ? null : h('img', {
       class: 'punk', alt: '',
-      src: cls.includes('profile-avatar') ? punkUrl(pk) : punkSmallUrl(pk),
-      onError: (e) => { e.target.style.display = 'none'; },
+      src,
+      onError: (e) => { failedPunks.set(src, Date.now()); e.target.remove(); },
     }),
     (name || npubOf(pk) || '??').slice(0, 2));
+};
 
 const REGISTRAR = 'https://names.coinos.io';
 const SEARCH_RELAYS = ['wss://search.nos.today', 'wss://relay.nostr.band'];
@@ -103,7 +108,8 @@ export function warmSearch() {
 // Caches survive reloads: a name searched yesterday paints instantly today.
 // Profiles cap at 200 by recency; whole-query results keep for 12 hours.
 const PROF_KEY = 'btc-wallet-search-profiles';
-const QUERY_KEY = 'btc-wallet-search-queries';
+// Discard old results that identified migrated accounts by their wallet key.
+const QUERY_KEY = 'btc-wallet-search-queries-v2';
 const QUERY_TTL = 12 * 3600_000;
 const profileCache = new Map(); // pk -> { name, picture }
 const queryCache = new Map(); // q -> rows
diff --git a/tools/account-access-test.js b/tools/account-access-test.js
new file mode 100644
index 0000000..ad6ce3f
--- /dev/null
+++ b/tools/account-access-test.js
@@ -0,0 +1,82 @@
+// A watch-only account without remembered Nostr metadata must still offer
+// account switching and logout. Uses an unfunded, generated public key only.
+// Run: bun tools/account-access-test.js
+import assert from 'node:assert/strict';
+import puppeteer from 'puppeteer-core';
+import { generateMnemonic } from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+import { accountXpubFor, cacheKeyFor } from '../src/wallet.js';
+import { buildHtml } from '../build.js';
+
+const xpub = accountXpubFor({ mnemonic: generateMnemonic(wordlist) });
+const html = await buildHtml({ minify: false, pwa: false });
+const server = Bun.serve({ port: 0, fetch: () => new Response(html, { headers: { 'content-type': 'text/html' } }) });
+const browser = await puppeteer.launch({ executablePath: '/usr/bin/google-chrome', headless: true, args: ['--no-sandbox'] });
+const page = await browser.newPage();
+const errors = [];
+page.on('pageerror', (e) => errors.push(e.stack));
+await page.setRequestInterception(true);
+page.on('request', (r) => r.url().startsWith(server.url.origin) ? r.continue() : r.abort());
+const check = (name, value) => { assert(value, name); console.log(' ✓ ' + name); };
+const click = (text) => page.evaluate((label) => {
+  const button = [...document.querySelectorAll('button')].find((b) => b.textContent.trim() === label);
+  if (!button) throw new Error('Missing button: ' + label);
+  button.click();
+}, text);
+try {
+  await page.goto(server.url.href);
+  await page.evaluate((xpub) => {
+    localStorage.setItem('btc-wallet-watch', JSON.stringify([{ id: 'test-watch', label: 'Saved wallet', xpub }]));
+  }, xpub);
+  await page.reload();
+  await page.waitForSelector('.header-avatar');
+  check('fresh local account defaults to mainnet', await page.evaluate(() => JSON.parse(localStorage.getItem('btc-wallet-watch'))[0].network === 'mainnet'));
+  check('anonymous avatar has an accessible Accounts label', await page.$eval('.header-avatar', (e) => e.getAttribute('aria-label') === 'Accounts'));
+  await page.click('.header-avatar');
+  check('avatar opens Accounts with sign-in and logout', await page.evaluate(() => ['Accounts', 'Sign into another account', 'Log out'].every((s) => document.body.innerText.includes(s))));
+  const saved = await page.evaluate(() => localStorage.getItem('btc-wallet-watch'));
+  await click('Sign into another account');
+  // Expand the Nostr login card without supplying a private key.
+  await click('Sign in with Nostr');
+  await page.waitForSelector('input[placeholder="nsec, private key, or bunker://…"]');
+  check('Nostr key sign-in is reachable without deleting the old wallet', await page.evaluate((saved) => localStorage.getItem('btc-wallet-watch') === saved, saved));
+  await click('← Back');
+  await page.waitForSelector('.header-avatar');
+  await page.click('.header-avatar');
+  await click('Log out');
+  check('logout asks before ending the session', await page.evaluate(() => document.body.innerText.includes('Your accounts stay saved on this device.')));
+  await click('Log out');
+  check('logout reaches the sign-in screen and retains the saved wallet', await page.evaluate((saved) => !document.querySelector('.header-avatar') && document.body.innerText.includes('Sign in with Nostr') && localStorage.getItem('btc-wallet-watch') === saved, saved));
+  // Remember a public login identity on the watch-only account so every
+  // header destination is available, without supplying a private key.
+  await page.evaluate(({ key }) => {
+    localStorage.setItem(key + ':nostrlogin', JSON.stringify({ pubkey: 'a'.repeat(64), type: 'extension' }));
+    history.replaceState(null, '');
+  }, { key: cacheKeyFor(xpub) });
+  await page.reload();
+  await page.waitForSelector('[aria-label="Messages"]');
+  await click('Accounts');
+  const onAccounts = () => page.evaluate(() => [...document.querySelectorAll('h3')].some(e => e.textContent === 'Accounts'));
+  for (const label of ['Search', 'Messages', 'Your profile', 'Settings']) {
+    check(label + ' starts on Accounts', await onAccounts());
+    await page.click('[aria-label="' + label + '"]');
+    check(label + ' opens from Accounts', await page.evaluate(label => {
+      const nav = history.state.nav;
+      return nav.screen === 'wallet' && ![...document.querySelectorAll('h3')].some(e => e.textContent === 'Accounts')
+        && (label === 'Search' ? !!document.querySelector('.user-search-input')
+          : label === 'Messages' ? nav.chatOpen && nav.msgView === 'home'
+          : label === 'Your profile' ? !!document.querySelector('.npub-box') && nav.profilePk === 'a'.repeat(64)
+          : nav.tab === 'settings');
+    }, label));
+    await page.goBack();
+    await page.waitForFunction(() => [...document.querySelectorAll('h3')].some(e => e.textContent === 'Accounts'));
+    check('Back returns from ' + label + ' to Accounts', await onAccounts());
+  }
+  await page.click('[aria-label="Lock wallet"]');
+  check('Lock opens its password prompt from Accounts', await page.evaluate(() => !!document.querySelector('input[type="password"]')));
+  await click('Not now');
+  await page.click('.brand');
+  check('the logo returns to the wallet', await page.evaluate(() => history.state.nav.screen === 'wallet' && ![...document.querySelectorAll('h3')].some(e => e.textContent === 'Accounts')));
+  assert.deepEqual(errors, []);
+  check('no browser errors', true);
+} finally { await browser.close(); server.stop(true); }
diff --git a/tools/post-emoji-test.js b/tools/post-emoji-test.js
new file mode 100644
index 0000000..6c7a9aa
--- /dev/null
+++ b/tools/post-emoji-test.js
@@ -0,0 +1,79 @@
+// Exercise public reaction ingestion, rendering, signing and withdrawal.
+// No requests or events leave this local fixture. Run: bun tools/post-emoji-test.js
+import assert from 'node:assert/strict';
+import puppeteer from 'puppeteer-core';
+const app = await Bun.file('src/app.js').text();
+const dom = app.slice(app.indexOf('function h(tag,'), app.indexOf('// ---------------------------------------------------------------- morphing'));
+const entry = `
+import { messagesFeature } from './src/features/messages.js';
+${dom}
+const mine = 'a'.repeat(64), author = 'b'.repeat(64);
+const note = { id: 'c'.repeat(64), pubkey: author, kind: 1, tags: [], content: 'A post' };
+const ui = { screen: 'wallet' }, data = {};
+window.sent = [];
+let seq = 0, feature;
+const signer = { signEvent: async e => ({ ...e, pubkey: mine, id: 'signed-' + ++seq }) };
+const wallet = { loaded: true, loadFeatureState: (k, d) => data[k] || d, saveFeatureState: (k, v) => data[k] = v };
+function render() {
+  if (!feature) return;
+  document.querySelector('#panel').replaceChildren(feature.panel(note));
+  document.querySelector('#actions').replaceChildren(feature.actions(author, note, { canZap: false }));
+}
+feature = messagesFeature({ h, wallet, ui, render, toast() {}, brandHeader: () => null,
+  hook: k => k === 'nostrLoginIdentity' ? { pubkey: mine, signer } : null });
+window.test = {
+  add: (content, code, url, pk = author) => {
+    const ev = { id: 'received-' + ++seq, pubkey: pk, kind: 7, content,
+      tags: [['e', note.id], ...(code ? [['emoji', code, url]] : [])] };
+    feature.ingest(ev); render(); return ev;
+  },
+  duplicate: ev => { feature.ingest(ev); render(); },
+  send: async emoji => { await feature.send(note, emoji); render(); },
+  remove: async () => { await feature.remove(note); render(); },
+  count: () => feature.count(note.id), mine,
+};
+`;
+const bundle = await Bun.build({ entrypoints: ['post-emoji-entry'], target: 'browser', plugins: [{ name: 'post-emoji', setup(build) {
+  build.onResolve({ filter: /^post-emoji-entry$/ }, () => ({ path: 'entry', namespace: 'post-emoji' }));
+  build.onLoad({ filter: /.*/, namespace: 'post-emoji' }, () => ({ contents: entry, loader: 'js', resolveDir: process.cwd() }));
+  build.onLoad({ filter: /src\/features\/messages\.js$/ }, async ({ path }) => ({ loader: 'js', contents: (await Bun.file(path).text())
+    .replace("id: 'messages',", "id: 'messages', ingest: noteEvent, panel: whoPanel, actions: noteActions, send: reactTo, remove: unreact, count: whoCount,") }));
+  build.onLoad({ filter: /src\/nostr\.js$/ }, async ({ path }) => ({ loader: 'js', contents: (await Bun.file(path).text())
+    .replace('export async function queryOn(relays, filter, maxWait = 1500) {', 'export async function queryOn(relays, filter, maxWait = 1500) { return [];')
+    .replace('export async function publishOn(relays, evt) {', 'export async function publishOn(relays, evt) { window.sent.push(evt); return true;') }));
+} }] });
+assert(bundle.success, bundle.logs.join('\n'));
+const html = `<!doctype html><meta charset="utf-8"><style>${await Bun.file('src/style.css').text()}</style><div id="panel"></div><div id="actions"></div><script type="module">${await bundle.outputs[0].text()}</script>`;
+const gif = Buffer.from('R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7', 'base64');
+const server = Bun.serve({ port: 0, fetch: req => new URL(req.url).pathname.endsWith('.gif')
+  ? new Response(gif, { headers: { 'content-type': 'image/gif' } })
+  : new Response(html, { headers: { 'content-type': 'text/html' } }) });
+const browser = await puppeteer.launch({ executablePath: '/usr/bin/google-chrome', headless: true, args: ['--no-sandbox'] });
+const page = await browser.newPage();
+const errors = [];
+page.on('pageerror', e => errors.push(e.message));
+await page.setRequestInterception(true);
+page.on('request', r => r.url().startsWith(server.url.origin) ? r.continue() : r.abort());
+const check = (name, value) => { assert(value, name); console.log('✓ ' + name); };
+try {
+  await page.goto(server.url.href);
+  await page.waitForFunction(() => !!window.test);
+  await page.evaluate(() => { window.first = test.add(':catJAM:', 'catJAM', location.origin + '/cat.gif'); });
+  await page.waitForFunction(() => document.querySelector('#panel .cemoji')?.naturalWidth > 0);
+  check('tagged catJAM renders a decodable image with its shortcode as alt text', await page.$eval('#panel .cemoji', e => e.alt === ':catJAM:' && e.src.endsWith('/cat.gif')));
+  await page.evaluate(() => test.duplicate(first));
+  check('duplicate events do not inflate the tally', await page.evaluate(() => test.count() === 1));
+  await page.evaluate(() => test.add(':catJAM:', 'catJAM', location.origin + '/different.gif', 'd'.repeat(64)));
+  check('identical shortcodes with different images stay separate', await page.evaluate(() => [...document.querySelectorAll('#panel .cemoji')].map(e => e.src).join('|') === location.origin + '/cat.gif|' + location.origin + '/different.gif'));
+  await page.evaluate(() => test.add(':a_very_long_custom_emoji:', 'a_very_long_custom_emoji', location.origin + '/long.gif'));
+  check('long shortcodes are preserved', await page.evaluate(() => !!document.querySelector('img[alt=":a_very_long_custom_emoji:"]')));
+  await page.evaluate(() => { test.add(':missing:'); test.add(':unsafe:', 'unsafe', 'javascript:alert(1)'); test.add('+'); test.add('🔥'); });
+  check('missing or unsafe tags fall back to text and standard reactions still render', await page.evaluate(() => [':missing:', ':unsafe:', '❤️', '🔥'].every(s => document.querySelector('#panel').innerText.includes(s)) && !document.querySelector('img[src^="javascript:"]')));
+  await page.evaluate(() => test.send(':catJAM:'));
+  check('outgoing custom reactions carry their image tag', await page.evaluate(() => sent.at(-1).tags.some(t => t[0] === 'emoji' && t[1] === 'catJAM' && t[2] === location.origin + '/different.gif')));
+  check('our custom reaction renders on the action button', await page.evaluate(() => document.querySelector('#actions .cemoji')?.getAttribute('alt') === ':catJAM:'));
+  await page.evaluate(() => test.remove());
+  check('withdrawing it preserves other reactions and publishes deletion', await page.evaluate(() => !document.querySelector('#actions .cemoji') && sent.at(-1).kind === 5 && test.count() === 7));
+  assert.deepEqual(errors, []);
+  console.log('✓ no browser errors');
+} finally { await browser.close(); server.stop(true); }
diff --git a/tools/profile-recovery-test.js b/tools/profile-recovery-test.js
new file mode 100644
index 0000000..b2c871a
--- /dev/null
+++ b/tools/profile-recovery-test.js
@@ -0,0 +1,86 @@
+// Profile misses must preserve cached details, fall back to index relays,
+// and remain retryable. Tests real rendering with deterministic relay replies.
+// Run: bun tools/profile-recovery-test.js
+import assert from 'node:assert/strict';
+import puppeteer from 'puppeteer-core';
+const app = await Bun.file('src/app.js').text();
+const dom = app.slice(app.indexOf('function h(tag,'), app.indexOf('// ---------------------------------------------------------------- morphing'));
+const entry = `
+import { messagesFeature } from './src/features/messages.js';
+import { fallbackAvatar, punkUrl, punkSmallUrl } from './src/recipient-search.js';
+${dom}
+const pk = 'a'.repeat(64), other = 'b'.repeat(64);
+const cached = { name: 'Cached person', picture: 'https://example.invalid/photo.jpg', about: 'Cached bio' };
+const data = { profiles: { [pk]: { ...cached, t: Date.now(), eventAt: 1 } }, profPages: { full: { [pk]: { t: Date.now(), v: cached } } } };
+const ui = { screen: 'wallet', profilePk: pk };
+let feature, mode = 'empty', release;
+const asks = [];
+const event = (author, name, created_at = 2) => ({ pubkey: author, kind: 0, created_at, content: JSON.stringify({ name, about: name + ' bio', picture: '' }), tags: [] });
+window.__profileQuery = async (relays, filter) => {
+  asks.push({ relays, kinds: filter.kinds });
+  if (filter.kinds[0] !== 0) return [];
+  if (mode === 'hold') return new Promise(r => { release = r; });
+  if (mode === 'index' && relays.includes('wss://purplepag.es')) return [event(filter.authors[0], 'Recovered person')];
+  return [];
+};
+const wallet = { mnemonic: 'test', loadFeatureState: (key, fallback) => data[key] || fallback,
+  saveFeatureState: (key, value) => data[key] = value, nostr: null };
+function render() {
+  if (feature) document.querySelector('#profile').replaceChildren(feature.testView(pk));
+}
+feature = messagesFeature({ h, ui, wallet, render, hook: () => null, brandHeader: () => null, toast() {} });
+window.test = {
+  pk, other, asks, data, feature, event, render,
+  fetch: (author = pk) => feature.testFetch(author),
+  show: author => { ui.profilePk = author; render(); },
+  mode: value => mode = value,
+  release: () => { mode = 'empty'; release([]); },
+  avatar: () => { document.querySelector('#avatar').replaceChildren(fallbackAvatar(h, pk, 'Person', 'chat-avatar profile-avatar')); },
+  urls: () => [punkUrl(pk), punkSmallUrl(pk)],
+};
+render();
+`;
+const bundle = await Bun.build({ entrypoints: ['profile-test-entry'], target: 'browser', plugins: [{ name: 'profile-test', setup(build) {
+  build.onResolve({ filter: /^profile-test-entry$/ }, () => ({ path: 'entry', namespace: 'profile-test' }));
+  build.onLoad({ filter: /.*/, namespace: 'profile-test' }, () => ({ contents: entry, loader: 'js', resolveDir: process.cwd() }));
+  build.onLoad({ filter: /src\/features\/messages\.js$/ }, async ({ path }) => ({ contents: (await Bun.file(path).text())
+    .replace("id: 'messages',", "id: 'messages', testFetch: fetchFullProfile, testView: profileScreen, testApply: applyProfile, testLight: (pk) => profiles.get(pk), testFull: (pk) => fullProfiles.get(pk),"), loader: 'js' }));
+  build.onLoad({ filter: /src\/nostr\.js$/ }, async ({ path }) => ({ contents: (await Bun.file(path).text())
+    .replace('export async function queryOn(relays, filter, maxWait = 1500) {', 'export async function queryOn(relays, filter, maxWait = 1500) { if (globalThis.__profileQuery) return globalThis.__profileQuery(relays, filter);'), loader: 'js' }));
+} }] });
+assert(bundle.success, bundle.logs.join('\n'));
+const css = await Bun.file('src/style.css').text();
+const html = `<!doctype html><meta charset="utf-8"><style>${css}</style><div id="profile"></div><div id="avatar"></div><script type="module">${await bundle.outputs[0].text()}</script>`;
+const server = Bun.serve({ port: 0, fetch: req => new URL(req.url).pathname.startsWith('/punks')
+  ? new Response('missing', { status: 404 }) : new Response(html, { headers: { 'content-type': 'text/html' } }) });
+const browser = await puppeteer.launch({ executablePath: '/usr/bin/google-chrome', headless: true, args: ['--no-sandbox'] });
+const page = await browser.newPage();
+const errors = [];
+page.on('pageerror', e => errors.push(e.message));
+await page.setRequestInterception(true);
+page.on('request', r => r.url().startsWith(server.url.origin) ? r.continue() : r.abort());
+const check = (name, value) => { assert(value, name); console.log(' ✓ ' + name); };
+try {
+  await page.goto(server.url.href + 'someone/');
+  await page.waitForFunction(() => !!window.test);
+  await page.evaluate(() => test.fetch());
+  check('an empty fetch preserves cached name, photo and bio', await page.evaluate(() => test.feature.testLight(test.pk).name === 'Cached person' && test.feature.testFull(test.pk).about === 'Cached bio' && test.data.profiles[test.pk].picture === 'https://example.invalid/photo.jpg'));
+  check('a miss offers Retry instead of becoming permanent', await page.evaluate(() => document.body.innerText.includes('Couldn’t load the latest profile.') && [...document.querySelectorAll('button')].some(b => b.textContent === 'Retry')));
+  await page.evaluate(() => { test.mode('index'); [...document.querySelectorAll('button')].find(b => b.textContent === 'Retry').click(); });
+  await page.waitForFunction(() => document.body.innerText.includes('Recovered person bio'));
+  check('retry recovers a profile from an index relay', await page.evaluate(() => test.feature.testLight(test.pk).name === 'Recovered person' && !document.body.innerText.includes('Couldn’t load the latest profile.')));
+  await page.evaluate(() => { test.mode('hold'); window.pending = test.fetch(test.other); test.feature.testApply(test.other, test.event(test.other, 'Arrived in batch', 10)); test.release(); });
+  await page.evaluate(() => window.pending);
+  check('a slow empty page fetch cannot erase a successful batch answer', await page.evaluate(() => test.feature.testLight(test.other).name === 'Arrived in batch' && test.feature.testFull(test.other).name === 'Arrived in batch'));
+  await page.evaluate(() => test.feature.testApply(test.other, test.event(test.other, 'Old answer', 5)));
+  check('an older relay response cannot overwrite newer metadata', await page.evaluate(() => test.feature.testLight(test.other).name === 'Arrived in batch'));
+  await page.evaluate(async () => { const missing = 'c'.repeat(64); test.mode('empty'); test.show(missing); await test.fetch(missing); });
+  check('a key without cached or published details shows a neutral missing-profile message and Retry', await page.evaluate(() => document.body.innerText.includes('No profile details found on the available relays.') && !document.body.innerText.includes('Couldn’t load the latest profile.') && [...document.querySelectorAll('button')].some(b => b.textContent === 'Retry')));
+  check('avatar paths are rooted even on a trailing-slash profile URL', await page.evaluate(() => test.urls().every(url => url.startsWith('/punks'))));
+  await page.evaluate(() => test.avatar());
+  await page.waitForFunction(() => !document.querySelector('#avatar img'));
+  await page.evaluate(() => test.avatar());
+  check('failed fallback images stay removed across redraws', await page.evaluate(() => !document.querySelector('#avatar img') && document.querySelector('#avatar').textContent === 'Pe'));
+  assert.deepEqual(errors, []);
+  console.log(' ✓ no browser errors');
+} finally { await browser.close(); server.stop(true); }
diff --git a/tools/registry-ownership-test.js b/tools/registry-ownership-test.js
new file mode 100644
index 0000000..43683a1
--- /dev/null
+++ b/tools/registry-ownership-test.js
@@ -0,0 +1,18 @@
+import assert from 'node:assert/strict';
+import { registrationIdentity } from '../names/ownership.js';
+
+const owner = 'a'.repeat(64), wallet = 'b'.repeat(64), stranger = 'c'.repeat(64);
+const grant = { pubkey: owner, manager: wallet };
+for (const signer of [owner, wallet]) {
+  assert.deepEqual(registrationIdentity({ signer, grant, granted: true }), { pubkey: owner, manager: wallet });
+}
+console.log('✓ owner and manager registrations both preserve the migration identity');
+assert.deepEqual(registrationIdentity({ signer: wallet, manager: wallet, grant, granted: true }), { pubkey: owner, manager: wallet });
+console.log('✓ the signing wallet can remain the nominated manager');
+const existing = { pubkey: owner, manager: wallet };
+assert.deepEqual(registrationIdentity({ existing, signer: wallet, grant: { pubkey: stranger }, granted: false }), existing);
+console.log('✓ later wallet updates preserve existing ownership and management');
+assert.deepEqual(registrationIdentity({ signer: wallet, grant, granted: false }), { pubkey: wallet, manager: undefined });
+assert.deepEqual(registrationIdentity({ signer: owner, manager: wallet }), existing);
+assert.deepEqual(registrationIdentity({ signer: owner, manager: owner }), { pubkey: owner, manager: undefined });
+console.log('✓ ordinary claims retain their signer and ignore unauthorized grants');
diff --git a/tools/spending-restore-test.js b/tools/spending-restore-test.js
new file mode 100644
index 0000000..34cdd59
--- /dev/null
+++ b/tools/spending-restore-test.js
@@ -0,0 +1,119 @@
+// Snapshot-first Spending restore, without real relays, keys, or payments.
+// Run: bun tools/spending-restore-test.js
+import assert from 'node:assert/strict';
+import { slimArkForSync, mergeArkStates, arkFeature } from '../src/features/ark.js';
+import { installSyncWallet } from '../src/features/sync.js';
+import { ArkManager } from '../src/ark/manager.js';
+
+class Storage {
+  data = new Map();
+  get length() { return this.data.size; }
+  key(i) { return [...this.data.keys()][i] ?? null; }
+  getItem(k) { return this.data.get(k) ?? null; }
+  setItem(k, v) { this.data.set(k, String(v)); }
+  removeItem(k) { this.data.delete(k); }
+}
+globalThis.localStorage = new Storage();
+globalThis.fetch = async () => { throw new Error('Network disabled in restore test'); };
+const serverPubkey = '02' + 'ab'.repeat(32);
+const empty = () => ({ v: 1, serverPubkey, mailboxCheckpoint: 0, vtxos: [], actions: [], movements: [], scheduled: [] });
+const full = {
+  ...empty(), mailboxCheckpoint: 123456, nextKeyIndex: 401,
+  vtxos: Array.from({ length: 400 }, (_, i) => ({ id: 'coin-' + i, state: 'spent', amountSat: 100, keyIndex: 0 })),
+  movements: Array.from({ length: 400 }, (_, i) => ({ id: 'move-' + i, type: 'receive', status: 'complete', vtxoId: 'coin-' + i, amountSat: 100, ts: 1700000000000 + i })),
+  actions: Array.from({ length: 120 }, (_, i) => ({ id: 'send-' + i, type: 'send', step: 'done', amountSat: 50, inputIds: ['coin-' + i] })),
+};
+const snapshot = slimArkForSync(full);
+assert.equal(snapshot.movements.length, 400);
+assert.equal(snapshot.vtxos.length, 400);
+assert.equal(snapshot.actions.length, 120);
+assert.deepEqual(slimArkForSync(snapshot).actions[0].inputIds, ['coin-0']);
+assert.equal(mergeArkStates(empty(), snapshot).mailboxCheckpoint, 123456);
+const local = { ...empty(), mailboxCheckpoint: 10, movements: [{ id: 'local' }] };
+assert.equal(mergeArkStates(local, snapshot).mailboxCheckpoint, 10);
+assert.equal(mergeArkStates({ ...empty(), actions: [{ id: 'pending', step: 'signing' }] }, snapshot).mailboxCheckpoint, 0);
+const older = { ...empty(), vtxos: [{ id: 'coin-0', amountSat: 100, state: 'spendable' }] };
+assert.equal(mergeArkStates(snapshot, older).vtxos.find(v => v.id === 'coin-0').state, 'spent');
+console.log('✓ complete history, spent stubs and spend provenance survive repeated snapshotting');
+console.log('✓ fresh restores inherit the cursor; existing or unfinished local work does not skip messages');
+
+const hooks = { realtime: [], load: [] };
+const wallet = {
+  offline: false, netName: 'mainnet', txs: [], _savedAt: 0,
+  registerCacheSavedHook() {}, registerLoadHook: f => hooks.load.push(f),
+  registerRealtimeHook: h => hooks.realtime.push(h),
+  _mergeSnapshotExtensions(s) { if (s.arkState) this.arkState = mergeArkStates(this.arkState, s.arkState); },
+  _applySnapshot() {}, emit() {}, saveCache() {},
+};
+installSyncWallet(wallet, { outbox: null });
+wallet.nostr.load('abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about');
+let fetched = 0, subscribed = 0, finish;
+wallet.nostr.fetchAllStates = () => { fetched++; return new Promise(r => { finish = r; }); };
+wallet.nostr.subscribeStates = () => { subscribed++; return () => {}; };
+hooks.realtime[0].start();
+const restore = wallet.syncFromNostr();
+assert.equal(fetched, 1);
+assert.equal(subscribed, 0);
+finish([
+  { created_at: 2, dtag: 'bitcoin-wallet:x:one:ark', state: { netName: 'mainnet', arkState: snapshot } },
+  { created_at: 1, dtag: 'bitcoin-wallet:x:two:ark', state: { netName: 'mainnet', arkState: older } },
+]);
+assert.equal(await restore, true);
+await Promise.resolve();
+assert.equal(subscribed, 1);
+assert.equal(wallet.arkState.movements.length, 400);
+assert.equal(wallet.arkState.vtxos[0].state, 'spent');
+console.log('✓ initial fetch is shared and sorted before live snapshot delivery begins');
+hooks.realtime[0].stop();
+wallet.nostrRestoreReady = null;
+hooks.realtime[0].start();
+hooks.realtime[0].stop();
+const stopped = wallet.nostrRestoreReady;
+finish([]); await stopped; await Promise.resolve();
+assert.equal(subscribed, 1);
+console.log('✓ logout during restore does not restart the old identity subscription');
+
+// Real Ark feature lifecycle, with only the manager's network operations
+// replaced. Exercise the first-login case where state is held until the ASP
+// handshake establishes which server owns it.
+const original = {};
+for (const name of ['init', 'sync', 'startMailboxStream', 'stopMailboxStream']) original[name] = ArkManager.prototype[name];
+let syncs = 0, streams = 0, releaseRestore, releaseCatchup, manager;
+const restored = new Promise(r => { releaseRestore = r; });
+const catchup = new Promise(r => { releaseCatchup = r; });
+ArkManager.prototype.init = async function () {
+  manager = this;
+  this.info = { serverPubkey };
+  this.state = this.storage.adopt(serverPubkey) || this.storage.load() || empty();
+  return this;
+};
+ArkManager.prototype.sync = async function () { syncs++; assert.equal(this.state.mailboxCheckpoint, 123456); await catchup; };
+ArkManager.prototype.startMailboxStream = function () { streams++; };
+ArkManager.prototype.stopMailboxStream = function () {};
+let extension;
+const arkWallet = {
+  _cacheKey: () => 'fresh-spending-test', account: () => ({}),
+  registerCacheExtension: e => { extension = e; },
+  nostrRestoreReady: restored, saveCache() {}, loadFeatureState: () => ({}),
+};
+const feature = arkFeature({ wallet: arkWallet, ui: {}, render() {}, hook() {}, getAccount: () => 'spending' });
+const pause = () => new Promise(r => setTimeout(r, 20));
+try {
+  feature.init(); // no local Spending state yet
+  extension.load({ arkState: snapshot });
+  await pause();
+  assert.ok(manager, 'held snapshot starts a connection immediately, without the old 20-second throttle');
+  assert.equal(syncs, 0);
+  assert.equal(streams, 0);
+  assert.equal(manager.state.movements.length, 400);
+  releaseRestore(true); await pause();
+  assert.equal(syncs, 1);
+  assert.equal(streams, 0);
+  releaseCatchup(); await pause();
+  assert.equal(streams, 1);
+  console.log('✓ fresh Spending adopts the whole snapshot before catch-up, then starts its live stream');
+} finally {
+  feature.stop();
+  for (const [name, fn] of Object.entries(original)) ArkManager.prototype[name] = fn;
+}
+process.exit(0);
diff --git a/tools/thread-reply-test.js b/tools/thread-reply-test.js
new file mode 100644
index 0000000..c125ef8
--- /dev/null
+++ b/tools/thread-reply-test.js
@@ -0,0 +1,93 @@
+// Real reply buttons/composer with controlled relay replies and no publishing.
+// Run: bun tools/thread-reply-test.js
+import assert from 'node:assert/strict';
+import puppeteer from 'puppeteer-core';
+const app = await Bun.file('src/app.js').text();
+const dom = app.slice(app.indexOf('function h(tag,'), app.indexOf('// ---------------------------------------------------------------- morphing'));
+const entry = `
+import { messagesFeature } from './src/features/messages.js';
+${dom}
+const author = 'a'.repeat(64), mine = 'b'.repeat(64), rootId = 'c'.repeat(64);
+const root = { id: rootId, pubkey: author, kind: 1, content: 'Root post', tags: [], created_at: 1 };
+const reply = { ...root, id: 'd'.repeat(64), content: 'The reply you tapped', tags: [['e', rootId, '', 'root']], created_at: 2 };
+const other = { ...reply, id: 'e'.repeat(64), content: 'Another reply not returned by the relay', created_at: 3 };
+const ui = { screen: 'wallet' }, waiting = [];
+window.sent = [];
+window.query = filter => filter.kinds?.[0] === 1 && (filter.ids || filter['#e']) ? new Promise(resolve => waiting.push({ filter, resolve })) : Promise.resolve([]);
+const signer = { signEvent: async e => ({ ...e, id: 'f'.repeat(64), pubkey: mine }) };
+let feature;
+const wallet = { loaded: true, nostrRelays: () => [], loadFeatureState: (k, d) => d, saveFeatureState() {} };
+function render() {
+  if (!feature) return;
+  document.querySelector('#app').replaceChildren(feature.screenView() || feature.row(author, reply, 'Someone'));
+}
+feature = messagesFeature({ h, wallet, ui, render, toast() {}, brandHeader: () => null,
+  hook: k => k === 'nostrLoginIdentity' ? { pubkey: mine, signer } : null });
+window.test = { ui, reply, other, root, render, waiting,
+  release: () => { for (const q of waiting.splice(0)) q.resolve(q.filter.ids ? [root] : []); },
+  overlay: () => {
+    ui.profilePk = author; ui.profOverThread = true; render();
+    document.querySelector('#outside').replaceChildren(feature.actions(author, other, { canZap: false }));
+  },
+  missing: () => {
+    const ev = { ...other, id: '1'.repeat(64), tags: [['e', '2'.repeat(64), '', 'root']] };
+    document.querySelector('#outside').replaceChildren(feature.actions(author, ev, { canZap: false }));
+  },
+  empty: () => { for (const q of waiting.splice(0)) q.resolve([]); },
+};
+render();
+`;
+const bundle = await Bun.build({ entrypoints: ['thread-test-entry'], target: 'browser', plugins: [{ name: 'thread-test', setup(build) {
+  build.onResolve({ filter: /^thread-test-entry$/ }, () => ({ path: 'entry', namespace: 'thread-test' }));
+  build.onLoad({ filter: /.*/, namespace: 'thread-test' }, () => ({ contents: entry, loader: 'js', resolveDir: process.cwd() }));
+  build.onLoad({ filter: /src\/features\/messages\.js$/ }, async ({ path }) => ({ loader: 'js', contents: (await Bun.file(path).text())
+    .replace("id: 'messages',", "id: 'messages', row: noteRow, actions: noteActions,") }));
+  build.onLoad({ filter: /src\/nostr\.js$/ }, async ({ path }) => ({ loader: 'js', contents: (await Bun.file(path).text())
+    .replace('export async function queryOn(relays, filter, maxWait = 1500) {', 'export async function queryOn(relays, filter, maxWait = 1500) { return window.query(filter);')
+    .replace('export async function publishOn(relays, evt) {', 'export async function publishOn(relays, evt) { window.sent.push(evt); return true;')
+    .replace(/export function subscribeOn\(([^)]*)\) \{/, 'export function subscribeOn($1) { return () => {};') }));
+} }] });
+assert(bundle.success, bundle.logs.join('\n'));
+const html = `<!doctype html><meta charset="utf-8"><style>${await Bun.file('src/style.css').text()}</style><div id="app"></div><div id="outside"></div><input id="elsewhere"><script type="module">${await bundle.outputs[0].text()}</script>`;
+const server = Bun.serve({ port: 0, fetch: () => new Response(html, { headers: { 'content-type': 'text/html' } }) });
+const browser = await puppeteer.launch({ executablePath: '/usr/bin/google-chrome', headless: true, args: ['--no-sandbox'] });
+const page = await browser.newPage(), errors = [];
+page.on('pageerror', e => errors.push(e.message));
+await page.setRequestInterception(true);
+page.on('request', r => r.url().startsWith(server.url.origin) ? r.continue() : r.abort());
+const check = (name, value) => { assert(value, name); console.log('✓ ' + name); };
+const inline = () => page.evaluate(() => {
+  const input = document.querySelector('.thread-reply-input');
+  const box = input?.parentElement.parentElement;
+  return !!input && box.previousElementSibling?.dataset.zapPost === test.ui.noteThread.focusId;
+});
+try {
+  await page.goto(server.url.href);
+  await page.waitForSelector('#app .note-act');
+  await page.click('#app .note-act');
+  check('Reply immediately shows its composer beneath the tapped post', await inline());
+  check('the input receives focus before relay queries finish', await page.evaluate(() => document.activeElement.matches('.thread-reply-input')));
+  await page.type('.thread-reply-input', 'A reply before the root loads');
+  await page.click('.thread-reply-send');
+  await page.waitForFunction(() => sent.length === 1);
+  check('publishing targets the selected reply and its original root', await page.evaluate(() => sent[0].tags.some(t => t[0] === 'e' && t[1] === test.reply.id && t[3] === 'reply') && sent[0].tags.some(t => t[0] === 'e' && t[1] === test.root.id && t[3] === 'root')));
+  await page.waitForFunction(() => test.waiting.length === 2);
+  await page.evaluate(() => test.release());
+  await page.waitForFunction(() => document.body.innerText.includes('Root post'));
+  check('a relay result omitting the tapped reply keeps it and its composer', await inline());
+  await page.evaluate(() => test.overlay());
+  check('fixture starts with a profile covering the existing thread', await page.evaluate(() => test.ui.profOverThread && !document.querySelector('.thread-reply-input')));
+  await page.click('#outside .note-act');
+  check('Reply leaves the covering profile and inserts an uncached reply into the thread', await inline() && await page.evaluate(() => !test.ui.profOverThread && document.activeElement.matches('.thread-reply-input')));
+  await page.evaluate(() => test.missing());
+  await page.click('#outside .note-act');
+  await page.waitForFunction(() => test.waiting.length === 2);
+  await page.evaluate(() => test.empty());
+  await page.waitForFunction(() => !document.querySelector('#app .spinner'));
+  check('an unavailable root still leaves the selected post replyable', await inline());
+  await page.evaluate(() => { test.ui.noteThread = null; test.ui.profilePk = null; test.render(); document.querySelector('#elsewhere').focus(); });
+  await new Promise(r => setTimeout(r, 120));
+  check('deferred focus does not steal focus after leaving the thread', await page.evaluate(() => document.activeElement.id === 'elsewhere'));
+  assert.deepEqual(errors, []);
+  console.log('✓ no browser errors');
+} finally { await browser.close(); server.stop(true); }