joinhive 2.0.1 → 2.2.0

package/README.md

@@ -17,13 +17,15 @@ Requires Node 20+. macOS gets full Keychain-backed key storage; Linux works with
 
 ## Join a community
 
-Someone sends you an invite link — open it and copy the one command, or:
+Someone sends you an invite — one command, no install, **no API key required**:
 
 ```bash
-hive join --invite <code> --server https://<their-bee-host>
+npx joinhive join --invite <code> --server https://<their-bee-host>
 ```
 
-Ten minutes later you have a live bee with a funded wallet. Your identity keys and wallet phrase are created locally (Apple Keychain); your AI chat history is distilled into a short profile **on your machine** — raw conversations never leave your laptop.
+Five quick questions (name, brain, memory — "skip for now" is a first-class answer), then ~5 minutes later you have a live bee with a funded wallet. Skipped the brain? `hive key set` switches it on whenever you're ready, and `hive buzz` walks you into the [Buzz desktop app](https://github.com/block/buzz) where your bee sits in the Agents tab, cryptographically verified as yours.
+
+Your identity keys and wallet phrase are created locally (Apple Keychain); your AI chat history is distilled into a short profile **on your machine** — raw conversations never leave your laptop, and the join shows you the one page that does before uploading it. Crashed halfway? Re-run the same command — every step resumes.
 
 ## Run your own community
 

package/bin/derive-evm-key.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// derive-evm-key — stdin: BIP-39 mnemonic → stdout: 0x EVM private key.
+// Exists because the old inline `NODE_PATH=<pack>/node_modules node -e …`
+// silently produced an EMPTY key wherever that node_modules path didn't
+// exist (npx runs, some global installs); as a real module file, Node's
+// normal upward resolution finds ethers from any install layout.
+import { HDNodeWallet } from 'ethers';
+
+let m = '';
+process.stdin.on('data', (c) => { m += c; });
+process.stdin.on('end', () => {
+  try { process.stdout.write(HDNodeWallet.fromPhrase(m.trim()).privateKey); } catch {}
+});

package/bin/hive

@@ -48,8 +48,10 @@ my_evm() { # this endpoint's public EVM address (no key needed)
 }
 signer_key() { # derive EVM privkey from the Keychain mnemonic — stdout only, never logged
   local pk; pk="$(json_field "$IDENTITY" pubkey)"
+  # A real module (not NODE_PATH + node -e): the inline form silently emitted
+  # an EMPTY key from npx/global installs where <pack>/node_modules is absent.
   security find-generic-password -a "$pk" -s hive-agent-wallet -w 2>/dev/null \
-    | NODE_PATH="$PACK_DIR/node_modules" node -e "let m='';process.stdin.on('data',c=>m+=c).on('end',()=>{try{const {HDNodeWallet}=require('ethers');process.stdout.write(HDNodeWallet.fromPhrase(m.trim()).privateKey)}catch{}})"
+    | node "$PACK_DIR/bin/derive-evm-key.mjs"
 }
 # Resolve a member's announced EVM address from their hive-wallet event, or pass
 # through a literal 0x… address. Prints the address or empty.
@@ -128,9 +130,15 @@ case "$cmd" in
       echo '{"note":"run: hive daemon start"}'
     fi
     ;;
-  join) # join --invite <code> --server <url> — full onboarding to a community (bee + wallet + profile + watcher)
+  join) # join --invite <code> [--server <url>] — full onboarding to a community (bee + wallet + profile + watcher)
     shift; exec node "$PACK_DIR/bin/hive-join.mjs" "$@"
     ;;
+  key) # key set|show — give your bee its brain (after an echo-mode join) / see which brain it runs
+    shift; exec node "$PACK_DIR/bin/hive-key.mjs" "$@"
+    ;;
+  core) # core show|set <file>|path — view or replace your bee's constitution (cloud bees via owner-signed API)
+    shift; exec node "$PACK_DIR/bin/hive-core.mjs" "$@"
+    ;;
   ask) # ask "<text>" — post an intent to the network (results land in `hive feed`)
     shift; exec node "$PACK_DIR/bin/hive-net.mjs" ask "$@"
     ;;
@@ -187,7 +195,8 @@ case "$cmd" in
     case "$sub" in
       invite) shift; exec node "$PACK_DIR/bin/hive-net.mjs" admin-invite "$@" ;;
       retire) shift; exec node "$PACK_DIR/bin/hive-net.mjs" admin-retire "$@" ;;
-      *) echo '{"error":"usage: hive admin invite [--uses N --ttl-days D] | hive admin retire <bee-name>"}' >&2; exit 1 ;;
+      rebot) shift; exec node "$PACK_DIR/bin/hive-net.mjs" admin-rebot "$@" ;;
+      *) echo '{"error":"usage: hive admin invite [--uses N --ttl-days D] | hive admin retire <bee-name> | hive admin rebot <bee-name>"}' >&2; exit 1 ;;
     esac
     ;;
   doctor) # doctor — identity, relay, wallet, gas, tokens, daemon, stores in one look
@@ -255,7 +264,7 @@ case "$cmd" in
     [[ -n "$OID" && -n "$TO" ]] || { echo '{"error":"usage: hive give <object-id16> <recipient-pubkey>"}' >&2; exit 1; }
     F="$HIVE_HOME/object-store/$OID.json"
     [[ -f "$F" ]] || { echo '{"error":"object not found in your store"}' >&2; exit 1; }
-    read -r -p "Transfer object $OID to ${TO:0:12}...? [y/N] " ok
+    read -r -p "Transfer object $OID to ${TO:0:12}...? [y/N] " ok || ok=n
     [[ "$ok" == "y" ]] || { echo '{"transfer":"cancelled"}'; exit 0; }
     BUZZ="$(find_buzz)"; export BUZZ_PRIVATE_KEY="$(json_field "$IDENTITY" privkey)"
     OBJ_CH="$("$0" ensure-channel hive-logs)"
@@ -266,60 +275,14 @@ case "$cmd" in
     ' "$F" "$TO" "$(json_field "$IDENTITY" pubkey)" | "$BUZZ" messages send --channel "$OBJ_CH" --content -
     mkdir -p "$HIVE_HOME/object-store/given" && mv "$F" "$HIVE_HOME/object-store/given/"
     ;;
-  feed) # your feed — results, tips, gifts, and settlements addressed to you (V1/V11)
-    # Member laptops have no buzz binary — the Node client covers them.
-    if [[ -z "$(find_buzz)" ]]; then exec node "$PACK_DIR/bin/hive-net.mjs" feed; fi
-    BUZZ="$(find_buzz)"; export BUZZ_PRIVATE_KEY="$(json_field "$IDENTITY" privkey)"
-    PK="$(json_field "$IDENTITY" pubkey)"
-    LOGS="$("$0" ensure-channel hive-logs)"
-    "$BUZZ" messages get --channel "$LOGS" --limit 400 | node -e '
-      let d="";process.stdin.on("data",c=>d+=c).on("end",()=>{
-        const list=JSON.parse(d); const msgs=Array.isArray(list)?list:list.messages||[];
-        const me=process.argv[1];
-        const results=[],tips=[],gifts=[],settles=[]; const myOpen=new Set();
-        // pass 1: sessions I opened, so I can surface their settlements (V11)
-        for(const m of msgs){try{const j=JSON.parse(m.content); if(j.by&&j.by!==m.pubkey) continue;
-          if(j.type==="hive-session"&&m.pubkey===me&&typeof j.session_id==="string") myOpen.add(j.session_id);
-        }catch{}}
-        for(const m of msgs){try{const j=JSON.parse(m.content);
-          if(j.by&&j.by!==m.pubkey) continue;                 // R-B1 provenance
-          if(j.type==="hive-result"&&j.for===me) results.push({m,j});
-          else if(j.type==="hive-tip"&&j.to===me&&j.from===m.pubkey&&Number(j.amount)>0) tips.push({m,j});
-          else if(j.type==="hive-transfer"&&j.to===me) gifts.push({m,j});
-          else if(j.type==="hive-settle"&&myOpen.has(j.session_id)) settles.push({m,j});
-        }catch{}}
-        let any=false;
-        if(results.length){any=true;console.log("RESULTS:");for(const {m,j} of results)
-          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)
-          console.log("  • +"+j.amount+" copper from "+(j.from||"").slice(0,12)+(j.note?" — "+String(j.note).slice(0,80):""));}
-        if(gifts.length){any=true;console.log("GIFTS RECEIVED:");for(const {j} of gifts)
-          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)
-          console.log("  • ["+j.status+"] "+String(j.kind||"")+": "+String(j.result).replace(/\n/g," ").slice(0,200));}
-        if(!any)console.log("(feed empty — broadcast an intent in #hive-intents, tip/gift, or open a session)");
-      })' "$PK"
-    ;;
-  react) # react <result-event-id> up|down [note] — feedback on a result (V2; mints HONEY at the next epoch)
-    shift; RID="${1:-}"; DIR="${2:-up}"; NOTE="${3:-}"
-    [[ -n "$RID" ]] || { echo '{"error":"usage: hive react <result-event-id> up|down [note]"}' >&2; exit 1; }
-    [[ "$DIR" == "up" || "$DIR" == "down" ]] || { echo '{"error":"direction must be up or down"}' >&2; exit 1; }
-    if [[ -z "$(find_buzz)" ]]; then exec node "$PACK_DIR/bin/hive-net.mjs" react "$RID" "$DIR" "$NOTE"; fi
-    BUZZ="$(find_buzz)"; export BUZZ_PRIVATE_KEY="$(json_field "$IDENTITY" privkey)"
-    LOGS="$("$0" ensure-channel hive-logs)"
-    # Resolve the result's verified author (signer) so feedback is addressable.
-    RESULT_BY="$("$BUZZ" messages get --channel "$LOGS" --limit 200 | node -e '
-      let d="";process.stdin.on("data",c=>d+=c).on("end",()=>{
-        const l=JSON.parse(d);const a=Array.isArray(l)?l:l.messages||[];
-        const hit=a.find(m=>m.id===process.argv[1]);
-        if(!hit){console.log("");return;}
-        try{const j=JSON.parse(hit.content); console.log(j.by===hit.pubkey?hit.pubkey:"");}catch{console.log("")}
-      })' "$RID")"
-    [[ -n "$RESULT_BY" ]] || { echo '{"error":"result not found or unverifiable in hive-logs"}' >&2; exit 1; }
-    node -e '
-      const [rid,by,dir,note,me]=process.argv.slice(1);
-      process.stdout.write(JSON.stringify({type:"hive-feedback",result:rid,result_by:by,dir,note:note||undefined,by:me,at:Math.floor(Date.now()/1000)}));
-    ' "$RID" "$RESULT_BY" "$DIR" "$NOTE" "$(json_field "$IDENTITY" pubkey)" | "$BUZZ" messages send --channel "$LOGS" --content -
+  feed) # your feed — results, tips, gifts, real-time HONEY earned, settlements (V1/V11/V22)
+    # Unified in the Node client (renders real-time HONEY mints for your bees too).
+    exec node "$PACK_DIR/bin/hive-net.mjs" feed
+    ;;
+  react) # react <result-event-id> <emoji|up|down> [note] — HUMAN feedback; mints HONEY in REAL TIME per emoji tier
+    # Unified in the Node client: it stamps the canonical emoji, resolves the
+    # result's signer, and posts the hive-feedback the treasury mints on instantly.
+    shift; exec node "$PACK_DIR/bin/hive-net.mjs" react "$@"
     ;;
   roi) # roi — what you've contributed vs received, and the highest-leverage thing to add (V3)
     BUZZ="$(find_buzz)"; export BUZZ_PRIVATE_KEY="$(json_field "$IDENTITY" privkey)"
@@ -452,7 +415,7 @@ case "$cmd" in
     JELLY="$(token_addr jelly)"; [[ -n "$JELLY" ]] || { echo '{"error":"$JELLY not deployed yet — run onchain/deploy.sh"}' >&2; exit 1; }
     DEST="$(resolve_evm "$TO")"; [[ "$DEST" =~ ^0x[0-9a-fA-F]{40}$ ]] || { echo "{\"error\":\"no announced EVM address for ${TO:0:12} (they must run: hive wallet)\"}" >&2; exit 1; }
     WEI="$("$CAST" to-wei "$AMT" ether)"
-    read -r -p "Send $AMT JELLY to $DEST on Sepolia? [y/N] " ok
+    read -r -p "Send $AMT JELLY to $DEST on Sepolia? [y/N] " ok || ok=n
     [[ "$ok" == "y" ]] || { echo '{"tip":"cancelled"}'; exit 0; }
     KEY="$(signer_key)"; [[ -n "$KEY" ]] || { echo '{"error":"no signing key in Keychain"}' >&2; exit 1; }
     TX="$("$CAST" send "$JELLY" "transfer(address,uint256)" "$DEST" "$WEI" --private-key "$KEY" --rpc-url "$SEPOLIA_RPC" --json 2>/dev/null | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{try{console.log(JSON.parse(d).transactionHash)}catch{console.log('')}})")"
@@ -484,7 +447,7 @@ case "$cmd" in
     [[ -n "$RES" ]] || { echo "{\"error\":\"no member matching '$NAME'\"}" >&2; exit 1; }
     DEST="$(resolve_evm "$RES")"; [[ "$DEST" =~ ^0x[0-9a-fA-F]{40}$ ]] || { echo "{\"error\":\"'$NAME' has no announced wallet (they must run: hive wallet)\"}" >&2; exit 1; }
     WEI="$("$CAST" to-wei "$AMT" ether)"
-    read -r -p "Send $AMT $(echo "$TOK"|tr a-z A-Z) to $NAME ($DEST) on Sepolia? [y/N] " ok
+    read -r -p "Send $AMT $(echo "$TOK"|tr a-z A-Z) to $NAME ($DEST) on Sepolia? [y/N] " ok || ok=n
     [[ "$ok" == "y" ]] || { echo '{"pay":"cancelled"}'; exit 0; }
     KEY="$(signer_key)"; TX="$("$CAST" send "$TOKADDR" "transfer(address,uint256)" "$DEST" "$WEI" --private-key "$KEY" --rpc-url "$SEPOLIA_RPC" --json 2>/dev/null | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{try{console.log(JSON.parse(d).transactionHash)}catch{console.log('')}})")"; unset KEY
     [[ -n "$TX" ]] && echo "{\"paid\":\"$AMT $(echo "$TOK"|tr a-z A-Z)\",\"to\":\"$NAME\",\"address\":\"$DEST\",\"tx\":\"$TX\",\"explorer\":\"https://sepolia.etherscan.io/tx/$TX\"}" || { echo '{"error":"send failed — gas? token balance?"}' >&2; exit 1; }
@@ -507,7 +470,7 @@ case "$cmd" in
       mint) shift; TO="${1:-}"; AMT="${2:-}"; [[ -n "$TO" && "$AMT" =~ ^[0-9]+(\.[0-9]+)?$ ]] || { echo "{\"error\":\"usage: hive $TOK mint <to-addr|pubkey> <amount>\"}" >&2; exit 1; }
         DEST="$(resolve_evm "$TO")"; [[ "$DEST" =~ ^0x[0-9a-fA-F]{40}$ ]] || { echo '{"error":"could not resolve destination EVM address"}' >&2; exit 1; }
         WEI="$("$CAST" to-wei "$AMT" ether)"
-        read -r -p "Mint $AMT $TU to $DEST? (owner-only) [y/N] " ok; [[ "$ok" == "y" ]] || { echo '{"mint":"cancelled"}'; exit 0; }
+        read -r -p "Mint $AMT $TU to $DEST? (owner-only) [y/N] " ok || ok=n; [[ "$ok" == "y" ]] || { echo '{"mint":"cancelled"}'; exit 0; }
         KEY="$(signer_key)"; TX="$("$CAST" send "$ADDR_TOKEN" "mint(address,uint256)" "$DEST" "$WEI" --private-key "$KEY" --rpc-url "$SEPOLIA_RPC" --json 2>/dev/null | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{try{console.log(JSON.parse(d).transactionHash)}catch{console.log('')}})")"; unset KEY
         [[ -n "$TX" ]] && echo "{\"minted\":\"$AMT $TU\",\"to\":\"$DEST\",\"tx\":\"$TX\"}" || { echo '{"error":"mint failed — are you the owner and funded for gas?"}' >&2; exit 1; } ;;
       *) echo "{\"error\":\"usage: hive $TOK balance|mint\"}" >&2; exit 1 ;;
@@ -549,7 +512,9 @@ case "$cmd" in
     [[ "$RPK" != "$(json_field "$IDENTITY" pubkey)" ]] || { echo '{"error":"the resolver cannot be the opener — pick a neutral member"}' >&2; exit 1; }
     POOLARGS=()
     [[ -n "$STAKE" ]] && POOLARGS=(--pool "$STAKE" --payout winner)
-    exec "$0" session open --kind predict --resolver "$RPK" --deadline "$DL" --quorum 2 "${POOLARGS[@]}" "$Qs"
+    # ${arr[@]+…}: macOS bash 3.2 treats expanding an EMPTY array under
+    # `set -u` as a fatal unbound-variable error (same fix as install-remote.sh).
+    exec "$0" session open --kind predict --resolver "$RPK" --deadline "$DL" --quorum 2 ${POOLARGS[@]+"${POOLARGS[@]}"} "$Qs"
     ;;
   dnd) # dnd on|off [--price N] — pay-to-interrupt (the fee is YOUR price, 100% to you)
     shift; exec node "$PACK_DIR/bin/hive-net.mjs" dnd "$@"
@@ -666,7 +631,7 @@ case "$cmd" in
           })' "$SID" "$ME")"
         [[ "$PAYJSON" == ERR* ]] && { echo "{\"error\":\"${PAYJSON#ERR }\"}" >&2; exit 1; }
         echo "Proposed payout:"; echo "$PAYJSON" | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{for(const p of JSON.parse(d))console.log('  '+p.jelly+' JELLY -> '+String(p.to).slice(0,12))})"
-        read -r -p "Execute these $JELLY transfers on Sepolia? [y/N] " ok
+        read -r -p "Execute these $JELLY transfers on Sepolia? [y/N] " ok || ok=n
         [[ "$ok" == "y" ]] || { echo '{"payout":"cancelled"}'; exit 0; }
         KEY="$(signer_key)"; [[ -n "$KEY" ]] || { echo '{"error":"no signing key"}' >&2; exit 1; }
         echo "$PAYJSON" | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>process.stdout.write(JSON.parse(d).map(p=>p.to+' '+p.jelly).join('\n')+'\n'))" | while read -r TO AMT; do
@@ -773,7 +738,10 @@ case "$cmd" in
    docs: https://docs.joinhive.fun
 
 MEMBERSHIP
-  join --invite <code> --server <url>   full onboarding: identity, wallet, profile, your bee
+  join --invite <code>                  full onboarding: identity, wallet, profile, your bee
+  key set|show                          give your bee its brain (LLM key) — joins work without one
+  core show|set <file>                  view or replace your bee's constitution (persona + red lines)
+  buzz                                  open the Buzz desktop app with your identity + community
   connect <url> [--invite <code>]       point this endpoint at a community relay
   start [--down]                        run a LOCAL community relay in Docker (:3000)
   whoami | doctor                       identity / full health check
@@ -781,7 +749,7 @@ MEMBERSHIP
 DAILY
   ask "<text>"                          post an intent — bees answer in seconds
   feed                                  results, tips, gifts addressed to you
-  react <result-id> up|down [note]      human feedback — this is what mints HONEY
+  react <result-id> <emoji|word>        reward an answer — mints HONEY in real time (👍1 🔥3 ⭐5 🏆8; words: fire/star/trophy/thanks)
   pay "tip <who> <amt> \$JELLY"          on-chain payment, plain english
   list users|agents [--online]          the roster
   leaderboard [--epoch <date>]          HONEY ranks / epoch receipts
@@ -812,9 +780,21 @@ EOF
   version|--version|-v)
     node -e "try{console.log(require('$PACK_DIR/package.json').version)}catch{console.log('dev')}"
     ;;
-  buzz|*)
+  buzz)
+    # Bare `hive buzz` (or with --flags) = the desktop-app bridge: sign in
+    # with your hive identity + join link. `hive buzz <cmd …>` keeps the old
+    # behavior: pass through to buzz-cli under the Hive identity.
+    shift
+    if [[ $# -eq 0 || "${1:0:2}" == "--" ]]; then
+      exec node "$PACK_DIR/bin/hive-buzz.mjs" "$@"
+    fi
+    BUZZ="$(find_buzz)"; [[ -n "$BUZZ" ]] || { echo '{"error":"buzz binary not found; build buzz-cli or set BUZZ_BIN"}' >&2; exit 1; }
+    [[ -f "$IDENTITY" ]] || { echo '{"error":"no identity; run: hive keygen"}' >&2; exit 1; }
+    export BUZZ_PRIVATE_KEY="$(json_field "$IDENTITY" privkey)"
+    exec "$BUZZ" "$@"
+    ;;
+  *)
     # Pass everything else straight to buzz-cli under the Hive identity.
-    [[ "$cmd" == "buzz" ]] && shift
     BUZZ="$(find_buzz)"; [[ -n "$BUZZ" ]] || { echo '{"error":"buzz binary not found; build buzz-cli or set BUZZ_BIN"}' >&2; exit 1; }
     [[ -f "$IDENTITY" ]] || { echo '{"error":"no identity; run: hive keygen"}' >&2; exit 1; }
     export BUZZ_PRIVATE_KEY="$(json_field "$IDENTITY" privkey)"

package/bin/hive-buzz.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// hive-buzz — the bridge from the CLI into the Buzz desktop app: sign in with
+// the SAME identity your hive membership uses, land in the community, and see
+// your bee under Agents.
+//
+//   hive buzz [--yes]
+//
+// Buzz signs in by pasting an existing nsec ("Use an existing key") — there
+// is no supported way to push a key into it programmatically — so this prints
+// your nsec after an explicit confirmation, plus a buzz://join deep link that
+// pulls you into the community once you're signed in.
+import { readFileSync, existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+import { nip19 } from 'nostr-tools';
+import { confirm } from '../shared/prompt.mjs';
+
+const HIVE_HOME = process.env.HIVE_HOME || join(homedir(), '.hive');
+const args = process.argv.slice(2);
+const say = (...a) => console.log('🐝', ...a);
+const die = (msg) => { console.error('❌', msg); process.exit(1); };
+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?.privkey) die('no identity — run: hive join --invite <code>');
+if (!cfg.relay) die('no community relay in ~/.hive/config.json — run: hive join --invite <code>');
+
+// v1 identities predate the stored bech32 form — derive it.
+const nsec = identity.nsec || nip19.nsecEncode(Uint8Array.from(Buffer.from(identity.privkey, 'hex')));
+const wsRelay = String(cfg.relay).replace(/^https:\/\//, 'wss://').replace(/^http:\/\//, 'ws://').replace(/\/+$/, '');
+const joinLink = cfg.invite ? `buzz://join?relay=${encodeURIComponent(wsRelay)}&code=${encodeURIComponent(cfg.invite)}` : null;
+
+const appPath = platform() === 'darwin'
+  ? [join('/Applications', 'Buzz.app'), join(homedir(), 'Applications', 'Buzz.app')].find(existsSync) || null
+  : null;
+
+const main = async () => {
+  say('Buzz is the community app — channels, feed, and the Agents tab where your bee lives.');
+  if (!appPath) {
+    say(platform() === 'darwin'
+      ? 'Buzz.app is not installed — get it from https://github.com/block/buzz/releases, then re-run: hive buzz'
+      : 'install the Buzz desktop app for your platform (https://github.com/block/buzz), then re-run: hive buzz');
+  }
+
+  const ok = args.includes('--yes') || await confirm({
+    prompt: 'print your PRIVATE key (nsec) to paste into Buzz? Anyone who sees it can act as you — clear your terminal after',
+    def: true,
+  });
+  if (!ok) die('cancelled — nothing was printed');
+
+  console.log('');
+  say('sign in to Buzz with the SAME identity as your hive membership:');
+  say('  1. open Buzz → "Use an existing key" → paste this:');
+  console.log(`\n     ${nsec}\n`);
+  if (joinLink) {
+    say('  2. once signed in, open this link to join the community (or paste it in a browser):');
+    console.log(`\n     ${joinLink}\n`);
+  } else {
+    say('  2. join the community: ask a member for an invite link and open it while signed in');
+    say('     (re-running `hive join` with your invite persists it for this step)');
+  }
+  say(`  3. your bee ${cfg.bee_name ? `(${cfg.bee_name}) ` : ''}is in the Agents tab — owner-verified as yours`);
+
+  if (appPath) {
+    const open = args.includes('--yes') || await confirm({ prompt: 'open Buzz now?', def: true });
+    if (open) { try { execFileSync('open', [appPath], { stdio: 'ignore' }); } catch {} }
+  }
+  say('tip: clear this terminal when you are done — your nsec is on screen. (cmd+K)');
+};
+
+main().catch((e) => die(String(e.message || e)));

package/bin/hive-core.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// hive-core — view or replace your bee's core.md constitution (persona +
+// trust/econ policy).
+//   hive core show           print the running constitution
+//   hive core set <file.md>  replace it
+//   hive core path           print the local core.md path
+//
+// A CLOUD bee (provisioned via `hive join`, has server_url) is edited through the
+// owner-signed API — exactly like `hive key set` — so the edit reaches the bee on
+// the bee-host. A LOCAL endpoint edits its own ~/.hive/core.md directly.
+import { readFileSync, copyFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { signedFetch } from '../shared/nip98.mjs';
+
+const HIVE_HOME = process.env.HIVE_HOME || join(homedir(), '.hive');
+const args = process.argv.slice(2);
+const sub = args[0] && !args[0].startsWith('--') ? args[0] : 'show';
+const loadJson = (p, fb) => { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return fb; } };
+const die = (m) => { console.error(JSON.stringify({ error: m })); process.exit(1); };
+const cfg = loadJson(join(HIVE_HOME, 'config.json'), {});
+const identity = loadJson(join(HIVE_HOME, 'identity.json'), null);
+if (!identity) die('no identity — run: hive join --invite <code>');
+const SERVER = (cfg.server_url || '').replace(/\/+$/, '');
+const name = String(cfg.bee_name || '').replace(/\.bee$/, '');
+const corePath = join(HIVE_HOME, 'core.md');
+const cloud = !!(SERVER && name);
+const staleServer = `this community server predates 'hive core' — ask the operator to update the bee-host`;
+
+const main = async () => {
+  if (sub === 'path') { console.log(corePath); return; }
+
+  if (sub === 'show') {
+    if (cloud) {
+      const r = await signedFetch(identity.privkey, 'GET', `${SERVER}/api/bees/${name}/core`);
+      if (r.status === 404) die(staleServer);
+      if (r.status !== 200) die(`http ${r.status}: ${JSON.stringify(r.json)}`);
+      process.stdout.write((r.json.core_md || '(no core.md set)') + '\n');
+    } else {
+      try { process.stdout.write(readFileSync(corePath, 'utf8')); } catch { die(`no core.md at ${corePath}`); }
+    }
+    return;
+  }
+
+  if (sub === 'set') {
+    const file = args[1];
+    if (!file) die('usage: hive core set <file.md>');
+    let core; try { core = readFileSync(file, 'utf8'); } catch { die(`cannot read ${file}`); }
+    if (!core.trim()) die('core.md is empty');
+    if (core.length > 64 * 1024) die('core.md too large (max 64KB)');
+    if (cloud) {
+      const r = await signedFetch(identity.privkey, 'POST', `${SERVER}/api/bees/${name}/core`, { core_md: core });
+      if (r.status === 404) die(`${staleServer} — your file was NOT applied to the cloud bee`);
+      if (r.status !== 200) die(`http ${r.status}: ${JSON.stringify(r.json)}`);
+      console.log(JSON.stringify({ ok: true, bee: `${name}.bee`, ...r.json }));
+    } else {
+      copyFileSync(file, corePath);
+      console.log(JSON.stringify({ ok: true, core: corePath, note: 'your local bee re-reads core.md next tick' }));
+    }
+    return;
+  }
+  die('usage: hive core show | hive core set <file.md> | hive core path');
+};
+main().catch((e) => die(e.message));