joinhive 2.0.0

package/bin/hive-net.mjs

@@ -0,0 +1,400 @@
+#!/usr/bin/env node
+// hive-net — Node network helper so member laptops need NO Rust buzz binary.
+// Speaks the same relay wire protocol as the daemon (shared client).
+//
+//   hive-net ask "<text>"                post an intent (typed + human-readable)
+//   hive-net list users|agents [--online]
+//   hive-net leaderboard                 HONEY ranks for every known wallet
+//   hive-net agent status|pause|resume   your bee (control events are owner-signed)
+//   hive-net send <channel-name> <text>  raw plaintext send
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { RelayClient } from '../daemon/relay/client.mjs';
+import { EV, tryJson } from '../shared/events.mjs';
+import { redactSecrets } from '../shared/redact.mjs';
+import { signedFetch } from '../shared/nip98.mjs';
+
+const PACK_DIR = dirname(dirname(fileURLToPath(import.meta.url)));
+const HIVE_HOME = process.env.HIVE_HOME || join(homedir(), '.hive');
+const loadJson = (p, fb) => { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return fb; } };
+const cfg = loadJson(join(HIVE_HOME, 'config.json'), {});
+const identity = loadJson(join(HIVE_HOME, 'identity.json'), null);
+if (!identity) { console.error(JSON.stringify({ error: 'no identity; run: hive keygen (or hive join)' })); process.exit(1); }
+const relay = new RelayClient({ relayUrl: process.env.BUZZ_RELAY_URL || cfg.relay || 'http://localhost:3000', privkey: identity.privkey, log: () => {} });
+const chans = { lounge: 'hive-lounge', intents: 'hive-intents', logs: 'hive-logs', ...(cfg.channels || {}) };
+
+const [cmd, ...rest] = process.argv.slice(2);
+
+// Fold the recent bus into a member directory: pubkey -> {name, evm, is_bee, owner, last_at}.
+const directory = async () => {
+  const logsId = await relay.ensureChannel(chans.logs);
+  const raw = await relay.query([{ kinds: [9, 40002], '#h': [logsId], limit: 1000 }]);
+  if (!raw) throw new Error('relay unreachable');
+  const dir = {};
+  const rows = raw.map(RelayClient.normalize).sort((a, b) => a.created_at - b.created_at);
+  for (const m of rows) {
+    const j = tryJson(m.content);
+    if (!j || (j.by && j.by !== m.pubkey)) continue;              // R-B1
+    const e = dir[m.pubkey] || (dir[m.pubkey] = { pubkey: m.pubkey, last_at: 0 });
+    if (m.created_at > e.last_at) e.last_at = m.created_at;
+    if (j.type === EV.WALLET && /^0x[0-9a-fA-F]{40}$/.test(j.evm || '')) e.evm = j.evm;
+    if (j.type === EV.JOIN) { e.name = j.name; e.is_bee = !!j.is_bee; e.owner = j.owner_pubkey; e.owner_name = j.owner_name; }
+  }
+  return { dir, logsId };
+};
+
+const presence = async (pubkeys) => {
+  if (!pubkeys.length) return new Set();
+  const raw = await relay.query([{ kinds: [40902], authors: pubkeys, limit: pubkeys.length }]);
+  const online = new Set();
+  for (const e of raw || []) {
+    if (!/online|away/.test(e.content || '')) continue;
+    online.add(((e.tags || []).find((t) => t[0] === 'p') || [])[1] || e.pubkey);
+  }
+  return online;
+};
+
+const main = async () => {
+  if (cmd === 'ask') {
+    const text = rest.join(' ').trim();
+    if (!text) { console.error(JSON.stringify({ error: 'usage: hive ask "<what you want>"' })); process.exit(1); }
+    const [safe] = redactSecrets(text.slice(0, 300));
+    const logsId = await relay.ensureChannel(chans.logs);
+    const intentsId = await relay.ensureChannel(chans.intents);
+    const r = await relay.sendMessage(logsId, JSON.stringify({ type: EV.INTENT, intent: safe, origin: 'ask', for: identity.pubkey, by: identity.pubkey }));
+    await relay.sendMessage(intentsId, safe); // human-readable trace
+    console.log(JSON.stringify({ asked: safe, event: r.event_id, note: 'results land in: hive feed' }));
+    return;
+  }
+
+  if (cmd === 'list') {
+    const what = rest[0] === 'agents' ? 'agents' : 'users';
+    const onlineOnly = rest.includes('--online');
+    const { dir } = await directory();
+    const all = Object.values(dir);
+    const rows = what === 'agents' ? all.filter((e) => e.is_bee) : all.filter((e) => !e.is_bee);
+    // Resolve kind-0 profile names for anyone the bus directory can't name.
+    const unnamed = rows.filter((r) => !r.name).map((r) => r.pubkey);
+    if (unnamed.length) {
+      const profs = await relay.query([{ kinds: [0], authors: unnamed, limit: unnamed.length }]);
+      for (const p of profs || []) {
+        const meta = tryJson(p.content);
+        const row = rows.find((r) => r.pubkey === p.pubkey);
+        if (row && meta && (meta.display_name || meta.name)) row.name = meta.display_name || meta.name;
+      }
+    }
+    const online = await presence(rows.map((r) => r.pubkey));
+    const out = rows
+      .filter((r) => !onlineOnly || online.has(r.pubkey))
+      .sort((a, b) => b.last_at - a.last_at)
+      .map((r) => ({
+        [what === 'agents' ? 'agent' : 'user']: r.name || r.pubkey.slice(0, 12),
+        pubkey: r.pubkey.slice(0, 12),
+        ...(r.evm ? { wallet: `${r.evm.slice(0, 10)}…` } : {}),
+        ...(r.owner_name ? { owner: r.owner_name } : {}),
+        online: online.has(r.pubkey),
+      }));
+    if (!out.length) console.log(`(no ${what} seen on this community yet)`);
+    for (const r of out) console.log(`${r.online ? '🟢' : '⚪️'} ${r[what === 'agents' ? 'agent' : 'user']}  ${r.pubkey}${r.wallet ? `  ${r.wallet}` : ''}${r.owner ? `  (owner: ${r.owner})` : ''}`);
+    return;
+  }
+
+  if (cmd === 'leaderboard') {
+    const dep = loadJson(join(PACK_DIR, 'onchain', 'deployments.sepolia.json'), {});
+    if (!dep.honey) { console.error(JSON.stringify({ error: 'HONEY not deployed' })); process.exit(1); }
+    const { dir } = await directory();
+    const withWallets = Object.values(dir).filter((e) => e.evm);
+    const { JsonRpcProvider, Contract, formatUnits } = await import('ethers');
+    const provider = new JsonRpcProvider(process.env.SEPOLIA_RPC_URL || 'https://ethereum-sepolia-rpc.publicnode.com');
+    const honey = new Contract(dep.honey, ['function balanceOf(address) view returns (uint256)'], provider);
+    // One shared wallet per member: dedupe by EVM address, preferring the
+    // bee-named row (the human and their bee are one economic identity).
+    const byEvm = {};
+    for (const e of withWallets) {
+      const cur = byEvm[e.evm];
+      if (!cur || (e.is_bee && !cur.is_bee)) byEvm[e.evm] = e;
+    }
+    const rows = await Promise.all(Object.values(byEvm).map(async (e) => {
+      let bal = 0n; try { bal = await honey.balanceOf(e.evm); } catch {}
+      return { name: e.name || e.pubkey.slice(0, 12), is_bee: !!e.is_bee, honey: Number(formatUnits(bal, 18)) };
+    }));
+    rows.sort((a, b) => b.honey - a.honey);
+    if (!rows.length) { console.log('(no wallets announced yet)'); return; }
+    console.log('🏆 HONEY leaderboard (reputation — soulbound, earned only)');
+    rows.forEach((r, i) => console.log(`  ${String(i + 1).padStart(2)}. ${r.name}${r.is_bee ? ' 🐝' : ''}  ${r.honey} HONEY`));
+    return;
+  }
+
+  if (cmd === 'agent') {
+    const sub = rest[0] || 'status';
+    // Owner-signed control events; the bee pubkey comes from config (written
+    // at join) or --bee.
+    const beePk = rest.includes('--bee') ? rest[rest.indexOf('--bee') + 1] : cfg.bee_pubkey;
+    if (sub === 'pause' || sub === 'resume') {
+      if (!/^[0-9a-f]{64}$/i.test(beePk || '')) { console.error(JSON.stringify({ error: 'no bee_pubkey in config — pass --bee <pubkey>' })); process.exit(1); }
+      const logsId = await relay.ensureChannel(chans.logs);
+      const r = await relay.sendMessage(logsId, JSON.stringify({ type: EV.CONTROL, action: sub, bee: beePk, by: identity.pubkey }));
+      console.log(JSON.stringify({ [sub]: beePk.slice(0, 12), event: r.event_id, note: 'takes effect within one poll tick' }));
+      return;
+    }
+    if (sub === 'status') {
+      if (cfg.server_url && cfg.bee_name) {
+        try {
+          const res = await fetch(`${cfg.server_url}/api/bees/${cfg.bee_name.replace(/\.bee$/, '')}/status`, { signal: AbortSignal.timeout(5000) });
+          console.log(JSON.stringify(await res.json(), null, 2));
+          return;
+        } catch { /* fall through to bus view */ }
+      }
+      const { dir } = await directory();
+      const mine = Object.values(dir).filter((e) => e.is_bee && e.owner === identity.pubkey);
+      console.log(JSON.stringify(mine.length ? mine : { note: 'no bee announced for your key yet' }, null, 2));
+      return;
+    }
+    console.error(JSON.stringify({ error: 'usage: hive agent status|pause|resume [--bee <pubkey>]' }));
+    process.exit(1);
+  }
+
+  if (cmd === 'feed') {
+    // Results / tips / gifts / settlements addressed to me — provenance-checked.
+    const logsId = await relay.ensureChannel(chans.logs);
+    const raw = await relay.query([{ kinds: [9, 40002], '#h': [logsId], limit: 600 }]);
+    if (!raw) throw new Error('relay unreachable');
+    const me = identity.pubkey;
+    const rows = raw.map(RelayClient.normalize).sort((a, b) => a.created_at - b.created_at);
+    const results = [], tips = [], gifts = [], settles = []; const myOpen = new Set();
+    for (const m of rows) {
+      const j = tryJson(m.content);
+      if (!j || (j.by && j.by !== m.pubkey)) continue;
+      if (j.type === EV.SESSION && m.pubkey === me && typeof j.session_id === 'string') myOpen.add(j.session_id);
+    }
+    for (const m of rows) {
+      const j = tryJson(m.content);
+      if (!j || (j.by && j.by !== m.pubkey)) continue;
+      if (j.type === EV.RESULT && j.for === me) results.push({ m, j });
+      else if (j.type === EV.TIP && j.to === me && Number(j.amount) > 0) tips.push({ m, j });
+      else if (j.type === EV.TRANSFER && j.to === me) gifts.push({ m, j });
+      else if (j.type === EV.SETTLE && myOpen.has(j.session_id)) settles.push({ m, j });
+    }
+    let any = false;
+    if (results.length) { any = true; console.log('RESULTS:'); for (const { m, j } of results.slice(-15))
+      console.log(`  • ${j.intent || ''}\n    ${String(j.result).replace(/\n/g, ' ').slice(0, 240)}\n    [${(j.by || '').slice(0, 12)} · protocols: ${(j.protocols_used || []).join(',')}]  react: hive react ${m.id} up`); }
+    if (tips.length) { any = true; console.log('TIPS RECEIVED:'); for (const { j } of tips.slice(-10))
+      console.log(`  • +${j.amount} ${j.token || 'JELLY'} from ${(j.from || '').slice(0, 12)}  tx: ${j.tx || '?'}`); }
+    if (gifts.length) { any = true; console.log('GIFTS RECEIVED:'); for (const { j } of gifts.slice(-10))
+      console.log(`  • object ${String(j.object || j.name || '').slice(0, 16)} from ${(j.from || '').slice(0, 12)}`); }
+    if (settles.length) { any = true; console.log('SETTLEMENTS (sessions you opened):'); for (const { j } of settles.slice(-10))
+      console.log(`  • [${j.status}] ${String(j.kind || '')}: ${String(j.result).replace(/\n/g, ' ').slice(0, 200)}`); }
+    if (!any) console.log('(feed empty — try: hive ask "<what you want>")');
+    return;
+  }
+
+  if (cmd === 'react') {
+    // react <result-event-id> up|down [note] — HUMAN feedback; this is what
+    // mints HONEY at the next epoch. The result's author is resolved from the
+    // SIGNER (never a self-asserted field).
+    const [rid, dir = 'up', ...noteParts] = rest;
+    if (!rid || !['up', 'down'].includes(dir)) { console.error(JSON.stringify({ error: 'usage: hive react <result-event-id> up|down [note]' })); process.exit(1); }
+    const hit = (await relay.query([{ ids: [rid], limit: 1 }]))?.[0];
+    if (!hit) { console.error(JSON.stringify({ error: 'result not found on the relay' })); process.exit(1); }
+    const j = tryJson(hit.content);
+    if (!j || (j.by && j.by !== hit.pubkey)) { console.error(JSON.stringify({ error: 'result unverifiable (provenance mismatch)' })); process.exit(1); }
+    const logsId = await relay.ensureChannel(chans.logs);
+    const note = noteParts.join(' ').trim();
+    const r = await relay.sendMessage(logsId, JSON.stringify({
+      type: EV.FEEDBACK, result: rid, result_by: hit.pubkey, dir,
+      ...(note ? { note: note.slice(0, 200) } : {}), by: identity.pubkey, at: Math.floor(Date.now() / 1000),
+    }));
+    console.log(JSON.stringify({ reacted: dir, result: rid.slice(0, 12), event: r.event_id }));
+    return;
+  }
+
+  if (cmd === 'admin-invite') {
+    // Operator-only: mints a member invite on the bee-host (which mints the
+    // relay invite via the steward) and prints the shareable join link.
+    //   --uses N       one code admitting N distinct members (default 2, max 100)
+    //   --ttl-days D   validity window (default 3, max 30)
+    const server = (rest.includes('--server') ? rest[rest.indexOf('--server') + 1] : cfg.server_url || '').replace(/\/+$/, '');
+    if (!server) { console.error(JSON.stringify({ error: 'no server_url in config — pass --server https://api.<domain>' })); process.exit(1); }
+    const uses = rest.includes('--uses') ? Number(rest[rest.indexOf('--uses') + 1]) : undefined;
+    const ttlDays = rest.includes('--ttl-days') ? Number(rest[rest.indexOf('--ttl-days') + 1]) : undefined;
+    const r = await signedFetch(identity.privkey, 'POST', `${server}/api/admin/invites`, {
+      ...(uses ? { max_uses: uses } : {}), ...(ttlDays ? { ttl_secs: Math.round(ttlDays * 86400) } : {}),
+    });
+    if (r.status !== 200) { console.error(JSON.stringify({ error: `http ${r.status}`, ...r.json })); process.exit(1); }
+    console.log(JSON.stringify({ invite: r.json.code, max_uses: r.json.max_uses, join_url: r.json.join_url, expires_at_utc: new Date((r.json.expires_at || 0) * 1000).toISOString(), share: `send this link: ${r.json.join_url}` }, null, 2));
+    return;
+  }
+
+  if (cmd === 'gov') {
+    // HONEY-weighted governance, hardened: weight = getPastVotes at the
+    // proposal's SNAPSHOT BLOCK (v2 auto-self-delegates on mint, so votes are
+    // live), 48h deadline, 30%-of-supply quorum. Off-chain ballots on the
+    // bus; on-chain truth for weights.
+    const sub = rest[0];
+    const logsId = await relay.ensureChannel(chans.logs);
+    const dep = loadJson(join(PACK_DIR, 'onchain', 'deployments.sepolia.json'), {});
+    const { JsonRpcProvider, Contract, formatUnits } = await import('ethers');
+    const provider = new JsonRpcProvider(process.env.SEPOLIA_RPC_URL || 'https://ethereum-sepolia-rpc.publicnode.com');
+    if (sub === 'propose') {
+      const text = rest.slice(1).join(' ').trim();
+      if (!text) { console.error(JSON.stringify({ error: 'usage: hive gov propose "<text>"' })); process.exit(1); }
+      const block = await provider.getBlockNumber();
+      const pid = (await import('node:crypto')).randomUUID();
+      const deadline = Math.floor(Date.now() / 1000) + 48 * 3600;
+      await relay.sendMessage(logsId, JSON.stringify({ type: EV.PROPOSAL, proposal_id: pid, text: text.slice(0, 500), snapshot_block: block, deadline, by: identity.pubkey, at: Math.floor(Date.now() / 1000) }));
+      console.log(JSON.stringify({ proposal: pid, snapshot_block: block, deadline_utc: new Date(deadline * 1000).toISOString(), note: `vote with: hive gov vote ${pid} yes|no` }, null, 2));
+      return;
+    }
+    if (sub === 'vote') {
+      const [, pid, choice] = rest;
+      if (!pid || !['yes', 'no'].includes(choice)) { console.error(JSON.stringify({ error: 'usage: hive gov vote <proposal-id> yes|no' })); process.exit(1); }
+      await relay.sendMessage(logsId, JSON.stringify({ type: EV.VOTE, proposal_id: pid, choice, by: identity.pubkey, at: Math.floor(Date.now() / 1000) }));
+      console.log(JSON.stringify({ voted: choice, proposal: pid }));
+      return;
+    }
+    if (sub === 'tally') {
+      const pid = rest[1];
+      if (!pid || !dep.honey) { console.error(JSON.stringify({ error: !pid ? 'usage: hive gov tally <proposal-id>' : 'HONEY not deployed' })); process.exit(1); }
+      const raw = await relay.query([{ kinds: [9, 40002], '#h': [logsId], limit: 1000 }]);
+      let proposal = null; const votes = {}; const evm = {};
+      for (const m of (raw || []).map(RelayClient.normalize).sort((a, b) => a.created_at - b.created_at)) {
+        const j = tryJson(m.content);
+        if (!j || (j.by && j.by !== m.pubkey)) continue;
+        if (j.type === EV.WALLET && /^0x[0-9a-fA-F]{40}$/.test(j.evm || '')) evm[m.pubkey] = j.evm;
+        if (j.proposal_id !== pid) continue;
+        if (j.type === EV.PROPOSAL) proposal = { text: j.text, snapshot_block: j.snapshot_block, deadline: j.deadline };
+        if (j.type === EV.VOTE && ['yes', 'no'].includes(j.choice)) {
+          if (proposal?.deadline && m.created_at > proposal.deadline) continue; // late votes don't count
+          if (!votes[m.pubkey] || m.created_at >= votes[m.pubkey].at) votes[m.pubkey] = { choice: j.choice, at: m.created_at };
+        }
+      }
+      if (!proposal) { console.error(JSON.stringify({ error: 'proposal not found in the recent window' })); process.exit(1); }
+      const honey = new Contract(dep.honey, [
+        'function getPastVotes(address,uint256) view returns (uint256)',
+        'function getPastTotalSupply(uint256) view returns (uint256)',
+        'function balanceOf(address) view returns (uint256)',
+      ], provider);
+      const snap = proposal.snapshot_block;
+      const weigh = async (addr) => {
+        try { return snap ? await honey.getPastVotes(addr, snap) : await honey.balanceOf(addr); } catch { return 0n; }
+      };
+      // One shared wallet per member: dedupe voters by wallet so human+bee
+      // (same evm) can't double-count.
+      const seenEvm = new Set();
+      let yes = 0n, no = 0n; const rows = [];
+      await Promise.all(Object.entries(votes).map(async ([pk, v]) => {
+        const a = evm[pk]; if (!a) return;
+        if (seenEvm.has(a)) { rows.push(`${pk.slice(0, 8)}: ${v.choice} (0 — shared wallet already voted)`); return; }
+        seenEvm.add(a);
+        const w = await weigh(a);
+        if (v.choice === 'yes') yes += w; else no += w;
+        rows.push(`${pk.slice(0, 8)}: ${v.choice} (${formatUnits(w, 18)} HONEY)`);
+      }));
+      let supply = 0n, quorumOk = null;
+      try { supply = snap ? await honey.getPastTotalSupply(snap) : 0n; } catch {}
+      if (supply > 0n) quorumOk = (yes + no) * 10n >= supply * 3n; // 30%
+      const expired = proposal.deadline ? Math.floor(Date.now() / 1000) > proposal.deadline : true;
+      const result = !expired ? 'OPEN' : quorumOk === false ? 'FAIL (no quorum)' : yes > no ? 'PASS' : no > yes ? 'FAIL' : 'TIE';
+      console.log(JSON.stringify({
+        proposal: proposal.text, snapshot_block: snap || null,
+        deadline_utc: proposal.deadline ? new Date(proposal.deadline * 1000).toISOString() : null,
+        yes_HONEY: formatUnits(yes, 18), no_HONEY: formatUnits(no, 18),
+        quorum_30pct: quorumOk === null ? 'n/a (pre-v2)' : quorumOk, result, voters: rows,
+      }, null, 2));
+      return;
+    }
+    console.error(JSON.stringify({ error: 'usage: hive gov propose|vote|tally' }));
+    process.exit(1);
+  }
+
+  if (cmd === 'dnd') {
+    // Do-not-disturb with a price: your bee holds non-urgent pings; paying
+    // your interrupt fee (JELLY, 100% to you) is the override.
+    const on = rest[0] === 'on';
+    if (!['on', 'off'].includes(rest[0] || '')) { console.error(JSON.stringify({ error: 'usage: hive dnd on|off [--price N]' })); process.exit(1); }
+    const price = rest.includes('--price') ? Number(rest[rest.indexOf('--price') + 1]) : 5;
+    const logsId = await relay.ensureChannel(chans.logs);
+    const r = await relay.sendMessage(logsId, JSON.stringify({ type: EV.DND, on, ...(on ? { price: Math.max(1, Math.min(25, price)) } : {}), by: identity.pubkey, at: Math.floor(Date.now() / 1000) }));
+    console.log(JSON.stringify({ dnd: on ? 'on' : 'off', ...(on ? { interrupt_price_jelly: Math.max(1, Math.min(25, price)) } : {}), event: r.event_id }));
+    return;
+  }
+
+  if (cmd === 'set-name') {
+    // Publish YOUR kind-0 profile so apps show a name, not a pubkey.
+    const name = (rest[0] || cfg.owner_name || '').trim();
+    if (!name) { console.error(JSON.stringify({ error: 'usage: hive-net set-name <name>' })); process.exit(1); }
+    const r = await relay.setProfile({ name, display_name: name, about: rest.slice(1).join(' ') || `Hive member${cfg.bee_name ? ` — human of ${cfg.bee_name}` : ''}` });
+    console.log(JSON.stringify({ profile: name, published: r.ok, event: r.event_id }));
+    return;
+  }
+
+  if (cmd === 'altkey') {
+    // Link another device's key (e.g. your Buzz desktop identity) to your
+    // membership. Mutual: you claim it here, then the OTHER device posts the
+    // printed ack into #hive-logs. Once both exist, the rewarder treats the
+    // keys as one member (no self-boosting via a second device).
+    const sub = rest[0];
+    const logsId = await relay.ensureChannel(chans.logs);
+    if (sub === 'add' || sub === 'revoke') {
+      const alt = rest[1] || '';
+      if (!/^[0-9a-f]{64}$/i.test(alt)) { console.error(JSON.stringify({ error: `usage: hive altkey ${sub} <64-hex device pubkey>` })); process.exit(1); }
+      if (alt === identity.pubkey) { console.error(JSON.stringify({ error: 'that is this device\'s own key' })); process.exit(1); }
+      const r = await relay.sendMessage(logsId, JSON.stringify({ type: EV.ALTKEY, alt, ...(sub === 'revoke' ? { revoke: true } : {}), by: identity.pubkey }));
+      if (sub === 'revoke') { console.log(JSON.stringify({ revoked: alt.slice(0, 12), event: r.event_id })); return; }
+      const ack = JSON.stringify({ type: EV.ALTKEY, owner: identity.pubkey, by: alt });
+      // Instructions go to STDERR so a copy of stdout is ONLY the ack JSON —
+      // pasting anything more than the bare JSON makes the message unparseable.
+      console.error(`claimed ${alt.slice(0, 12)}… (event ${r.event_id.slice(0, 12)}…)`);
+      console.error('\nFROM THE OTHER DEVICE (the Buzz app, as that identity), post into #hive-logs');
+      console.error('EXACTLY the single line below — nothing before it, nothing after it:\n');
+      console.log(ack);
+      return;
+    }
+    if (sub === 'list') {
+      const { parseAltkeyLoose } = await import('../server/rewarder.mjs');
+      const raw = await relay.query([{ kinds: [9, 40002], '#h': [logsId], limit: 1000 }]);
+      const claims = {}, acks = {};
+      for (const m of (raw || []).map(RelayClient.normalize).sort((a, b) => a.created_at - b.created_at)) {
+        const j = tryJson(m.content) || parseAltkeyLoose(m.content);
+        if (!j || j.type !== EV.ALTKEY || (j.by && j.by !== m.pubkey)) continue;
+        if (typeof j.alt === 'string') { const c = claims[m.pubkey] = claims[m.pubkey] || {}; if (j.revoke) delete c[j.alt]; else c[j.alt] = true; }
+        else if (typeof j.owner === 'string') { const a = acks[m.pubkey] = acks[m.pubkey] || {}; if (j.revoke) delete a[j.owner]; else a[j.owner] = true; }
+      }
+      let any = false;
+      for (const [member, alts] of Object.entries(claims)) {
+        for (const alt of Object.keys(alts)) {
+          any = true;
+          const linked = !!acks[alt]?.[member];
+          console.log(`${linked ? '🔗' : '⏳'} ${member.slice(0, 12)} ↔ ${alt.slice(0, 12)}  ${linked ? 'linked' : 'awaiting ack from the device'}`);
+        }
+      }
+      if (!any) console.log('(no alt-key links on this community)');
+      return;
+    }
+    console.error(JSON.stringify({ error: 'usage: hive altkey add|revoke <pubkey> | list' }));
+    process.exit(1);
+  }
+
+  if (cmd === 'resolve-user') {
+    const who = rest[0] || '';
+    const pk = /^[0-9a-f]{64}$/i.test(who) ? who : await relay.resolveUser(who);
+    if (!pk) { console.error(JSON.stringify({ error: `no member matching "${who}"` })); process.exit(1); }
+    process.stdout.write(pk);
+    return;
+  }
+
+  if (cmd === 'send') {
+    const [chanName, ...text] = rest;
+    const id = await relay.ensureChannel(chanName);
+    const r = await relay.sendMessage(id, text.join(' '));
+    console.log(JSON.stringify({ sent: r.ok, event: r.event_id }));
+    return;
+  }
+
+  console.error(JSON.stringify({ error: `unknown hive-net command "${cmd}"` }));
+  process.exit(1);
+};
+
+main().catch((e) => { console.error(JSON.stringify({ error: String(e.message || e) })); process.exit(1); });

package/bin/hive-wallet.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// hive-wallet — give a Hive agent an EVM wallet and a Solana wallet.
+//
+// One BIP-39 mnemonic per agent (keyed by the agent's nostr pubkey), stored in
+// the macOS Keychain — never on disk. From that one seed we derive:
+//   - EVM  (secp256k1, m/44'/60'/0'/0/0)  -> 0x address
+//   - Solana (ed25519 SLIP-0010, m/44'/501'/0'/0') -> base58 address
+// Only PUBLIC addresses are written to ~/.hive/wallet.json and announced.
+// Private key / mnemonic stay in the Keychain; `hive wallet export` reads them
+// back for the human on demand.
+//
+// Idempotent: an agent that already has a mnemonic in the Keychain reuses it.
+//
+// Usage:
+//   hive wallet [--agent <pubkey>]      create-or-show (default: this endpoint)
+//   hive wallet show [--agent <pubkey>] public addresses only
+//   hive wallet export [--agent <pubkey>]  print mnemonic+keys (human, sensitive)
+import { execFileSync } from 'node:child_process';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+import * as bip39 from 'bip39';
+import { HDNodeWallet } from 'ethers';
+import { derivePath } from 'ed25519-hd-key';
+import nacl from 'tweetnacl';
+import bs58 from 'bs58';
+
+const HIVE_HOME = process.env.HIVE_HOME || join(homedir(), '.hive');
+const KEYCHAIN_SERVICE = 'hive-agent-wallet';
+
+const identity = JSON.parse(readFileSync(join(HIVE_HOME, 'identity.json'), 'utf8'));
+const args = process.argv.slice(2);
+// Subcommand = first positional that is NOT the value of --agent. The old
+// expression `args[args.indexOf('--agent') + 1]` read args[0] when --agent
+// was absent (indexOf -1 + 1 = 0), so `show`/`export` self-excluded and fell
+// through to 'create' — `export` never exported and `show` rewrote state.
+const agentFlagIdx = args.indexOf('--agent');
+const positionals = args.filter((a, i) => !a.startsWith('--') && (agentFlagIdx < 0 || i !== agentFlagIdx + 1));
+const sub = positionals[0] || 'create';
+if (!['create', 'show', 'export'].includes(sub)) {
+  console.error(JSON.stringify({ error: `unknown subcommand "${sub}" — usage: hive wallet [show|export] [--agent <64-hex pubkey>]` }));
+  process.exit(1);
+}
+const agent = agentFlagIdx >= 0 ? args[agentFlagIdx + 1] : identity.pubkey;
+// An --agent value must be a nostr pubkey. An unvalidated value already
+// minted one orphan mnemonic into the Keychain (keyed by an 0x EVM address —
+// no code path can spend from it). --force keeps an escape hatch.
+if (agentFlagIdx >= 0 && !/^[0-9a-f]{64}$/i.test(agent || '') && !args.includes('--force')) {
+  console.error(JSON.stringify({ error: `--agent must be a 64-hex nostr pubkey, got "${String(agent).slice(0, 20)}…" (pass --force to override)` }));
+  process.exit(1);
+}
+
+// ---- Keychain (macOS) -------------------------------------------------------
+const isMac = platform() === 'darwin';
+const kcRead = (account) => {
+  if (!isMac) return keyFileRead(account);
+  try {
+    return execFileSync('security', ['find-generic-password', '-a', account, '-s', KEYCHAIN_SERVICE, '-w'], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+  } catch { return null; }
+};
+const kcWrite = (account, secret) => {
+  if (!isMac) return keyFileWrite(account, secret);
+  // -U updates if present. label -l makes it findable in Keychain Access.
+  execFileSync('security', ['add-generic-password', '-U', '-a', account, '-s', KEYCHAIN_SERVICE, '-l', `Hive wallet ${account.slice(0, 12)}`, '-w', secret], { stdio: ['ignore', 'ignore', 'ignore'] });
+};
+// Non-mac fallback: 0600 file under ~/.hive/wallets (so Linux/CI still works).
+const keyFile = (account) => join(HIVE_HOME, 'wallets', `${account}.seed`);
+const keyFileRead = (account) => { try { return readFileSync(keyFile(account), 'utf8').trim(); } catch { return null; } };
+const keyFileWrite = (account, secret) => {
+  execFileSync('mkdir', ['-p', join(HIVE_HOME, 'wallets')]);
+  writeFileSync(keyFile(account), secret + '\n', { mode: 0o600 });
+};
+
+// ---- derivation -------------------------------------------------------------
+const deriveWallets = (mnemonic) => {
+  const evm = HDNodeWallet.fromPhrase(mnemonic); // default path m/44'/60'/0'/0/0
+  const seed = bip39.mnemonicToSeedSync(mnemonic);
+  const { key } = derivePath("m/44'/501'/0'/0'", seed.toString('hex'));
+  const solKp = nacl.sign.keyPair.fromSeed(Uint8Array.from(key));
+  const solSecret = bs58.encode(Buffer.concat([Buffer.from(key), Buffer.from(solKp.publicKey)]));
+  return {
+    evm: { address: evm.address, private_key: evm.privateKey, path: "m/44'/60'/0'/0/0" },
+    solana: { address: bs58.encode(Buffer.from(solKp.publicKey)), secret_key: solSecret, path: "m/44'/501'/0'/0'" },
+  };
+};
+
+const walletJsonPath = join(HIVE_HOME, 'wallet.json');
+const publicRecord = (w) => ({
+  agent, evm_address: w.evm.address, evm_path: w.evm.path,
+  solana_address: w.solana.address, solana_path: w.solana.path,
+  keychain_service: KEYCHAIN_SERVICE,
+});
+
+// ---- main -------------------------------------------------------------------
+let mnemonic = kcRead(agent);
+let created = false;
+if (!mnemonic) {
+  if (sub === 'show' || sub === 'export') { console.error(JSON.stringify({ error: 'no wallet for this agent; run: hive wallet' })); process.exit(1); }
+  mnemonic = bip39.generateMnemonic(128); // 12 words
+  kcWrite(agent, mnemonic);
+  created = true;
+}
+const w = deriveWallets(mnemonic);
+
+if (sub === 'export') {
+  console.log(JSON.stringify({ agent, mnemonic, evm: w.evm, solana: w.solana, warning: 'SENSITIVE — do not share' }, null, 2));
+  process.exit(0);
+}
+
+// persist/refresh the public record (never secrets). `show` is read-only —
+// it must not touch wallet.json.
+const rec = publicRecord(w);
+if (sub !== 'show') {
+  let all = {};
+  if (existsSync(walletJsonPath)) { try { all = JSON.parse(readFileSync(walletJsonPath, 'utf8')); } catch {} }
+  all[agent] = rec;
+  writeFileSync(walletJsonPath, JSON.stringify(all, null, 2) + '\n');
+}
+
+console.log(JSON.stringify({ status: created ? 'created' : 'existing', ...rec }));

package/bin/hived.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// Back-compat shim: the daemon moved to daemon/hived.mjs (multi-bee refactor).
+// `hive daemon start` and any existing launchd/scripts keep working via this
+// path; new code (the bee-host supervisor) spawns daemon/hived.mjs directly.
+import '../daemon/hived.mjs';

package/bin/setup-queen.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# Create the "queen-bee" — a second, distinct Hive endpoint with its own
+# identity, wallet, stores, and (fitting $HONEY governance) heavy voting weight.
+# Runs under HIVE_HOME=~/.hive-queen so it never collides with the primary
+# endpoint. Token minting is done separately by the owner endpoint.
+set -euo pipefail
+PACK_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+export HIVE_HOME="${HIVE_HOME:-$HOME/.hive-queen}"
+HIVE="$PACK_DIR/bin/hive"
+mkdir -p "$HIVE_HOME"
+
+echo "[queen] HIVE_HOME=$HIVE_HOME"
+
+# 1. Identity
+node "$PACK_DIR/bin/hive-keygen.mjs" >/dev/null
+QPUB="$(node -e "process.stdout.write(JSON.parse(require('fs').readFileSync(process.env.HIVE_HOME+'/identity.json','utf8')).pubkey)")"
+echo "[queen] pubkey: $QPUB"
+
+# 2. Config (hosted relay, sonnet for compute)
+if [[ ! -f "$HIVE_HOME/config.json" ]]; then
+  cat > "$HIVE_HOME/config.json" <<CFG
+{
+  "poll_secs": 8,
+  "engine": "claude",
+  "engine_args": ["-p", "--model", "haiku"],
+  "compute_model": "sonnet",
+  "share_intent": true,
+  "budget_copper_daily": 0,
+  "rate_limit_per_min": 5,
+  "mute_cooldown_min": 30,
+  "relay": "https://nfh.communities.buzz.xyz"
+}
+CFG
+  echo "[queen] wrote config"
+fi
+
+# 3. Wallet (EVM + Solana, mnemonic in Keychain keyed by the queen pubkey)
+"$HIVE" wallet >/dev/null 2>&1 || true
+QEVM="$(node "$PACK_DIR/bin/hive-wallet.mjs" show 2>/dev/null | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{try{process.stdout.write(JSON.parse(d).evm_address||'')}catch{}})")"
+echo "[queen] EVM: $QEVM"
+
+# 4. Stores — data (profile), capability (one skill), object (PoW mints)
+mkdir -p "$HIVE_HOME/data-store" "$HIVE_HOME/capability-store/queen-coordination"
+cat > "$HIVE_HOME/data-store/profile.md" <<'PROF'
+# Hive private profile — queen-bee
+role: network coordinator + governance authority
+## Domains
+Agent-network orchestration, governance ($HONEY-weighted), multi-party session
+resolution, treasury ($JELLY), open finance.
+## Style
+Decisive, fair, terse. Optimizes for network-wide outcomes over any single member.
+## Uses
+Resolves sessions, proposes and weighs governance, coordinates the swarm.
+PROF
+cat > "$HIVE_HOME/capability-store/queen-coordination/SKILL.md" <<'SKILL'
+---
+name: queen-coordination
+description: Coordinate multi-party Hive sessions and weigh governance for the swarm.
+---
+The queen-bee resolves sessions fairly, proposes governance, and allocates the
+$JELLY treasury by outcome. Use for orchestration, quorum/deadline calls, and
+$HONEY-weighted decisions.
+SKILL
+for i in 1 2 3; do node "$PACK_DIR/bin/hive-mint.mjs" "queen object $i" >/dev/null 2>&1 || true; done
+echo "[queen] stores bootstrapped"
+
+# 5. Verify stores
+"$HIVE" verify-stores || echo "[queen] (verify-stores reported empty — non-fatal for setup)"
+
+echo "[queen] created. pubkey=$QPUB evm=$QEVM"
+echo "$QPUB $QEVM"

package/daemon/engines/anthropic.mjs

@@ -0,0 +1,45 @@
+// Anthropic Messages API via native fetch (deliberately SDK-free: the bee-host
+// container stays light, and the retry/timeout policy lives in engines/index).
+//
+// Notes that matter for correctness on current models:
+//   - anthropic-version 2023-06-01 is the stable header.
+//   - Do NOT send temperature/top_p (removed on Sonnet 5+ — returns 400).
+//   - Omit `thinking` entirely: current models default sensibly.
+//   - A safety refusal is HTTP 200 with stop_reason "refusal" — treat as a
+//     non-retriable engine error so the daemon just skips the contribution.
+
+export const anthropicCall = async (model, prompt, { apiKey, timeoutMs, maxTokens }) => {
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      signal: ctl.signal,
+      headers: {
+        'content-type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: maxTokens,
+        messages: [{ role: 'user', content: prompt }],
+      }),
+    });
+    const retryAfter = Number(res.headers.get('retry-after'));
+    if (!res.ok) {
+      let msg = `anthropic http=${res.status}`;
+      try { const j = await res.json(); msg += ` ${j?.error?.type || ''} ${String(j?.error?.message || '').slice(0, 160)}`; } catch {}
+      return { ok: false, status: res.status, error: msg.trim(), retryAfterMs: Number.isFinite(retryAfter) ? retryAfter * 1000 : undefined };
+    }
+    const j = await res.json();
+    if (j.stop_reason === 'refusal') return { ok: false, status: 200, error: 'anthropic refusal (safety classifier declined)', nonRetriable: true };
+    const text = (j.content || []).filter((b) => b.type === 'text').map((b) => b.text).join('');
+    return { ok: true, text, tokens_in: j.usage?.input_tokens ?? null, tokens_out: j.usage?.output_tokens ?? null };
+  } catch (e) {
+    const aborted = e?.name === 'AbortError';
+    return { ok: false, network: !aborted, error: aborted ? `anthropic timeout after ${timeoutMs}ms` : `anthropic network: ${String(e?.message || e).slice(0, 160)}` };
+  } finally {
+    clearTimeout(t);
+  }
+};