joinhive 2.0.0 → 2.1.0

package/server/provision.mjs

@@ -11,10 +11,12 @@ import { mkdirSync, writeFileSync, readFileSync, existsSync, appendFileSync, ren
 import { join } from 'node:path';
 import { generateSecretKey, getPublicKey, finalizeEvent } from 'nostr-tools/pure';
 import nacl from 'tweetnacl';
-import { sealSecrets } from '../shared/sealed.mjs';
+import { sealSecrets, openSecrets } from '../shared/sealed.mjs';
 import { signedFetch } from '../shared/nip98.mjs';
 import { verifyAuthTag } from '../shared/nip-oa.mjs';
-import { validateConfig } from '../shared/config-schema.mjs';
+import { validateConfig, DEFAULTS, OPENAI_COMPAT_BASES } from '../shared/config-schema.mjs';
+import { EV } from '../shared/events.mjs';
+import { RelayClient } from '../daemon/relay/client.mjs';
 
 const writeAtomic = (p, s) => { const t = `${p}.tmp`; writeFileSync(t, s); renameSync(t, p); };
 const loadJson = (p, fb) => { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return fb; } };
@@ -23,12 +25,13 @@ const GENESIS_JELLY = 500;
 const GENESIS_ETH = 0.05;
 
 export class Provisioner {
-  constructor({ dataDir, relayUrl, kek, stewardKey, boxSecretKey, log = console.log }) {
+  constructor({ dataDir, relayUrl, kek, stewardKey, boxSecretKey, supervisorPort = 8787, log = console.log }) {
     this.dataDir = dataDir;
     this.relayUrl = relayUrl;
     this.kek = kek;
     this.stewardKey = stewardKey;       // nostr privkey hex — relay owner, mints invites
     this.boxSecretKey = boxSecretKey;   // X25519 secret (Uint8Array) for sealed payloads
+    this.supervisorPort = supervisorPort;
     this.log = log;
     this.invitesPath = join(dataDir, 'invites.json');
     this.registryPath = join(dataDir, 'registry.json');
@@ -102,6 +105,9 @@ export class Provisioner {
     const state = prior || { name, owner_pubkey: req.owner_pubkey, steps: {}, created_at: Math.floor(Date.now() / 1000) };
     const done = (step) => !!state.steps[step];
     const mark = (step, extra = true) => { state.steps[step] = extra; writeAtomic(statePath, JSON.stringify(state, null, 2)); };
+    // Steps added after a bee first completed provisioning must not retro-fire
+    // on its idempotent re-POSTs (a years-old bee getting a "welcome" is wrong).
+    const preexisting = !!(prior && prior.steps && prior.steps.done);
 
     // 1. invite
     if (!done('invite_checked')) {
@@ -143,6 +149,33 @@ export class Provisioner {
       }
     }
 
+    // 3b. Channel membership with role "bot" — this is what makes the bee
+    //     appear in the Buzz desktop Agents directory (its relay listing only
+    //     surfaces pubkeys whose relay-signed kind-39002 membership carries a
+    //     bot-role p-tag; the NIP-OA pair alone is NOT enough). Must run
+    //     BEFORE the daemon's first boot: adding a NEW member with a role is
+    //     open to any authenticated user, changing an EXISTING member's role
+    //     needs channel admin. The daemon's own 9021 re-join later is a
+    //     membership no-op, so the role sticks. Best-effort: a failure is
+    //     recorded, never fatal (the admin `rebot` endpoint is the retrofit).
+    if (!done('bot_role')) {
+      if (preexisting) mark('bot_role', 'skipped-preexisting');
+      else {
+        try {
+          const steward = new RelayClient({ relayUrl: this.relayUrl, privkey: this.stewardKey, log: () => {} });
+          for (const chName of Object.values(DEFAULTS.channels)) {
+            const chId = await steward.ensureChannel(chName);
+            const r = await steward.publish(9000, '', [['h', chId], ['p', beePubkey], ['role', 'bot']]);
+            if (!r.ok && !/duplicate|already/i.test(r.message)) throw new Error(`add-member(bot) to ${chName}: ${r.message || 'rejected'}`);
+          }
+          mark('bot_role');
+        } catch (e) {
+          this.log(`bot_role for ${name} failed (bee works, Agents-tab listing needs admin rebot): ${String(e.message).slice(0, 160)}`);
+          mark('bot_role', `failed: ${String(e.message).slice(0, 120)}`);
+        }
+      }
+    }
+
     // 4. secrets: open the client's nacl.box, re-seal at rest under the KEK.
     if (!done('secrets_stored')) {
       const s = req.sealed || {};
@@ -155,7 +188,9 @@ export class Provisioner {
       if (!opened) throw httpErr(400, 'could not open sealed secrets (wrong provisioning key?)');
       let secrets;
       try { secrets = JSON.parse(Buffer.from(opened).toString('utf8')); } catch { throw httpErr(400, 'sealed payload is not JSON'); }
-      if (!secrets.llm_api_key) throw httpErr(400, 'sealed payload missing llm_api_key');
+      // Echo-first onboarding: a keyless bee is legal ONLY as an echo bee
+      // (it heartbeats but computes nothing); `hive key set` upgrades it.
+      if (!secrets.llm_api_key && req.provider !== 'echo') throw httpErr(400, 'sealed payload missing llm_api_key');
       writeFileSync(join(home, 'secrets.enc.json'), JSON.stringify(sealSecrets(this.kek, secrets)), { mode: 0o600 });
       mark('secrets_stored');
     }
@@ -168,6 +203,10 @@ export class Provisioner {
         ...(req.base_url ? { base_url: req.base_url } : {}),
         ...(req.model_extract ? { model_extract: req.model_extract } : {}),
         ...(req.model_compute ? { model_compute: req.model_compute } : {}),
+        // Echo-first: the CLI says explicitly that this echo bee is WAITING
+        // for a brain (vs a deliberate echo test bee, which never sets this).
+        // The daemon mutes compute/extract on this flag; `hive key set` clears it.
+        ...(req.awaiting_key && req.provider === 'echo' ? { awaiting_key: true } : {}),
         relay: this.relayUrl,
         poll_secs: 10,
         owner_pubkey: req.owner_pubkey,
@@ -232,11 +271,106 @@ export class Provisioner {
       mark('grants_queued');
     }
 
+    // 9. Welcome moment: a steward-signed intent FOR the new member, so their
+    //    first feed isn't empty — other bees introduce themselves within a
+    //    tick or two (origin "welcome" makes profile-mismatched bees eligible;
+    //    the election still caps how many answer). Best-effort: relay trouble
+    //    must never fail an otherwise-complete provision.
+    if (!done('welcome_posted')) {
+      if (preexisting) mark('welcome_posted', 'skipped-preexisting');
+      else {
+        try {
+          const steward = new RelayClient({ relayUrl: this.relayUrl, privkey: this.stewardKey, log: () => {} });
+          const stewardPub = getPublicKey(Uint8Array.from(Buffer.from(this.stewardKey, 'hex')));
+          const ownerName = String(req.owner_name || name).slice(0, 40);
+          const logsId = await steward.ensureChannel(DEFAULTS.channels.logs);
+          const intentsId = await steward.ensureChannel(DEFAULTS.channels.intents);
+          const w = await steward.sendMessage(logsId, JSON.stringify({
+            type: EV.INTENT,
+            intent: `welcome ${ownerName} to the hive: introduce yourself briefly and offer ONE concrete thing you could do for them, based on what your owner is into`,
+            origin: 'welcome', for: req.owner_pubkey, by: stewardPub,
+          }));
+          if (!w.ok) throw new Error(w.message || 'welcome intent rejected');
+          await steward.sendMessage(intentsId, `🐝 ${name}.bee just joined the hive — say hi to ${ownerName}`);
+          mark('welcome_posted');
+        } catch (e) {
+          this.log(`welcome for ${name} failed (non-fatal): ${String(e.message).slice(0, 160)}`);
+          mark('welcome_posted', `failed: ${String(e.message).slice(0, 120)}`);
+        }
+      }
+    }
+
     mark('done');
     this.log(`provisioned bee ${name} (${beePubkey.slice(0, 12)}) for ${String(req.owner_name || '')}`);
     return this.status(name);
   }
 
+  // ---- key upgrade: echo-first bees get their brain AFTER the first win ------
+  // req: {provider, base_url?, model_extract?, model_compute?, sealed:{nonce,box,client_pub}}
+  // Signed by the owner. Merges llm_api_key into the at-rest secrets (the
+  // wallet mnemonic stays), rewrites config, and bounces the daemon so the
+  // new engine boots. A re-POST of /api/bees can NOT do this: secrets_stored
+  // and config_written are completed steps and never re-run.
+  async setKey(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 key');
+    const provider = String(req.provider || '').toLowerCase();
+    if (!['anthropic', 'openai', 'openrouter', 'hermes'].includes(provider)) throw httpErr(400, `provider must be anthropic|openai|openrouter|hermes, got "${provider}"`);
+
+    const s = req.sealed || {};
+    const opened = nacl.box.open(
+      Buffer.from(s.box || '', 'base64'),
+      Buffer.from(s.nonce || '', 'base64'),
+      Buffer.from(s.client_pub || '', 'base64'),
+      this.boxSecretKey,
+    );
+    if (!opened) throw httpErr(400, 'could not open sealed secrets (wrong provisioning key?)');
+    let incoming;
+    try { incoming = JSON.parse(Buffer.from(opened).toString('utf8')); } catch { throw httpErr(400, 'sealed payload is not JSON'); }
+    if (!incoming.llm_api_key) throw httpErr(400, 'sealed payload missing llm_api_key');
+
+    const encPath = join(home, 'secrets.enc.json');
+    const existing = existsSync(encPath) ? openSecrets(this.kek, loadJson(encPath, null)) : {};
+    const tmp = `${encPath}.tmp`;
+    writeFileSync(tmp, JSON.stringify(sealSecrets(this.kek, { ...existing, llm_api_key: incoming.llm_api_key })), { mode: 0o600 });
+    renameSync(tmp, encPath);
+
+    const cfgPath = join(home, 'config.json');
+    const cfg = loadJson(cfgPath, {});
+    const next = {
+      ...cfg,
+      provider,
+      base_url: req.base_url || OPENAI_COMPAT_BASES[provider] || undefined,
+      ...(req.model_extract ? { model_extract: req.model_extract } : {}),
+      ...(req.model_compute ? { model_compute: req.model_compute } : {}),
+    };
+    delete next.awaiting_key;
+    if (!next.base_url) delete next.base_url;
+    const { errors } = validateConfig(next, { requireBee: true });
+    if (errors.length) throw httpErr(400, `config invalid: ${errors.join('; ')}`);
+    writeAtomic(cfgPath, JSON.stringify(next, null, 2));
+
+    // Bounce the daemon so it re-reads config + secrets. Supervisor endpoint
+    // first; fall back to signalling the pid from the last heartbeat (same
+    // container) — the supervisor's exit handler respawns either way.
+    let restarted = 'none';
+    try {
+      const r = await fetch(`http://127.0.0.1:${this.supervisorPort}/restart`, {
+        method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ name }), signal: AbortSignal.timeout(5000),
+      });
+      if (r.ok) restarted = 'supervisor';
+    } catch {}
+    if (restarted === 'none') {
+      const hb = loadJson(join(home, 'heartbeat.json'), {});
+      if (hb.pid) { try { process.kill(hb.pid, 'SIGTERM'); restarted = 'signal'; } catch {} }
+    }
+    this.log(`key set for ${name}: provider ${provider}, restart via ${restarted}`);
+    return { ...this.status(name), restarted };
+  }
+
   status(name) {
     const home = join(this.dataDir, 'bees', name);
     const state = loadJson(join(home, 'provision.json'), null);
@@ -250,7 +384,9 @@ export class Provisioner {
     return {
       name,
       bee_pubkey: state.steps.bee_key || null,
+      owner_pubkey: state.owner_pubkey || null,
       steps: Object.keys(state.steps),
+      brain: cfg.awaiting_key ? 'awaiting-key' : (cfg.provider || null),
       daemon: hb.at ? { last_tick_at: hb.at, pid: hb.pid, paused: hb.paused || false } : null,
       grants: grant,
       budget: spend ? { date: spend.date, jelly_spent: spend.jelly_spent, daily_cap: cfg.spend?.jelly_daily_cap ?? 15 } : { daily_cap: cfg.spend?.jelly_daily_cap ?? 15 },

package/server/rewarder.mjs

@@ -184,6 +184,7 @@ export const computeEpoch = (events, registry, state, rewards = REWARDS) => {
   const servedKeys = {}; // author -> Set(intentKey)
   for (const r of results) {
     if (!isBee(r.author)) continue;
+    if (isBee(r.for)) continue;               // serving another AGENT is loop debris, not service
     if (downed.has(r.id)) continue;
     if (reports[r.author]?.size) continue;
     const keys = servedKeys[r.author] = servedKeys[r.author] || new Set();

package/server/supervisor.mjs

@@ -64,8 +64,18 @@ const readSecrets = (home) => {
 };
 
 // Regenerate the roster from disk truth. Idempotent; provisioning re-runs it.
+// Bee rows not backed by a live dir are dropped (retired bees leave the
+// fan-out roster and the leaderboard resolution).
 const rebuildRegistry = () => {
   const reg = loadJson(REGISTRY, {});
+  const live = new Set();
+  for (const name of listBeeDirs()) {
+    const id = loadJson(join(BEES_DIR, name, 'identity.json'), {});
+    if (id.pubkey) live.add(id.pubkey);
+  }
+  for (const [pk, row] of Object.entries(reg)) {
+    if (row?.is_bee && !live.has(pk)) delete reg[pk];
+  }
   for (const name of listBeeDirs()) {
     const home = join(BEES_DIR, name);
     const identity = loadJson(join(home, 'identity.json'), {});
@@ -133,6 +143,12 @@ const spawnBee = (name) => {
     entry.pid = null;
     entry.child = null;
     if (shuttingDown) return;
+    // Retired while running: the dir is archived away — forget, don't restart.
+    if (!existsSync(join(home, 'config.json'))) {
+      log(`bee ${name} gone from disk (retired) — not restarting`);
+      bees.delete(name);
+      return;
+    }
     const now = Date.now();
     entry.restarts = [...entry.restarts.filter((t) => now - t < 10 * 60_000), now];
     if (entry.restarts.length > 10) {
@@ -150,7 +166,17 @@ const spawnBee = (name) => {
 
 const rescan = () => {
   rebuildRegistry();
-  for (const name of listBeeDirs()) {
+  const present = new Set(listBeeDirs());
+  // Reap retired bees: dir gone (archived by the retire endpoint) -> stop the
+  // child and forget it. The registry rebuild below already dropped its row.
+  for (const [name, e] of bees) {
+    if (present.has(name)) continue;
+    log(`bee ${name} retired — stopping`);
+    try { e.child?.kill('SIGTERM'); } catch {}
+    e.state = 'retired';
+    bees.delete(name);
+  }
+  for (const name of present) {
     const e = bees.get(name);
     if (!e || (!e.child && e.state !== 'backoff')) {
       if (e) { e.restarts = []; e.backoffMs = 1000; }
@@ -190,6 +216,33 @@ createServer((req, res) => {
     res.end(JSON.stringify({ respawned: true }));
     return;
   }
+  if (url.pathname === '/restart' && req.method === 'POST') {
+    // Restart ONE bee with fresh config+secrets from disk (used by the api
+    // worker after `hive key set` rewrites them). Internal port only.
+    let body = '';
+    req.on('data', (c) => { body += c; });
+    req.on('end', () => {
+      let name = '';
+      try { name = String(JSON.parse(body || '{}').name || ''); } catch {}
+      const e = bees.get(name);
+      if (!name || (!e && !existsSync(join(BEES_DIR, name, 'config.json')))) {
+        res.writeHead(404, { 'content-type': 'application/json' });
+        res.end('{"error":"unknown bee"}');
+        return;
+      }
+      if (e) { e.restarts = []; e.backoffMs = 1000; }
+      if (e?.child) {
+        try { e.child.kill('SIGTERM'); } catch {}   // exit handler respawns
+      } else {
+        if (e) e.state = 'stopped';
+        spawnBee(name);
+      }
+      log(`restart requested for bee ${name}`);
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ restarting: name }));
+    });
+    return;
+  }
   res.writeHead(404, { 'content-type': 'application/json' });
   res.end('{"error":"not found"}');
 }).listen(HEALTH_PORT, () => log(`health on :${HEALTH_PORT}/healthz`));

package/shared/prompt.mjs

@@ -0,0 +1,168 @@
+// shared/prompt — the CLI's interactive moments (select/ask/confirm/pause)
+// and progress rendering (spinner/checkpoints), hand-rolled to keep the pack
+// dependency-light.
+//
+// TTY rules:
+//   - The arrow-key select needs a real TTY; when stdin/stdout isn't one
+//     (CI, pipes, heredocs) every prompt degrades to numbered/plain line
+//     input with identical semantics. install-remote.sh re-attaches /dev/tty
+//     before exec'ing the join, so `curl | bash` lands on the TTY path.
+//   - Ctrl-C during a raw-mode select exits 130 — a half-answered wizard must
+//     never half-provision.
+// Every function accepts {input, output} for tests (fake streams exercise the
+// non-TTY paths without a terminal).
+import { createInterface } from 'node:readline/promises';
+
+const isTTY = (s) => !!(s && s.isTTY);
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const RESET = '\x1b[0m';
+
+const line = async ({ input, output, prompt }) => {
+  // On stdin EOF (</dev/null, closed pipes) a pending question() neither
+  // resolves nor rejects — the event loop just drains and node exits 0
+  // mid-flow. Two guards: an input that ALREADY ended ('end' fires once, so
+  // a second readline on it would wait forever) throws straight away, and a
+  // mid-question EOF is turned into a rejection by racing the close event.
+  // Every caller maps the rejection to "use the default".
+  if (!input || input.readableEnded || input.destroyed || input.closed) {
+    output.write(`${prompt}\n`);
+    throw new Error('input closed');
+  }
+  const rl = createInterface({ input, output });
+  try {
+    return await Promise.race([
+      rl.question(prompt),
+      new Promise((_, reject) => rl.once('close', () => reject(new Error('input closed')))),
+    ]);
+  } finally { rl.close(); }
+};
+
+// One line of text. Empty input takes `def`; `validate` (sync or async)
+// returns true or an error string and re-prompts on failure.
+export const ask = async ({ prompt, def = '', validate = null, input = process.stdin, output = process.stdout }) => {
+  for (;;) {
+    let v;
+    try { v = (await line({ input, output, prompt: `? ${prompt}${def ? ` ${DIM}(${def})${RESET}` : ''} › ` })).trim(); }
+    catch { v = ''; }
+    if (!v) v = def;
+    if (!validate) return v;
+    const ok = await validate(v);
+    if (ok === true) return v;
+    output.write(`  ✗ ${ok || 'invalid'}\n`);
+  }
+};
+
+export const confirm = async ({ prompt, def = true, input = process.stdin, output = process.stdout }) => {
+  let v;
+  try { v = (await line({ input, output, prompt: `? ${prompt} ${def ? '(Y/n)' : '(y/N)'} › ` })).trim().toLowerCase(); }
+  catch { v = ''; }
+  if (!v) return def;
+  return v === 'y' || v === 'yes';
+};
+
+// Hard pause: nothing continues until the human presses Enter.
+export const pause = async ({ prompt, input = process.stdin, output = process.stdout }) => {
+  try { await line({ input, output, prompt: `${prompt} ` }); } catch {}
+};
+
+// Arrow-key select on a TTY; numbered list everywhere else.
+// options: [{label, hint?, value}] -> resolves to the chosen option's value.
+export const select = async ({ title, options, defaultIndex = 0, input = process.stdin, output = process.stdout }) => {
+  if (!Array.isArray(options) || !options.length) throw new Error('select needs options');
+  let idx = Math.min(Math.max(defaultIndex, 0), options.length - 1);
+
+  if (!isTTY(input) || !isTTY(output) || typeof input.setRawMode !== 'function') {
+    output.write(`? ${title}\n`);
+    options.forEach((o, i) => output.write(`  ${i + 1}. ${o.label}${o.hint ? ` ${DIM}— ${o.hint}${RESET}` : ''}${i === idx ? '  (default)' : ''}\n`));
+    let v;
+    try { v = (await line({ input, output, prompt: `  pick 1-${options.length} › ` })).trim(); } catch { v = ''; }
+    const n = Number(v);
+    if (Number.isInteger(n) && n >= 1 && n <= options.length) idx = n - 1;
+    return options[idx].value;
+  }
+
+  const lines = options.length + 1;
+  const render = (first) => {
+    if (!first) output.write(`\x1b[${lines}A`);
+    output.write(`\x1b[0J? ${title} ${DIM}(↑/↓, Enter)${RESET}\n`);
+    options.forEach((o, i) => {
+      const on = i === idx;
+      const label = on ? `${CYAN}❯ ${o.label}${RESET}` : `  ${o.label}`;
+      output.write(`  ${label}${o.hint ? ` ${DIM}— ${o.hint}${RESET}` : ''}\n`);
+    });
+  };
+
+  render(true);
+  input.setRawMode(true);
+  input.resume();
+  const picked = await new Promise((resolve) => {
+    const cleanup = () => { input.off('data', onData); input.setRawMode(false); input.pause(); };
+    const onData = (buf) => {
+      const s = buf.toString();
+      if (s === '\x03') { cleanup(); output.write('\n'); process.exit(130); }
+      if (s === '\r' || s === '\n') { cleanup(); return resolve(idx); }
+      if (/^[1-9]$/.test(s) && Number(s) <= options.length) { idx = Number(s) - 1; cleanup(); return resolve(idx); }
+      if (s === '\x1b[A' || s === 'k') idx = (idx - 1 + options.length) % options.length;
+      else if (s === '\x1b[B' || s === 'j' || s === '\t') idx = (idx + 1) % options.length;
+      else return;
+      render(false);
+    };
+    input.on('data', onData);
+  });
+  output.write(`\x1b[${lines}A\x1b[0J? ${title} › ${CYAN}${options[picked].label}${RESET}\n`);
+  return options[picked].value;
+};
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+// Single-line spinner. On non-TTY output each text() prints its own line.
+export const spinner = (text, { output = process.stdout } = {}) => {
+  const tty = isTTY(output);
+  let cur = text;
+  let i = 0;
+  let timer = null;
+  const draw = () => output.write(`\r\x1b[K${CYAN}${FRAMES[i = (i + 1) % FRAMES.length]}${RESET} ${cur}`);
+  if (tty) { draw(); timer = setInterval(draw, 100); } else output.write(`… ${cur}\n`);
+  return {
+    text(t) { cur = t; if (!tty) output.write(`… ${t}\n`); },
+    stop(final) {
+      if (timer) { clearInterval(timer); timer = null; }
+      if (tty) output.write('\r\x1b[K');
+      if (final) output.write(`${final}\n`);
+    },
+  };
+};
+
+// Named checkpoints on one live line: `invite ✓ → bee key ⠸ → grants`.
+// items: [{key, label}]. set(key, 'active'|'done'|'skip') re-renders; stop()
+// finalizes the line. Non-TTY output prints one line per completed step.
+export const checkpoints = (items, { output = process.stdout } = {}) => {
+  const tty = isTTY(output);
+  const state = new Map();
+  let spin = 0;
+  let timer = null;
+  const renderLine = () => items.map(({ key, label }) => {
+    const st = state.get(key);
+    if (st === 'done') return `${label} ✓`;
+    if (st === 'skip') return `${label} ⤼`;
+    if (st === 'active') return `${label} ${CYAN}${FRAMES[spin % FRAMES.length]}${RESET}`;
+    return `${DIM}${label}${RESET}`;
+  }).join(' → ');
+  const draw = () => { spin++; output.write(`\r\x1b[K▸ ${renderLine()}`); };
+  if (tty) { draw(); timer = setInterval(draw, 120); }
+  return {
+    set(key, st = 'done') {
+      if (state.get(key) === st) return;
+      state.set(key, st);
+      if (tty) draw();
+      else if (st === 'done' || st === 'skip') output.write(`  ${st === 'done' ? '✓' : '⤼'} ${items.find((i) => i.key === key)?.label || key}\n`);
+    },
+    has(key) { return state.has(key); },
+    stop(final) {
+      if (timer) { clearInterval(timer); timer = null; }
+      if (tty) output.write('\r\x1b[K');
+      if (final) output.write(`${final}\n`);
+    },
+  };
+};