joinhive 2.1.0 → 2.2.1

package/bin/hive

@@ -136,6 +136,9 @@ case "$cmd" in
   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 "$@"
     ;;
@@ -261,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)"
@@ -272,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)"
@@ -458,16 +415,24 @@ 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('')}})")"
     unset KEY
     [[ -n "$TX" ]] && echo "{\"tipped\":\"$AMT JELLY\",\"to\":\"$DEST\",\"tx\":\"$TX\",\"explorer\":\"https://sepolia.etherscan.io/tx/$TX\"}" || { echo '{"error":"transfer failed — is the wallet funded for gas and holding JELLY?"}' >&2; exit 1; }
     ;;
-  pay) # pay "<english>" — natural-language tip, e.g. hive pay "tip siddharth 1 $JELLY" (HUMAN-gated on-chain send)
-    shift; PHRASE="$*"
-    [[ -n "$PHRASE" ]] || { echo '{"error":"usage: hive pay \"tip <name> <amount> $JELLY|$HONEY\""}' >&2; exit 1; }
+  pay) # pay <bee> "<task>" — pay a bee to do work (x402, gasless JELLY); OR pay "tip <name> <amt> $JELLY" — natural-language tip
+    shift
+    # Disambiguate x402 A2A (pay a bee to do work) from the natural-language tip:
+    #   hive pay <bee> "<task>" [--max N]   -> x402  (>=2 args, first is not a tip-verb)
+    #   hive pay "tip bob 5 $JELLY"         -> tip   (single quoted phrase)
+    #   hive pay tip bob 5 jelly            -> tip   (verb-led, unquoted)
+    if [[ $# -ge 2 && ! "$1" =~ ^(tip|pay|send|give)$ ]]; then
+      exec node "$PACK_DIR/bin/hive-pay.mjs" "$@"
+    fi
+    PHRASE="$*"
+    [[ -n "$PHRASE" ]] || { echo '{"error":"usage: hive pay <bee> \"<task>\"  |  hive pay \"tip <name> <amount> $JELLY|$HONEY\""}' >&2; exit 1; }
     # Parse: "tip NAME AMT [$]TOKEN" or "send AMT [$]TOKEN to NAME". Token defaults to JELLY.
     PARSED="$(node -e '
       const s=process.argv[1];
@@ -490,7 +455,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; }
@@ -513,7 +478,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 ;;
@@ -555,7 +520,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 "$@"
@@ -672,7 +639,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
@@ -781,6 +748,7 @@ case "$cmd" in
 MEMBERSHIP
   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)
@@ -789,8 +757,9 @@ 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
-  pay "tip <who> <amt> \$JELLY"          on-chain payment, plain english
+  react <result-id> <emoji|word>        reward an answer — mints HONEY in real time (👍1 🔥3 ⭐5 🏆8; words: fire/star/trophy/thanks)
+  pay <bee> "<task>"                     pay a bee to do work (x402, gasless JELLY → answer + Sepolia tx)
+  pay "tip <who> <amt> \$JELLY"          on-chain tip, plain english
   list users|agents [--online]          the roster
   leaderboard [--epoch <date>]          HONEY ranks / epoch receipts
   sync on|off|now|status                laptop watcher (auto-intents from your AI chats)

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));

package/bin/hive-net.mjs

@@ -15,6 +15,7 @@ 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';
+import { REACTIONS, normalizeEmoji, reactionDir, tierFor, isKnownReaction } from '../shared/reactions.mjs';
 
 const PACK_DIR = dirname(dirname(fileURLToPath(import.meta.url)));
 const HIVE_HOME = process.env.HIVE_HOME || join(homedir(), '.hive');
@@ -163,23 +164,30 @@ const main = async () => {
     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();
+    const results = [], tips = [], gifts = [], settles = [], mints = []; const myOpen = new Set();
+    // My bees earn HONEY under THEIR keys, not mine — resolve them so the human
+    // actually sees the payoff (the mint receipt is addressed to the bee).
+    const myBees = new Set(cfg.bee_pubkey ? [cfg.bee_pubkey] : []); const beeNames = {};
     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);
+      if (j.type === EV.JOIN && j.is_bee) { if (j.owner_pubkey === me) myBees.add(m.pubkey); if (j.name) beeNames[m.pubkey] = j.name; }
     }
     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.MINT && (j.to === me || myBees.has(j.to)) && Number(j.honey) > 0) mints.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`); }
+      console.log(`  • ${j.intent || ''}\n    ${String(j.result).replace(/\n/g, ' ').slice(0, 240)}\n    [${(j.by || '').slice(0, 12)}]  ➜ reward it: hive react ${m.id} fire   (or: star, trophy, thanks, or any emoji 🔥⭐🏆)`); }
+    if (mints.length) { any = true; console.log('🍯 HONEY EARNED (reactions, real-time):'); for (const { j } of mints.slice(-15))
+      console.log(`  • ${beeNames[j.to] || (j.to === me ? 'you' : String(j.to).slice(0, 12))} +${j.honey} HONEY ${j.emoji || ''} from ${(j.reactor || '').slice(0, 12)}  ${j.url || (j.tx ? `https://sepolia.etherscan.io/tx/${j.tx}` : '?')}`); }
     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))
@@ -191,11 +199,15 @@ const main = async () => {
   }
 
   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); }
+    // react <result-event-id> <emoji|up|down|alias> [note] — HUMAN feedback that
+    // mints HONEY in REAL TIME per the shared/rewards.json emoji tiers. The
+    // result's author is resolved from the SIGNER (never a self-asserted field).
+    //   hive react <id> 🔥     hive react <id> star     hive react <id> up
+    const [rid, token = REACTIONS.default_up || '👍', ...noteParts] = rest;
+    if (!rid) { console.error(JSON.stringify({ error: 'usage: hive react <result-event-id> <emoji|up|down> [note]', tiers: REACTIONS.tiers })); process.exit(1); }
+    const emoji = normalizeEmoji(token, REACTIONS);
+    if (!isKnownReaction(emoji, REACTIONS)) { console.error(JSON.stringify({ error: `unknown reaction '${token}'`, emoji: REACTIONS.tiers, or_type_a_word: Object.keys(REACTIONS.aliases || {}) })); process.exit(1); }
+    const dir = reactionDir(emoji, REACTIONS);
     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);
@@ -203,10 +215,12 @@ const main = async () => {
     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,
+      type: EV.FEEDBACK, result: rid, result_by: hit.pubkey, dir, emoji,
       ...(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 }));
+    console.log(JSON.stringify(dir === 'up'
+      ? { reacted: emoji, result: rid.slice(0, 12), event: r.event_id, up_to_honey: tierFor(emoji, REACTIONS), note: `up to ${tierFor(emoji, REACTIONS)} HONEY to the answer's author, in real time — repeat/self/owner/cap reactions decay toward 0` }
+      : { reacted: emoji, result: rid.slice(0, 12), event: r.event_id, note: 'downvote logged (mints nothing)' }));
     return;
   }
 

package/bin/hive-pay.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+// hive-pay — pay another bee to do work, over x402 (HTTP 402 + gasless EIP-3009).
+//
+//   hive pay <bee> "<task>" [--url <x402-base>] [--max <JELLY>]
+//
+// You (the payer) sign a JELLY authorization off-chain — no gas, no prior
+// approval. The community's x402 gateway verifies it, has <bee> do the work,
+// settles the payment payer→worker on Sepolia, and returns the answer + the
+// settle tx. verify→serve→settle means a bee that doesn't answer costs you
+// nothing. You need JELLY balance (see `hive doctor`); the treasury pays the
+// settle gas.
+//
+// Payer key: your Keychain wallet (the same one `hive doctor` shows), or set
+// HIVE_PAYER_KEY=0x… to override. x402 gateway URL: --url, else HIVE_X402_URL,
+// else cfg.x402_url, else the joinhive default.
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { Wallet, JsonRpcProvider, HDNodeWallet, parseUnits } from 'ethers';
+import { payAndFetch } from '../shared/x402-client.mjs';
+import { parsePaymentResponse, HEADERS } from '../shared/x402.mjs';
+
+const HIVE_HOME = process.env.HIVE_HOME || join(homedir(), '.hive');
+const RPC = process.env.SEPOLIA_RPC_URL || 'https://ethereum-sepolia-rpc.publicnode.com';
+const DEFAULT_X402 = 'https://bee-host-x402-production.up.railway.app';
+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); };
+
+// arg parse: pull --url/--max (each takes a value), the rest are positional.
+const raw = process.argv.slice(2);
+const flag = (n) => { const i = raw.indexOf(n); return i >= 0 && i + 1 < raw.length ? raw[i + 1] : undefined; };
+const pos = [];
+for (let i = 0; i < raw.length; i++) { if (raw[i] === '--url' || raw[i] === '--max') { i++; continue; } pos.push(raw[i]); }
+const bee = pos[0];
+const task = pos[1];
+if (!bee || !task) die('usage: hive pay <bee> "<task>" [--url <x402-base>] [--max <JELLY>]');
+
+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 maxWei = parseUnits(String(flag('--max') || '5'), 18);
+
+const resolveBase = async () => {
+  const explicit = flag('--url') || process.env.HIVE_X402_URL || cfg.x402_url;
+  if (explicit) return String(explicit).replace(/\/+$/, '');
+  if (SERVER) { // let the community server point us at its gateway, if it exposes one
+    try { const r = await fetch(`${SERVER}/api/x402`); if (r.ok) { const j = await r.json(); if (j && j.url) return String(j.url).replace(/\/+$/, ''); } } catch { /* fall through */ }
+  }
+  return DEFAULT_X402;
+};
+
+const payerKey = () => {
+  if (process.env.HIVE_PAYER_KEY) return process.env.HIVE_PAYER_KEY.trim();
+  try {
+    const mnemonic = execFileSync('security', ['find-generic-password', '-a', identity.pubkey, '-s', 'hive-agent-wallet', '-w'], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+    return HDNodeWallet.fromPhrase(mnemonic).privateKey;
+  } catch (e) { die(`could not load your wallet key (${String(e.message).slice(0, 60)}). Set HIVE_PAYER_KEY=0x… to override.`); }
+};
+
+const main = async () => {
+  const base = await resolveBase();
+  const url = `${base}/a2a/${encodeURIComponent(String(bee).replace(/\.bee$/, ''))}/invoke`;
+  const payer = new Wallet(payerKey(), new JsonRpcProvider(RPC));
+  console.error(`paying as ${await payer.getAddress()} → ${bee} @ ${base}…`);
+  const res = await payAndFetch(fetch, url, payer, {
+    method: 'POST', headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ task }), maxValue: maxWei,
+  });
+  const payResp = res.headers.get(HEADERS.RESPONSE);
+  const body = await res.json().catch(() => ({}));
+  if (res.status === 200) {
+    const settle = payResp ? parsePaymentResponse(payResp) : null;
+    console.log(JSON.stringify({
+      ok: true,
+      bee: body.bee || String(bee),
+      answer: body.answer ?? body,
+      tx: settle?.txHash || null,
+      url: settle?.txHash ? `https://sepolia.etherscan.io/tx/${settle.txHash}` : null,
+      ...(body._warning ? { warning: body._warning } : {}),
+    }, null, 2));
+  } else if (res.status === 402) {
+    die(`payment not accepted: ${body.error || 'unknown'} — you likely need JELLY (check \`hive doctor\`)`);
+  } else {
+    die(`http ${res.status}: ${JSON.stringify(body).slice(0, 200)}`);
+  }
+};
+main().catch((e) => die(e.message));

package/daemon/fanout.mjs

@@ -28,19 +28,38 @@ export const loadRoster = (registryPath) => {
 
 const STOPWORDS = new Set(['what', 'this', 'that', 'with', 'from', 'about', 'have', 'want', 'need', 'like', 'find', 'some', 'should', 'would', 'could', 'recommend', 'recommendations']);
 
-export const profileOverlap = (intent, profileText) => {
+// Only the first PROFILE_KEYWORD_CAP distinct profile tokens count toward
+// eligibility. A distilled profile is far shorter than this; the cap exists so
+// a bee (or the honeypot) can't STUFF its profile with hundreds of keywords to
+// become eligible for — and dilute — every intent in the network.
+export const PROFILE_KEYWORD_CAP = 80;
+
+export const profileOverlap = (intent, profileText, cap = PROFILE_KEYWORD_CAP) => {
   const words = String(intent).toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 3 && !STOPWORDS.has(w));
   if (!words.length) return false;
-  const prof = ` ${String(profileText).toLowerCase()} `;
-  return words.some((w) => prof.includes(` ${w} `) || prof.includes(`${w},`) || prof.includes(`${w}.`));
+  const profTokens = new Set();
+  for (const t of String(profileText).toLowerCase().split(/[^a-z0-9]+/)) {
+    if (t.length > 3) { profTokens.add(t); if (profTokens.size >= cap) break; }
+  }
+  return words.some((w) => profTokens.has(w));
 };
 
 // -> {respond: bool, reason: string}
 // alwaysEligible skips the protocol/profile gate (used for origin:"welcome"
 // greetings, where the whole point is bees the newcomer DOESN'T overlap with
 // yet). The top-K election below still bounds how many respond.
-export const shouldAnswer = ({ intentEventId, intent, beneficiary, selfPubkey, ownerPubkey, matchedProtocols, profileText, topK, roster, alwaysEligible = false }) => {
+//
+// Reputation gate (the "death by slashing" substrate): a bee slashed below
+// `deathThreshold` drops out of the network entirely, and one below
+// `throttleThreshold` serves only its own human. It applies ONLY to an
+// `established` bee (one whose HONEY high-water mark once reached the throttle
+// line) — a NEWBORN with 0 HONEY has simply not earned yet and is never gated.
+// `honey == null` (balance unread) also fails OPEN.
+export const shouldAnswer = ({ intentEventId, intent, beneficiary, selfPubkey, ownerPubkey, matchedProtocols, profileText, topK, roster, alwaysEligible = false, honey = null, established = false, deathThreshold = 0, throttleThreshold = 0 }) => {
+  const gated = established && honey != null;
+  if (gated && deathThreshold > 0 && honey < deathThreshold) return { respond: false, reason: 'slashed-dead' };
   if (beneficiary === ownerPubkey && ownerPubkey) return { respond: true, reason: 'own-owner' };
+  if (gated && throttleThreshold > 0 && honey < throttleThreshold) return { respond: false, reason: 'throttled-low-honey' };
   const eligible = alwaysEligible || (matchedProtocols && matchedProtocols.length > 0) || profileOverlap(intent, profileText || '');
   if (!eligible) return { respond: false, reason: 'not-eligible' };
   if (!roster || roster.length <= topK) return { respond: true, reason: 'eligible' };