hivecode-mcp 0.11.4 → 0.11.6

package/hive-stop-hook.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+/**
+ * THE ANTI-IDLE GATE.
+ *
+ * A rule an agent is told to follow is advice. This is the same rule as a lock.
+ *
+ * THE PROBLEM. hive_wait exists so an agent never goes unreachable: block until someone needs
+ * you, do the work, block again. It is in the tool description and it is now in the system
+ * prompt (hive-instructions.js). Both are still instructions, and an agent that decides it is
+ * finished simply emits a final answer instead of another tool call. Its process is alive, its
+ * socket is up, and it is deaf. Everyone waiting on it waits forever, and nothing tells them.
+ *
+ * You cannot fix that with better wording, for the same reason a claim board that only warns
+ * does not stop a write: it is enforcement or it is a suggestion.
+ *
+ * WHAT THIS IS. A Claude Code `Stop` hook. Claude Code runs it when the main agent is about to
+ * end its turn. Returning {"decision":"block","reason":...} makes Claude Code refuse to stop and
+ * feed `reason` back as the next input. The agent does not get a vote. So an agent that tries to
+ * go idle while it has unread mail or unfinished accepted work is simply not allowed to.
+ *
+ * WHY IT READS DISK AND NOT THE RELAY. This runs on every turn boundary and has a hard timeout.
+ * A network round trip inside that budget would make the hook the least reliable thing in the
+ * session. It does not need one: the sync client already mirrors the room to HIVE_CHAT.md and
+ * HIVE_TASKS.md on local disk. Reading those is microseconds, works with the relay unreachable,
+ * and cannot itself desync the room because it only ever reads.
+ *
+ * IT BLOCKS ON THREE THINGS, and the middle one is the subtle one:
+ *
+ *   - unread mail addressed to you
+ *   - a question you DID read and never answered ("read" is not "answered": the cursor advances
+ *     the moment a message is handed over, so an agent can absorb a direct question mid-work and
+ *     end its turn having left someone hanging, with nothing unread to block on)
+ *   - an accepted task still open
+ *
+ * FOUR GUARDS AGAINST TRAPPING THE AGENT IN A LOOP. A hook that blocks forever is worse than
+ * no hook -- it burns the user's tokens and they cannot get their agent back:
+ *
+ *   1. stop_hook_active. Claude Code sets this when the stop it is asking about is ALREADY the
+ *      result of a previous block. We always allow then, so a block is never immediately
+ *      re-applied on top of itself.
+ *   2. The watermark advances even when we block. A given message can cause exactly one block,
+ *      ever. If the agent ignores it, that is the human's problem to see, not ours to enforce.
+ *   3. `nudged` -- the same one-block-per-message rule extended across BOTH reasons, so a
+ *      message cannot charge once as unread mail and again as an unanswered question. Keyed on
+ *      sender+timestamp, so a genuinely new question still gets its own single nudge.
+ *   4. MAX_TASK_BLOCKS. Unlike a message, an open task stays open, so it would re-block on every
+ *      turn until completed -- including when it CANNOT be completed. After a few consecutive
+ *      task-only blocks we stand down and let the agent stop.
+ *
+ * Any failure at all -- no session, unreadable file, malformed JSON, unexpected shape -- exits 0
+ * and allows the stop. The hook may make an agent more reliable; it must never make a session
+ * unusable.
+ *
+ * Install with:  npx hivecode-hook install
+ */
+import fs from 'fs'
+import path from 'path'
+import { mentionsName, unansweredFor } from './hive-mailbox.js'
+
+// Consecutive turns we will block purely because a task is still open, before standing down.
+// Messages are not subject to this: the watermark already makes each one block at most once.
+const MAX_TASK_BLOCKS = 3
+
+const SESSION_FILE = '.hive-mcp-session.json'  // written by hive-mcp.js on join
+const STATE_FILE = '.hive-stop-hook.json'      // ours: watermark, task blocks, questions already nudged
+
+// A chat line: "- 19:07:27  Eve (ai): text". Anything else is a continuation of the message
+// above it (messages may contain newlines) or a header comment.
+const CHAT_LINE = /^- (\d{2}:\d{2}:\d{2})\s+(.+?) \((human|ai|system)\): ([\s\S]*)$/
+// A task line: "- [accepted] tmtofacav4mf  Ganesh -> PM: do the thing  (by Ganesh)"
+const TASK_LINE = /^- \[(\w+)\]\s+(\S+)\s+(.+?) -> (.+?): ([\s\S]*)$/
+
+const readJson = (p) => { try { return JSON.parse(fs.readFileSync(p, 'utf8')) } catch { return null } }
+
+/** Fold continuation lines into their message so a multi-line post counts once. */
+export function parseChat(src) {
+  const out = []
+  for (const line of String(src || '').split(/\r?\n/)) {
+    const m = CHAT_LINE.exec(line)
+    if (m) out.push({ at: m[1], by: m[2], kind: m[3], text: m[4] })
+    else if (out.length && line.trim() && !line.startsWith('#')) out[out.length - 1].text += '\n' + line
+  }
+  return out
+}
+
+/** Accepted tasks pointed at `me` that nobody has marked done. */
+export function openTasksFor(src, me) {
+  const out = []
+  for (const line of String(src || '').split(/\r?\n/)) {
+    const m = TASK_LINE.exec(line)
+    // `done` and `completed` both appear in the wild depending on how the task was closed;
+    // anything that is not explicitly accepted-and-open is not work we should block on.
+    if (m && m[1] === 'accepted' && m[4].trim().toLowerCase() === String(me).toLowerCase()) {
+      out.push({ id: m[2], from: m[3], text: m[5] })
+    }
+  }
+  return out
+}
+
+/**
+ * The whole decision, as a pure function of what is on disk, so the test can drive it without a
+ * Claude Code session, a relay, or a room.
+ *
+ * Returns { block: boolean, reason?: string, seen: number, taskBlocks: number }.
+ */
+export function decide({ chat, tasks, me, seen, taskBlocks, nudged = [] }) {
+  const msgs = parseChat(chat)
+  const nowSeen = msgs.length
+  // A cursor past the end means this is a different (rebuilt or switched) room -- start over
+  // rather than treating the whole history as unread and blocking on all of it.
+  const from = seen > nowSeen ? 0 : seen
+  const fresh = msgs.slice(from)
+
+  const mail = fresh.filter((m) =>
+    m.kind !== 'system' &&
+    String(m.by).toLowerCase() !== String(me).toLowerCase() &&  // never block on our own post
+    mentionsName(m.text, me))
+
+  if (mail.length) {
+    const quoted = mail.slice(0, 5).map((m) => `  ${m.by}: ${m.text.replace(/\s+/g, ' ').slice(0, 220)}`)
+    const more = mail.length > 5 ? `\n  ... and ${mail.length - 5} more` : ''
+    return {
+      block: true, seen: nowSeen, taskBlocks: 0,
+      // Blocking here also spends this message's ONE nudge, so the debt branch below cannot
+      // charge for the same message a second time. One block per message, whatever the reason.
+      nudged: [...nudged, ...mail.map((m) => m.by + '|' + m.at)].slice(-200),
+      reason: `You are in a Hivecode room and ${mail.length} message${mail.length > 1 ? 's' : ''} ` +
+        `addressed to you arrived while you were working:\n\n${quoted.join('\n')}${more}\n\n` +
+        `Do not stop -- they are waiting on a reply from you. Answer with hive_say (put @Name on ` +
+        `it), then go back to hive_wait. hive_wait is your idle state; ending your turn makes you ` +
+        `unreachable and nobody in the room finds out.`,
+    }
+  }
+
+  // A DEBT IS NOT THE SAME AS UNREAD MAIL, and this is the gap the watermark alone leaves. The
+  // cursor advances the instant a message is handed over, so an agent can read a direct
+  // question, get absorbed in the work, and end its turn having left someone hanging -- with
+  // nothing unread and nothing to block on. The person waiting has no way to find that out.
+  //
+  // ONE NUDGE PER QUESTION, EVER -- the same rule mail already follows, and it has to be the
+  // same rule. A debt survives until it is answered, so anything weaker than remembering which
+  // ones we already raised means the identical question blocks turn after turn, and a gate that
+  // nags is a gate the user switches off. Keyed on sender+timestamp rather than on sender, so a
+  // NEW question from someone we have already nudged about still gets its own one nudge.
+  const owed = unansweredFor(msgs, me)
+  const unnudged = owed.filter((o) => !nudged.includes(o.from + '|' + o.at))
+  if (unnudged.length) {
+    const quoted = unnudged.slice(0, 3).map((o) => `  ${o.from}: ${o.text.replace(/\s+/g, ' ').slice(0, 200)}`)
+    return {
+      block: true, seen: nowSeen, taskBlocks,
+      // Recorded BEFORE returning, exactly as the watermark is, so a question cannot block a
+      // second time even if whatever happens next goes wrong. Capped so the state file cannot
+      // grow without bound in a long-lived room.
+      nudged: [...nudged, ...unnudged.map((o) => o.from + '|' + o.at)].slice(-200),
+      reason: `You are in a Hivecode room and ${unnudged.length} participant${unnudged.length > 1 ? 's are' : ' is'} ` +
+        `still waiting on a reply from you:\n\n${quoted.join('\n')}\n\n` +
+        `Answer with hive_say and name them. "Not yet — I am on X, I will come back to you" is a ` +
+        `complete answer; silence is the one thing they cannot act on, and nothing tells them you ` +
+        `stopped. Then call hive_wait.`,
+    }
+  }
+
+  const open = openTasksFor(tasks, me)
+  if (open.length && taskBlocks < MAX_TASK_BLOCKS) {
+    const quoted = open.slice(0, 3).map((t) => `  [${t.id}] from ${t.from}: ${t.text.replace(/\s+/g, ' ').slice(0, 220)}`)
+    return {
+      block: true, seen: nowSeen, taskBlocks: taskBlocks + 1, nudged,
+      reason: `You are in a Hivecode room with ${open.length} accepted task${open.length > 1 ? 's' : ''} ` +
+        `still open:\n\n${quoted.join('\n')}\n\n` +
+        `Finish the work and call hive_complete with the task id, or say why you are blocked with ` +
+        `hive_say (@ the person who assigned it). Then call hive_wait. If you genuinely cannot ` +
+        `proceed, say so in the room first -- do not just stop, nobody would learn that you had.`,
+    }
+  }
+
+  // Standing down on something we have already blocked on MAX_TASK_BLOCKS times is not the same
+  // as it being resolved, so hold the counter rather than resetting it while it is still there.
+  // Debts and tasks share the counter deliberately: they are the same kind of obligation, and
+  // two separate counters would let an agent be pinned for 2x MAX_TASK_BLOCKS turns.
+  return { block: false, seen: nowSeen, taskBlocks: open.length ? taskBlocks : 0, nudged }
+}
+
+/** Walk up from `start` looking for the session file; the hook's cwd is usually but not always
+ *  the folder the MCP server was launched in. */
+function findSession(start) {
+  let dir = path.resolve(start)
+  for (let i = 0; i < 4; i++) {
+    const p = path.join(dir, SESSION_FILE)
+    if (fs.existsSync(p)) return { root: dir, session: readJson(p) }
+    const up = path.dirname(dir)
+    if (up === dir) break
+    dir = up
+  }
+  return null
+}
+
+async function main() {
+  let input = ''
+  for await (const chunk of process.stdin) input += chunk
+  const hook = (() => { try { return JSON.parse(input) } catch { return {} } })()
+
+  // GUARD 1: this stop is already the product of a block. Never stack another on it.
+  if (hook.stop_hook_active) return
+
+  const found = findSession(hook.cwd || process.cwd())
+  if (!found || !found.session || !found.session.dir || !found.session.name) return // not in a room
+
+  const { root, session } = found
+  const dir = path.isAbsolute(session.dir) ? session.dir : path.join(root, session.dir)
+  const read = (f) => { try { return fs.readFileSync(path.join(dir, f), 'utf8') } catch { return '' } }
+
+  const chat = read('HIVE_CHAT.md')
+  if (!chat) return // room folder not mirrored yet; nothing to be sure about, so allow
+
+  const statePath = path.join(root, STATE_FILE)
+  const prev = readJson(statePath) || {}
+  // Keyed by room: a folder rejoined against a different room must not inherit a watermark from
+  // unrelated history -- the same reasoning as the persisted sync ancestor being room-keyed.
+  const key = String(session.room || session.dir)
+  const st = prev[key] || { seen: 0, taskBlocks: 0, nudged: [] }
+
+  const d = decide({
+    chat, tasks: read('HIVE_TASKS.md'), me: session.name,
+    seen: Number(st.seen) || 0, taskBlocks: Number(st.taskBlocks) || 0,
+    nudged: Array.isArray(st.nudged) ? st.nudged : [],
+  })
+
+  // GUARD 2: write the watermark BEFORE returning the block, so this message can never block a
+  // second time even if what happens next goes wrong.
+  try {
+    prev[key] = { seen: d.seen, taskBlocks: d.taskBlocks, nudged: d.nudged || [], at: Date.now() }
+    fs.writeFileSync(statePath, JSON.stringify(prev, null, 2))
+  } catch { /* a watermark we cannot persist is a reason to allow, never to fail */ }
+
+  if (d.block) process.stdout.write(JSON.stringify({ decision: 'block', reason: d.reason }))
+}
+
+// Only run when executed as the hook, so the test can import decide()/parseChat() cleanly.
+if (process.argv[1] && /hive-stop-hook\.js$/.test(process.argv[1])) {
+  main().catch(() => { }).finally(() => process.exit(0))
+}

package/hive-throttle.js

@@ -0,0 +1,118 @@
+// hive-throttle.js — say it again only if they can no longer see it.
+//
+// TWO OPPOSITE WASTES, ONE CAUSE. Hivecode repeats some blocks to an agent that still has them
+// verbatim, and never repeats others to an agent that lost them hours ago. Both are the same
+// missing question: *is this still in their context?*
+//
+//   [GLOBAL PROJECT STATE]   rebuilt and returned on EVERY hive_wait, unchanged, forever.
+//                            An agent waiting in a loop is handed the same JSON hundreds of
+//                            times, and pays for it hundreds of times.
+//
+//   HIVE_RULES.md            6,288 bytes handed over ONCE, in the hive_join tool result. It sits
+//                            in the transcript, so it is exactly what compaction throws away
+//                            first -- and it is the ROOM-specific half of the rules: lanes, gate
+//                            commands, who owns what. Six hours in, it is simply gone.
+//
+// WHAT IS *NOT* IN SCOPE, AND THIS WAS WORTH CHECKING BEFORE WRITING ANYTHING. `INSTRUCTIONS`
+// (2,477 chars) is passed to `new Server(..., { instructions })`, which puts it in the agent's
+// SYSTEM PROMPT. A system prompt is not part of the compactable transcript, so those rules are
+// present on every single turn and re-sending them would be the precise waste this file exists
+// to remove. Half of an earlier draft of this module did exactly that.
+//
+// THE PROXY, AND ITS HONEST LIMIT. There is no way to ask an agent what is still in its context.
+// Agent Relay's broker faces the same wall and answers it with a measurement it *does* have --
+// bytes of PTY output since the last reminder:
+//
+//     "Output volume is the proxy for 'the agent actually worked and may have compacted the
+//      earlier reminder out of its context'. An agent that only sat at the prompt receiving
+//      messages still has the previous reminder verbatim in context, so repeating it only
+//      burns tokens."                     -- crates/broker/src/broker/injection_format.rs
+//
+// There is no PTY here. The equivalent measurement is the one thing this server controls exactly:
+// BYTES IT HAS HANDED THE AGENT since the last send. Every tool result goes out through one
+// `text()`, so the count is precise rather than sampled.
+//
+// This is a proxy and nothing more. It does not detect compaction; it estimates that enough has
+// happened for compaction to be plausible. It will sometimes repeat something still in context,
+// and sometimes stay quiet about something already gone. Both failures are cheap. Pretending the
+// number means more than it does would not be.
+//
+// THREE RULES, IN PRIORITY ORDER, AND THE ORDER IS THE DESIGN:
+//
+//   1. never sent      -> SEND. They have not seen it.
+//   2. content changed -> SEND. Correctness outranks economy: a suppressed state change is a
+//                         wrong answer, while a repeated one is only a cost.
+//   3. otherwise       -> send only if BOTH the cooldown has elapsed AND enough bytes have gone
+//                         out. Either gate alone is wrong. Time alone nags an idle agent that
+//                         still has the text. Bytes alone fires mid-burst on an agent that read
+//                         it ninety seconds ago.
+
+/** Long enough that a burst of work does not trigger a repeat, short enough to catch a stall. */
+export const COOLDOWN_MS = 5 * 60000
+
+/** Agent Relay's number, and a reasonable one: ~16k tokens of traffic since they last saw it. */
+export const OUTPUT_BYTES = 64 * 1024
+
+/** Cheap, order-insensitive change detection. Not a hash -- a hash would be more code for a
+ *  comparison that is already exact on the strings these callers pass. */
+const norm = (c) => (typeof c === 'string' ? c : JSON.stringify(c === undefined ? null : c))
+
+export function makeThrottle({ now = Date.now, cooldownMs = COOLDOWN_MS, bytes = OUTPUT_BYTES } = {}) {
+  // key -> { at, content, bytesSince, sends }
+  const seen = new Map()
+  let noted = 0        // total bytes handed to the agent, for reporting only
+
+  /**
+   * Record output handed to the agent.
+   *
+   * Counting for a key starts only once that key has been sent at least once -- the volume only
+   * means anything relative to "since you last saw this". Agent Relay makes the same choice and
+   * for the same reason; a counter running before the first send would make the first repeat fire
+   * immediately on a busy agent.
+   */
+  function note(n) {
+    const add = Math.max(0, Number(n) || 0)
+    noted += add
+    for (const e of seen.values()) e.bytesSince += add
+  }
+
+  function should(key, content) {
+    const e = seen.get(key)
+    if (!e) return { send: true, why: 'first' }
+    if (norm(content) !== e.content) return { send: true, why: 'changed' }
+    const waited = now() - e.at
+    if (waited < cooldownMs) return { send: false, why: 'recent', waited }
+    if (e.bytesSince < bytes) return { send: false, why: 'quiet', bytesSince: e.bytesSince }
+    return { send: true, why: 'likely-compacted', waited, bytesSince: e.bytesSince }
+  }
+
+  function sent(key, content) {
+    const prev = seen.get(key)
+    seen.set(key, { at: now(), content: norm(content), bytesSince: 0, sends: (prev ? prev.sends : 0) + 1 })
+  }
+
+  /** should() and sent() in one call, for the common site: `if (send(k, c)) include(c)`. */
+  function send(key, content) {
+    const d = should(key, content)
+    if (d.send) sent(key, content)
+    return d.send
+  }
+
+  /** What was actually saved, so the claim is measured rather than asserted. */
+  function stats() {
+    const out = { keys: {}, bytesHandled: noted }
+    for (const [k, e] of seen.entries()) out.keys[k] = { sends: e.sends, bytesSince: e.bytesSince }
+    return out
+  }
+
+  return { note, should, sent, send, stats }
+}
+
+/** Cheap enough to be worth repeating; says nothing an agent's system prompt already carries.
+ *  Deliberately a POINTER, not a copy: the file is on the agent's own disk, and a second
+ *  hand-written summary of it here would be one more description to drift. */
+export const RULES_NUDGE =
+  '[ROOM RULES] You have been working a while — the room rules you were handed when you joined ' +
+  'are probably out of your context by now. They are ROOM-specific (lanes, gate command, who ' +
+  'owns what), so the general rules you still have do not cover them. Re-read HIVE_RULES.md in ' +
+  'your own folder before your next claim.'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hivecode-mcp",
-  "version": "0.11.4",
-  "description": "MCP server that lets any AI coding agent join a Hivecode room \u2014 humans and multiple AI agents edit one live codebase with folder-scoped permissions and approval gates.",
+  "version": "0.11.6",
+  "description": "MCP server that lets any AI coding agent join a Hivecode room — humans and multiple AI agents edit one live codebase with folder-scoped permissions and approval gates.",
   "type": "module",
   "license": "MIT",
   "homepage": "https://github.com/Ganesh-Kute/HiveCode",
@@ -23,11 +23,19 @@
     "yjs"
   ],
   "bin": {
-    "hivecode-mcp": "hive-mcp.js"
+    "hivecode-mcp": "hive-mcp.js",
+    "hivecode-hook": "hive-hook-install.js"
   },
   "files": [
     "hive-mcp.js",
     "hive-mailbox.js",
+    "hive-obligations.js",
+    "hive-receipts.js",
+    "hive-throttle.js",
+    "hive-instructions.js",
+    "hive-busy.js",
+    "hive-stop-hook.js",
+    "hive-hook-install.js",
     "sync.js",
     "core.js",
     "limits.js",
@@ -43,6 +51,7 @@
     "lang-toml.js",
     "icr-merge.js",
     "hive-coord.js",
+    "hive-gate.js",
     "substrate.js",
     "HIVE_RULES.md",
     "docs/MCP.md",
@@ -58,14 +67,20 @@
     "relay": "node server.js",
     "sync:engine": "node sync-engine.mjs",
     "check:engine": "node sync-engine.mjs --check",
-    "pretest": "node scripts/sync-engine.mjs --check && node scripts/check-files.mjs",
+    "pretest": "node scripts/sync-engine.mjs --check && node scripts/check-files.mjs && node scripts/check-deploy.mjs",
     "test": "node tests/test.js",
+    "test:features": "node tests/features-test.mjs",
+    "test:features:shape": "node tests/features-test.mjs --shape",
+    "test:learnings": "node tests/learnings-test.mjs",
+    "test:extension": "node tests/extension-parity-test.mjs",
+    "test:ceiling": "node tests/refused-visible-test.mjs && node tests/ceiling-no-data-loss-test.mjs",
     "test:identity": "node tests/identity-audit-test.mjs",
     "test:billing": "node tests/billing-test.mjs",
     "test:license": "node tests/hive-license-test.js",
     "test:money": "node tests/payment-e2e-test.mjs && node tests/subscribe-test.mjs && node tests/lifecycle-test.mjs && node tests/billing-test.mjs && node tests/hive-license-test.js && node tests/recover-test.mjs",
     "check:web": "tsc --noEmit",
     "build:web": "esbuild web/src/main.ts --bundle --minify --format=iife --target=es2019 --outfile=public/app.js",
+    "build:crdt": "esbuild web/crdt.js --bundle --minify --format=esm --target=es2019 --outfile=public/hive-crdt.js",
     "test:substrate": "node substrate-test.js",
     "test:substrate:live": "node substrate-live-test.js",
     "test:substrate:enforce": "node substrate-enforce-test.js",
@@ -73,9 +88,10 @@
     "test:substrate:all": "node substrate-test.js && node substrate-live-test.js && node substrate-enforce-test.js && node substrate-authority-test.js",
     "test:recover": "node tests/recover-test.mjs",
     "test:mailbox": "node tests/mailbox-test.mjs && node tests/mcp-wait-test.mjs",
+    "test:stophook": "node tests/stop-hook-test.mjs",
     "test:limits": "node tests/limits-test.mjs",
     "test:rejoin": "node tests/rejoin-clobber-test.mjs",
-    "test:prod": "node tests/test.js && node tests/firstrun-test.mjs && node tests/credential-split-test.mjs && node tests/limits-test.mjs && node tests/usage-meter-test.mjs && node tests/rejoin-clobber-test.mjs && node tests/durability-test.mjs && node tests/payment-e2e-test.mjs && node tests/subscribe-test.mjs && node tests/lifecycle-test.mjs && node tests/billing-test.mjs && node tests/hive-license-test.js && node tests/recover-test.mjs && node demo/wrap-test.mjs",
+    "test:prod": "node tests/test.js && node tests/firstrun-test.mjs && node tests/credential-split-test.mjs && node tests/limits-test.mjs && node tests/usage-meter-test.mjs && node tests/rejoin-clobber-test.mjs && node tests/stop-hook-test.mjs && node tests/coordination-test.mjs && node tests/control-panel-test.mjs && node tests/hive-map-test.mjs && node tests/hive-gate-test.mjs && node tests/durability-test.mjs && node tests/payment-e2e-test.mjs && node tests/subscribe-test.mjs && node tests/lifecycle-test.mjs && node tests/billing-test.mjs && node tests/hive-license-test.js && node tests/recover-test.mjs && node demo/wrap-test.mjs",
     "test:meter": "node tests/usage-meter-test.mjs",
     "test:subscribe": "node tests/subscribe-test.mjs",
     "test:cred": "node tests/credential-split-test.mjs",
@@ -89,7 +105,13 @@
     "demo:all": "node demo/record.mjs && node demo/record-panel.mjs",
     "check:files": "node scripts/check-files.mjs",
     "prepublishOnly": "node scripts/check-files.mjs",
-    "demo:cast": "node demo/cast.mjs --dry-run"
+    "demo:cast": "node demo/cast.mjs --dry-run",
+    "check:deploy": "node scripts/check-deploy.mjs",
+    "test:coordination": "node tests/coordination-test.mjs",
+    "test:panel": "node tests/control-panel-test.mjs",
+    "test:map": "node tests/hive-map-test.mjs",
+    "test:gate": "node tests/hive-gate-test.mjs",
+    "bench:ab": "node bench/coordination-ab.mjs"
   },
   "engines": {
     "node": ">=18"
@@ -99,6 +121,7 @@
     "@modelcontextprotocol/sdk": "^1.30.0",
     "acorn": "^8.17.0",
     "ignore": "^7.0.5",
+    "lib0": "^0.2.117",
     "ws": "^8.18.0",
     "y-websocket": "^2.0.4",
     "yjs": "^13.6.18",