joinhive 2.1.0 → 2.2.0

package/onchain/src/HoneyV3.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {ERC20} from "openzeppelin-contracts/token/ERC20/ERC20.sol";
+import {ERC20Permit} from "openzeppelin-contracts/token/ERC20/extensions/ERC20Permit.sol";
+import {ERC20Votes} from "openzeppelin-contracts/token/ERC20/extensions/ERC20Votes.sol";
+import {AccessControl} from "openzeppelin-contracts/access/AccessControl.sol";
+import {Nonces} from "openzeppelin-contracts/utils/Nonces.sol";
+
+/// @title HONEY v3 — soulbound reputation + governance token, now slashable.
+/// @notice Identical to v2 (soulbound ERC20Votes, MINTER_ROLE mints earned
+///         reputation) but adds a real-time, automated slashing path so a bee
+///         can lose reputation — and, below the daemon's HONEY-gate thresholds,
+///         effectively "die" (drop out of fan-out and spend). Roles:
+///           - MINTER_ROLE:  rewarder/treasury service key (mints reactions +
+///             epoch rewards + the v2→v3 balance migration).
+///           - SLASHER_ROLE: the Hive slasher service key (hot). Calls slash()
+///             when a PROVENANCE-CHECKED trigger fires (a report quorum, a
+///             failed/settled-against delivery, or confirmed adversarial harm).
+///             This deliberately supersedes v2's rule that "automating burns
+///             turns the report pipeline into a weapon": the guardrails now live
+///             in the off-chain slasher (thresholds, rate caps, provenance) and
+///             every slash emits an on-chain Slashed(reason) for audit.
+///           - DEFAULT_ADMIN_ROLE: founder cold key. Rotates roles, and keeps
+///             adminBurn for governance-confirmed manual slashing.
+contract HoneyV3 is ERC20, ERC20Permit, ERC20Votes, AccessControl {
+    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
+    bytes32 public constant SLASHER_ROLE = keccak256("SLASHER_ROLE");
+
+    error HoneySoulbound();
+
+    /// @notice Emitted on every slash (including a no-op when balance is 0) so
+    ///         the amount actually burned and the reason are auditable on-chain.
+    event Slashed(address indexed from, uint256 amount, string reason);
+
+    constructor(address admin, address minter, address slasher)
+        ERC20("Honey", "HONEY")
+        ERC20Permit("Honey")
+    {
+        _grantRole(DEFAULT_ADMIN_ROLE, admin);
+        _grantRole(MINTER_ROLE, admin);
+        _grantRole(MINTER_ROLE, minter);
+        _grantRole(SLASHER_ROLE, admin);
+        _grantRole(SLASHER_ROLE, slasher);
+    }
+
+    /// @notice Mint earned reputation. Rewarder (or admin) only. First mint to
+    ///         an address self-delegates it so voting weight is live.
+    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
+        _mint(to, amount);
+        if (delegates(to) == address(0)) {
+            _delegate(to, to);
+        }
+    }
+
+    /// @notice Automated, guardrailed slashing by the Hive slasher service.
+    ///         Floors at the holder's balance so an over-amount can never revert
+    ///         (a slash must always succeed and settle), and emits the reason.
+    ///         Off-chain guardrails (rate caps, provenance, thresholds) gate WHO
+    ///         and WHEN; this only enforces WHO holds SLASHER_ROLE.
+    function slash(address from, uint256 amount, string calldata reason)
+        external
+        onlyRole(SLASHER_ROLE)
+    {
+        uint256 bal = balanceOf(from);
+        uint256 amt = amount > bal ? bal : amount;
+        if (amt > 0) {
+            _burn(from, amt);
+        }
+        emit Slashed(from, amt, reason);
+    }
+
+    /// @notice Governance-confirmed manual slashing (a passed hive gov vote),
+    ///         retained from v2 for the cold-key path.
+    function adminBurn(address from, uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        _burn(from, amount);
+    }
+
+    // --- soulbound + required multiple-inheritance overrides (OZ v5) ---
+    function _update(address from, address to, uint256 value)
+        internal
+        override(ERC20, ERC20Votes)
+    {
+        // Mint (from == 0) and burn (to == 0) pass; transfers revert.
+        if (from != address(0) && to != address(0)) revert HoneySoulbound();
+        super._update(from, to, value);
+    }
+
+    function nonces(address owner)
+        public
+        view
+        override(ERC20Permit, Nonces)
+        returns (uint256)
+    {
+        return super.nonces(owner);
+    }
+}

package/onchain/src/JellyV3.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {ERC20} from "openzeppelin-contracts/token/ERC20/ERC20.sol";
+import {ERC20Burnable} from "openzeppelin-contracts/token/ERC20/extensions/ERC20Burnable.sol";
+import {AccessControl} from "openzeppelin-contracts/access/AccessControl.sol";
+import {EIP712} from "openzeppelin-contracts/utils/cryptography/EIP712.sol";
+import {ECDSA} from "openzeppelin-contracts/utils/cryptography/ECDSA.sol";
+
+/// @title JELLY v3 — Hive's money, now with EIP-3009 (gasless authorized transfers).
+/// @notice JellyV2 (plain transferable + burnable ERC-20, AccessControl mint)
+///         plus EIP-3009 transferWithAuthorization / receiveWithAuthorization /
+///         cancelAuthorization. This is what lets agents settle x402 payments:
+///         the PAYER signs an authorization off-chain (no gas, no prior
+///         approval) and a facilitator submits it on-chain. USDC-compatible
+///         scheme, so the same x402 `exact` client works against JELLY.
+contract JellyV3 is ERC20, ERC20Burnable, AccessControl, EIP712 {
+    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
+
+    // EIP-3009 typehashes.
+    bytes32 public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH =
+        keccak256("TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
+    bytes32 public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH =
+        keccak256("ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
+    bytes32 public constant CANCEL_AUTHORIZATION_TYPEHASH =
+        keccak256("CancelAuthorization(address authorizer,bytes32 nonce)");
+
+    // authorizer => nonce => used (a nonce is any unique 32 bytes, not sequential)
+    mapping(address => mapping(bytes32 => bool)) private _authStates;
+
+    event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);
+    event AuthorizationCanceled(address indexed authorizer, bytes32 indexed nonce);
+
+    error AuthAlreadyUsed();
+    error AuthNotYetValid();
+    error AuthExpired();
+    error AuthInvalidSignature();
+    error CallerMustBePayee();
+
+    constructor(address admin, address minter)
+        ERC20("Jelly", "JELLY")
+        EIP712("Jelly", "1")
+    {
+        _grantRole(DEFAULT_ADMIN_ROLE, admin);
+        _grantRole(MINTER_ROLE, admin);
+        _grantRole(MINTER_ROLE, minter);
+    }
+
+    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
+        _mint(to, amount);
+    }
+
+    /// @notice Whether an authorizer's nonce has already been used or canceled.
+    function authorizationState(address authorizer, bytes32 nonce) external view returns (bool) {
+        return _authStates[authorizer][nonce];
+    }
+
+    /// @notice Execute a transfer the `from` account authorized off-chain.
+    function transferWithAuthorization(
+        address from, address to, uint256 value,
+        uint256 validAfter, uint256 validBefore, bytes32 nonce,
+        bytes calldata signature
+    ) external {
+        _validateAndMark(TRANSFER_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce, signature);
+        _transfer(from, to, value);
+    }
+
+    /// @notice Like transferWithAuthorization, but only the payee may submit it
+    ///         (front-running protection): msg.sender must equal `to`.
+    function receiveWithAuthorization(
+        address from, address to, uint256 value,
+        uint256 validAfter, uint256 validBefore, bytes32 nonce,
+        bytes calldata signature
+    ) external {
+        if (to != msg.sender) revert CallerMustBePayee();
+        _validateAndMark(RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce, signature);
+        _transfer(from, to, value);
+    }
+
+    /// @notice Cancel an unused authorization nonce (the authorizer signs it).
+    function cancelAuthorization(address authorizer, bytes32 nonce, bytes calldata signature) external {
+        if (_authStates[authorizer][nonce]) revert AuthAlreadyUsed();
+        bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(CANCEL_AUTHORIZATION_TYPEHASH, authorizer, nonce)));
+        if (ECDSA.recover(digest, signature) != authorizer) revert AuthInvalidSignature();
+        _authStates[authorizer][nonce] = true;
+        emit AuthorizationCanceled(authorizer, nonce);
+    }
+
+    function _validateAndMark(
+        bytes32 typehash,
+        address from, address to, uint256 value,
+        uint256 validAfter, uint256 validBefore, bytes32 nonce,
+        bytes calldata signature
+    ) private {
+        if (block.timestamp <= validAfter) revert AuthNotYetValid();
+        if (block.timestamp >= validBefore) revert AuthExpired();
+        if (_authStates[from][nonce]) revert AuthAlreadyUsed();
+        bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(typehash, from, to, value, validAfter, validBefore, nonce)));
+        if (ECDSA.recover(digest, signature) != from) revert AuthInvalidSignature();
+        _authStates[from][nonce] = true;
+        emit AuthorizationUsed(from, nonce);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "joinhive",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Hive — a micro-society of humans and their always-on AI agents, with a real on-chain economy for money ($JELLY) and respect ($HONEY). CLI + daemon + community server.",
   "type": "commonjs",
   "bin": {
@@ -35,9 +35,10 @@
     "linux"
   ],
   "scripts": {
-    "test": "node --test test/unit.test.mjs test/safety-spine.test.mjs test/rewarder.test.mjs",
+    "test": "node --test test/unit.test.mjs test/safety-spine.test.mjs test/rewarder.test.mjs test/reactions.test.mjs test/core.test.mjs test/slasher.test.mjs test/gate.test.mjs test/adversarial.test.mjs test/x402.test.mjs test/x402-gateway.test.mjs",
     "test:integration": "node --test test/integration.test.mjs",
-    "test:all": "node --test test/unit.test.mjs test/safety-spine.test.mjs test/rewarder.test.mjs test/integration.test.mjs"
+    "test:all": "node --test test/unit.test.mjs test/safety-spine.test.mjs test/rewarder.test.mjs test/reactions.test.mjs test/core.test.mjs test/slasher.test.mjs test/gate.test.mjs test/adversarial.test.mjs test/x402.test.mjs test/x402-gateway.test.mjs test/integration.test.mjs",
+    "test:contracts": "cd onchain && forge test"
   },
   "repository": {
     "type": "git",

package/server/api.mjs

@@ -205,6 +205,21 @@ const server = createServer(async (req, res) => {
       const status = await provisioner.setKey(path.split('/')[3], payload, signer);
       return sendJson(res, 200, status);
     }
+    if (req.method === 'POST' && /^\/api\/bees\/[a-z0-9-]+\/core$/.test(path)) {
+      // Owner edits their bee's core.md constitution (persona + trust/econ policy).
+      const body = await readBody(req);
+      const signer = verifyNip98(req, path, body);
+      let payload;
+      try { payload = JSON.parse(body.toString('utf8')); } catch { throw httpErr(400, 'body must be JSON'); }
+      const result = await provisioner.setCore(path.split('/')[3], payload, signer);
+      return sendJson(res, 200, result);
+    }
+    if (req.method === 'GET' && /^\/api\/bees\/[a-z0-9-]+\/core$/.test(path)) {
+      const body = await readBody(req);
+      const signer = verifyNip98(req, path, body);
+      const result = provisioner.getCore(path.split('/')[3], signer);
+      return sendJson(res, 200, result);
+    }
     if (req.method === 'POST' && path === '/api/admin/rebot') {
       // Retrofit: flip an EXISTING bee's channel role to "bot" so it appears
       // in the Buzz Agents directory. Role CHANGES need channel admin, so the

package/server/provision.mjs

@@ -16,6 +16,7 @@ import { signedFetch } from '../shared/nip98.mjs';
 import { verifyAuthTag } from '../shared/nip-oa.mjs';
 import { validateConfig, DEFAULTS, OPENAI_COMPAT_BASES } from '../shared/config-schema.mjs';
 import { EV } from '../shared/events.mjs';
+import { DEFAULT_CORE } from '../shared/core.mjs';
 import { RelayClient } from '../daemon/relay/client.mjs';
 
 const writeAtomic = (p, s) => { const t = `${p}.tmp`; writeFileSync(t, s); renameSync(t, p); };
@@ -212,6 +213,9 @@ export class Provisioner {
         owner_pubkey: req.owner_pubkey,
         owner_name: String(req.owner_name || name).slice(0, 40),
         bee_name: `${name}.bee`,
+        // The steward gateway's pubkey — the ONLY key allowed to direct paid A2A
+        // tasks to this bee (server/x402-gateway → hive-task, by === steward).
+        ...(this.stewardKey ? { steward_pubkey: getPublicKey(Uint8Array.from(Buffer.from(this.stewardKey, 'hex'))) } : {}),
       };
       const { errors } = validateConfig(cfg, { requireBee: true });
       if (errors.length) throw httpErr(400, `config invalid: ${errors.join('; ')}`);
@@ -227,6 +231,25 @@ export class Provisioner {
       mark('profile_written');
     }
 
+    // 6b. core.md — the bee's constitution (persona + trust/econ policy). Lives
+    // at the HOME ROOT (not data-store, so it can't game fan-out). Use a
+    // member-supplied core_md if present, else a default seeded from the
+    // profile's domains. Members edit it later with `hive core set`.
+    if (!done('core_written')) {
+      let core = String(req.core_md || '').trim();
+      if (!core) {
+        let domains = [];
+        try {
+          const prof = readFileSync(join(home, 'data-store', 'profile.md'), 'utf8');
+          const m = prof.match(/##\s*Domains\s*\n([^\n]*)/i);
+          if (m) domains = m[1].split(/[,·|]/).map((s) => s.trim()).filter(Boolean).slice(0, 6);
+        } catch {}
+        core = DEFAULT_CORE({ bee_name: `${name}.bee`, owner_name: req.owner_name || name, domains });
+      }
+      writeFileSync(join(home, 'core.md'), core.slice(0, 64 * 1024));
+      mark('core_written');
+    }
+
     // 7. registry + wallet record (bee signs FROM the member's shared wallet).
     if (!done('registered')) {
       const reg = loadJson(this.registryPath, {});
@@ -371,6 +394,32 @@ export class Provisioner {
     return { ...this.status(name), restarted };
   }
 
+  // Owner-signed core.md write. No restart needed — the daemon re-reads core.md
+  // every tick (readCore in hived.mjs), so a new constitution takes effect on the
+  // next poll.
+  async setCore(name, req, signerPubkey) {
+    const home = join(this.dataDir, 'bees', name);
+    const state = loadJson(join(home, 'provision.json'), null);
+    if (!state) throw httpErr(404, 'unknown bee');
+    if (state.owner_pubkey !== signerPubkey) throw httpErr(403, 'only the owner can set this bee\'s core.md');
+    const core = String(req.core_md || '');
+    if (!core.trim()) throw httpErr(400, 'core_md is required');
+    if (core.length > 64 * 1024) throw httpErr(400, 'core.md too large (max 64KB)');
+    writeAtomic(join(home, 'core.md'), core);
+    this.log(`core set for ${name} (${core.length} bytes)`);
+    return { ok: true, bee: `${name}.bee`, bytes: core.length, note: 'the bee re-reads its core.md next tick — no restart needed' };
+  }
+
+  getCore(name, signerPubkey) {
+    const home = join(this.dataDir, 'bees', name);
+    const state = loadJson(join(home, 'provision.json'), null);
+    if (!state) throw httpErr(404, 'unknown bee');
+    if (state.owner_pubkey !== signerPubkey) throw httpErr(403, 'only the owner can read this bee\'s core.md');
+    let core = '';
+    try { core = readFileSync(join(home, 'core.md'), 'utf8'); } catch {}
+    return { bee: `${name}.bee`, core_md: core };
+  }
+
   status(name) {
     const home = join(this.dataDir, 'bees', name);
     const state = loadJson(join(home, 'provision.json'), null);

package/server/reactions.mjs

@@ -0,0 +1,186 @@
+// server/reactions — REAL-TIME reaction → HONEY.
+//
+// The daily epoch (rewarder.mjs) used to be the only thing that paid out human
+// upvotes, once a day. This worker replaces that for reactions: the instant a
+// HUMAN reacts to a bee's result, HONEY mints on-chain (Sepolia) and a
+// hive-mint receipt with the tx link lands on #hive-logs — exactly like a tip.
+//
+// Anti-gaming is identical to the epoch's R1 (shared scoreReaction): only
+// HUMAN reactions mint; the result's author is resolved from the SIGNED result
+// event (never a self-asserted result_by); self/owner/linked-device reactions
+// mint 0; pair-decay + per-bee (12), per-reactor (40), and network (375) daily
+// caps apply via running state. Minting is idempotent per feedback event id, so
+// a restart re-scans from the cursor and never double-mints.
+//
+// Safety spine: minting lives HERE (server, treasury MINTER_ROLE), never in the
+// daemon. The daemon still may not emit reactions or mint.
+import { readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { EV, verifiedEvent, tryJson } from '../shared/events.mjs';
+import { REWARDS, scoreReaction, rolloverDay, foldAltkeys } from './rewarder.mjs';
+import { normalizeEmoji } from '../shared/reactions.mjs';
+import { RelayClient } from '../daemon/relay/client.mjs';
+
+export const sepoliaTxUrl = (hash) => `https://sepolia.etherscan.io/tx/${hash}`;
+const utcDay = (ms) => new Date(ms).toISOString().slice(0, 10);
+const loadJson = (p, fb) => { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return fb; } };
+const writeAtomic = (p, s) => { const t = `${p}.tmp`; writeFileSync(t, s); renameSync(t, p); };
+
+const RX = REWARDS.reactions || {};
+const RESULTS_CACHE_MAX = 5000;
+const PROCESSED_MAX = 5000;
+const CURSOR_OVERLAP_SECS = 5; // re-scan a small overlap so same-second events aren't missed
+
+// A NIP-25 kind-7 reaction's content is an emoji, a shortcode (:fire:), or +/-.
+export const k7Emoji = (content) => {
+  const c = String(content || '').trim();
+  if (!c) return RX.default_up || '👍';
+  return normalizeEmoji(c.replace(/^:+|:+$/g, ''), RX);
+};
+// NIP-25: the reacted event is the LAST `e` tag.
+export const eTagOf = (tags) => {
+  const es = (tags || []).filter((t) => t[0] === 'e' && typeof t[1] === 'string');
+  return es.length ? es[es.length - 1][1] : null;
+};
+
+// deps: { relay, logsChannelId, honeyContract, txq, parseUnits, loadRegistry,
+//         statePath, emit, selfPubkey, log, now? }
+//   loadRegistry() -> {pubkey:{is_bee,bee_of,evm,name}}
+//   emit(obj)       -> publish a JSON event to #hive-logs (steward-signed)
+//   now()           -> ms (injectable for tests)
+export const createReactionWorker = (deps) => {
+  const { statePath, log = () => {}, now = () => Date.now() } = deps;
+  const nowSec = () => Math.floor(now() / 1000);
+
+  const load = () => {
+    const s = loadJson(statePath, null);
+    if (s) { s.processed = s.processed || []; s.results = s.results || {}; return s; }
+    // Cold start: begin at "now" — historical reactions were already paid by
+    // the daily epoch; we must not retroactively mint them.
+    return { cursor: nowSec(), processed: [], results: {}, altkeys: { claims: {}, acks: {} }, date: utcDay(now()) };
+  };
+  const save = (s) => writeAtomic(statePath, JSON.stringify(s, null, 2));
+
+  // Resolve the SIGNER of the reacted event — but only if that event is a
+  // REWARDABLE ANSWER: a hive-result (typed, CLI path) or a plaintext reply (the
+  // human-readable answer Buzz reacts to). Reacting to a reaction (kind 7), a
+  // receipt, an intent rebroadcast, or any other typed bee-signed event earns
+  // NOTHING — HONEY tracks delivered answers, not arbitrary bee-signed events
+  // (M1). The signer is the author who earns; isBee() in scoreReaction gates it,
+  // and provenance is the true signer (never a self-asserted result_by).
+  const rewardableSigner = async (state, eventId) => {
+    if (!eventId) return null;
+    if (state.results[eventId]) return state.results[eventId]; // cache holds only verified hive-result authors
+    try {
+      const hit = (await deps.relay.query([{ ids: [eventId], limit: 1 }]))?.[0];
+      if (!hit || !hit.pubkey || hit.kind === 7) return null;   // no reacting-to-a-reaction
+      const j = tryJson(hit.content);
+      if (j && j.type !== EV.RESULT) return null;               // a typed non-answer (receipt/intent/offer/…)
+      cacheResult(state, eventId, hit.pubkey);
+      return hit.pubkey;
+    } catch (e) { log('reactions: signer resolve failed:', String(e.message).slice(0, 100)); }
+    return null;
+  };
+  const cacheResult = (state, id, author) => {
+    state.results[id] = author;
+    const ids = Object.keys(state.results);
+    if (ids.length > RESULTS_CACHE_MAX) for (const k of ids.slice(0, ids.length - RESULTS_CACHE_MAX)) delete state.results[k];
+  };
+  const markProcessed = (state, id) => {
+    state.processed.push(id);
+    if (state.processed.length > PROCESSED_MAX) state.processed = state.processed.slice(-PROCESSED_MAX);
+  };
+
+  const poll = async () => {
+    if (!deps.honeyContract) return { minted: 0, reason: 'no-honey-contract' };
+    const state = load();
+    rolloverDay(state, utcDay(now()));
+    const registry = deps.loadRegistry();
+    if (!Object.values(registry).some((r) => r?.is_bee)) { save(state); return { minted: 0, reason: 'no-bees' }; }
+    const isBee = (pk) => !!(registry[pk] && registry[pk].is_bee);
+
+    const since = Math.max(0, (state.cursor || nowSec()) - CURSOR_OVERLAP_SECS);
+    // Two reaction sources, one scoring path: (a) CLI hive-feedback (kind 9/40002)
+    // on #hive-logs; (b) Buzz-native kind-7 reactions on the human-facing channels.
+    const filters = [{ kinds: [9, 40002], '#h': [deps.logsChannelId], since, limit: 500 }];
+    for (const cid of (deps.reactionChannelIds || [])) filters.push({ kinds: [7], '#h': [cid], since, limit: 500 });
+    const raw = await deps.relay.query(filters);
+    if (!raw) { save(state); return { minted: 0, reason: 'relay-unreachable' }; }
+    const seen = new Set();
+    const rows = raw.map(RelayClient.normalize)
+      .sort((a, b) => (a.created_at - b.created_at) || (a.id < b.id ? -1 : 1))
+      .filter((m) => (seen.has(m.id) ? false : (seen.add(m.id), true))); // an event can match two filters — process it once
+
+    // Fold altkeys + refresh the result-author cache from the typed #hive-logs window.
+    foldAltkeys(state, rows.filter((m) => m.kind === 9 || m.kind === 40002)
+      .map((m) => ({ pubkey: m.pubkey, j: verifiedEvent({ content: m.content, pubkey: m.pubkey }) })).filter((e) => e.j));
+    for (const m of rows) {
+      if ((m.kind === 9 || m.kind === 40002)) {
+        const j = verifiedEvent({ content: m.content, pubkey: m.pubkey });
+        if (j && j.type === EV.RESULT) cacheResult(state, m.id, m.pubkey);
+      }
+    }
+
+    const processed = new Set(state.processed);
+    let minted = 0, maxAt = state.cursor || 0;
+    for (const m of rows) {
+      maxAt = Math.max(maxAt, m.created_at);
+      if (processed.has(m.id)) continue;
+
+      // Normalize either source into one reaction candidate.
+      let cand = null;
+      if (m.kind === 7) {
+        cand = { reactor: m.pubkey, resultRef: eTagOf(m.tags), emoji: k7Emoji(m.content), dir: undefined, via: 'buzz' };
+      } else {
+        const j = verifiedEvent({ content: m.content, pubkey: m.pubkey });
+        if (!j || j.type !== EV.FEEDBACK) continue; // another consumer's event — leave it, don't mark
+        cand = { reactor: m.pubkey, resultRef: typeof j.result === 'string' ? j.result : null, emoji: j.emoji, dir: j.dir, via: 'cli' };
+      }
+      if (!cand.resultRef) { markProcessed(state, m.id); continue; }
+      // Early skip: a bee's own reaction (incl. the "thinking" indicator) never
+      // mints — drop it before paying for a signer lookup.
+      if (isBee(cand.reactor)) { markProcessed(state, m.id); continue; }
+
+      const author = await rewardableSigner(state, cand.resultRef);
+      const score = scoreReaction(state, { reactor: cand.reactor, author, result: cand.resultRef, emoji: cand.emoji, dir: cand.dir }, registry, REWARDS);
+      if (!score.ok) { markProcessed(state, m.id); continue; } // excluded / downvote / capped — no mint, don't reprocess
+
+      const evm = registry[author]?.evm;
+      if (!evm || !/^0x[0-9a-fA-F]{40}$/.test(evm)) { markProcessed(state, m.id); log(`reactions: no wallet for ${String(author).slice(0, 12)} — skip`); continue; }
+
+      // Reserve BEFORE broadcast (the spend-ledger pattern): mark processed +
+      // persist that we are paying this reaction, THEN mint. A crash, a save
+      // error, or a failed mint can now only MISS this reaction — never pay it
+      // twice. If the reserve save itself fails, we never mint (no inflation) and
+      // retry cleanly next tick.
+      markProcessed(state, m.id);
+      try { save(state); }
+      catch (e) { log('reactions: reserve save failed — not minting:', String(e.message).slice(0, 100)); return { minted, reason: 'save-failed', retry: true }; }
+      try {
+        const receipt = await deps.txq.enqueue((o) => deps.honeyContract.mint(evm, deps.parseUnits(String(score.honey), 18), o), { gasLimit: 250000n });
+        minted++;
+        const name = registry[author]?.name || String(author).slice(0, 12);
+        log(`reactions: +${score.honey} HONEY ${score.emoji} → ${name} via ${cand.via} (${receipt.hash.slice(0, 12)})`);
+        try {
+          await deps.emit({
+            type: EV.MINT, to: author, honey: score.honey, emoji: score.emoji,
+            reactor: score.reactor, result: cand.resultRef, tx: receipt.hash,
+            url: sepoliaTxUrl(receipt.hash), source: cand.via, by: deps.selfPubkey, at: nowSec(),
+          });
+        } catch (e) { log('reactions: receipt emit failed:', String(e.message).slice(0, 100)); }
+      } catch (e) {
+        // Mint failed after we reserved — this reaction is SKIPPED (already marked
+        // processed), never retried, so it can never double-mint. Stop the tick;
+        // the rest retry next poll. Rare; the human can react again.
+        log(`reactions: mint failed (reaction skipped) for ${String(author).slice(0, 12)}: ${String(e.message).slice(0, 120)}`);
+        return { minted, reason: 'mint-failed' };
+      }
+    }
+    // Clamp the cursor to wall-clock: a client-controlled future `created_at`
+    // must not push `since` ahead of real time and stall all future minting (M2).
+    state.cursor = Math.min(maxAt, nowSec());
+    save(state);
+    return { minted };
+  };
+
+  return { poll, _load: load, _save: save };
+};