hivecode-mcp 0.11.2 → 0.11.4

package/hive-coord.js

@@ -31,8 +31,19 @@
 
 export function makeCoordinator(shared, self, opts = {}) {
   const ttl = opts.ttl != null ? opts.ttl : 5000
+  // A holder may RENEW its own claim, because a long edit should not lose the file mid-write.
+  // But renewal cannot be unbounded, or the lease stops being a lease. MEASURED on a 12-agent
+  // run: one agent re-claimed site/pricing.md eight times and legal/terms.md seven times and
+  // released twice, and since `claim` reset `at` on every call the 60s TTL never once elapsed.
+  // Six other agents sensed a live owner for the whole run; sixteen messages asked it to let go.
+  // `since` records the FIRST acquisition and survives renewal, so what caps a claim is total
+  // hold time rather than time since the holder last touched it.
+  const maxHold = opts.maxHold != null ? opts.maxHold : ttl * 3
   const now = opts.now || (() => Date.now())
-  const expired = (c) => !c || (now() - c.at) >= c.ttl
+  const held = (c) => now() - (c.since != null ? c.since : c.at) // total, across renewals
+  const cap = (c) => (c.maxHold != null ? c.maxHold : maxHold)
+  const overheld = (c) => !!c && held(c) >= cap(c)
+  const expired = (c) => !c || (now() - c.at) >= c.ttl || overheld(c)
 
   // SENSE: the live, non-expired claim on a region (or null if open).
   const sense = (region) => { const c = shared.get(region); return expired(c) ? null : c }
@@ -40,7 +51,16 @@ export function makeCoordinator(shared, self, opts = {}) {
   // Is this region open to ME? (free, expired, or already mine)
   const free = (region) => { const c = shared.get(region); return expired(c) || c.by === self }
 
-  const claim = (region, intent) => { shared.set(region, { by: self, intent, at: now(), ttl }) }
+  // A renewal keeps the original `since`; a fresh acquisition starts a new one. Claims written
+  // before `since` existed fall back to `at`, so an older room stays readable.
+  const claim = (region, intent) => {
+    const prev = shared.get(region)
+    const renewing = !!prev && prev.by === self && !expired(prev)
+    shared.set(region, {
+      by: self, intent, at: now(), ttl, maxHold,
+      since: renewing ? (prev.since != null ? prev.since : prev.at) : now(),
+    })
+  }
   const release = (region) => { const c = shared.get(region); if (c && c.by === self) shared.delete(region) }
 
   // ACQUIRE one region: sense → claim → verify. Returns true iff I now hold it.
@@ -49,6 +69,13 @@ export function makeCoordinator(shared, self, opts = {}) {
   const acquire = (region, intent) => {
     const c = shared.get(region)
     if (c && !expired(c) && c.by !== self) return false // sensed an owner → defer
+    // Once total hold is exhausted the region is open to everyone — INCLUDING the outgoing
+    // holder, which could then win the re-claim race indefinitely and starve the waiters that
+    // maxHold exists to admit. So the overrunning holder stands down for a full maxHold, which
+    // is a window every waiter is guaranteed to poll inside. A single-ttl cooldown was tried
+    // first and is NOT enough: the holder just waits it out and opens a fresh `since`.
+    // The bar lapses on its own, so a file nobody else wants returns to its owner.
+    if (c && c.by === self && overheld(c) && held(c) < 2 * cap(c)) return false
     claim(region, intent)
     const after = shared.get(region)
     return !(after && after.by !== self) // verify: did my claim survive?

package/hive-mailbox.js

@@ -141,3 +141,33 @@ export function formatMessage(m) {
   const times = m.repeated > 1 ? `  (×${m.repeated})` : ''
   return `${m.at || ''} ${m.by}(${m.kind || 'ai'}): ${m.text}${times}`
 }
+
+/**
+ * AMBIENT DIGEST -- what to do with room chatter nobody addressed to you.
+ *
+ * Un-addressed messages were handed to every agent in full, on every wake. In a room of N
+ * agents that means each one pays for the other N-1's conversation every single turn: O(N^2)
+ * context, so TOKEN COST -- not the relay -- becomes the real ceiling on room size. Measured:
+ * the relay holds 8 clients per room, converging in 1.0s on 45 MB. What actually stops a big
+ * room is this block of text.
+ *
+ * The COUNT stays exact and the newest messages still arrive in full. Only the older bodies
+ * are withheld, and the agent is told the number and how to read them, so nothing is hidden --
+ * it just stops being paid for unasked. An agent that wants the whole log calls hive_read_chat.
+ *
+ * Returns '' when there is nothing, so a caller can drop it with a falsy check.
+ */
+export function ambientDigest(messages, { keep = 4 } = {}) {
+  const list = Array.isArray(messages) ? messages : []
+  if (!list.length) return ''
+  const shown = keep > 0 ? list.slice(-keep) : []
+  const hidden = list.length - shown.length
+  const head = 'room activity (' + list.length +
+    (hidden ? ', newest ' + shown.length + ' shown' : '') + '):'
+  const tail = hidden
+    ? '\n... ' + hidden + ' earlier message(s) withheld to keep your context small'
+      + ' -- hive_read_chat for the full log'
+    : ''
+  if (!shown.length) return head + tail
+  return head + '\n' + shown.map(formatMessage).join('\n') + tail
+}

package/hive-mcp.js

@@ -34,7 +34,7 @@ import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprot
 if (!process.env.HIVE_PROVENANCE) process.env.HIVE_PROVENANCE = 'on'
 if (!process.env.HIVE_FORK_GATE) process.env.HIVE_FORK_GATE = 'on'
 import { startSync, parseLink } from './sync.js'
-import { createMailbox, formatMessage, mentionsName, priorityOf } from './hive-mailbox.js'
+import { createMailbox, formatMessage, mentionsName, mentionedNames, priorityOf, ambientDigest } from './hive-mailbox.js'
 
 const DEFAULT_RELAY = process.env.HIVE_RELAY || 'wss://livecode-xoss.onrender.com'
 let session = null // { hive, room, relay, dir, name, mailbox }
@@ -457,7 +457,18 @@ async function dispatch(req) {
         // a human reading the log, not just to the recipient's tool output.
         const body = args.urgent && !/^\s*\[!\]/.test(raw) ? `[!] ${raw}` : raw
         requireSession().hive.say(body)
-        return text(`sent: ${body}`)
+        // ADDRESSING IS THE PROTOCOL, and a rule an agent merely read is a rule it forgets once
+        // its context fills. So the tool itself answers back: a message that named nobody is
+        // reported as landing in everyone's ambient digest, where it is meant to be skipped.
+        // Immediate, per-call feedback, at the moment the mistake is made.
+        const named = mentionedNames(body)
+        if (!named.length) {
+          return text(`sent: ${body}\n\nNOBODY WAS ADDRESSED. This went to every agent's "room ` +
+            `activity", where they are told to skip it — so assume no one acts on it. Name the ` +
+            `agents you actually need with @Name (hive_members lists who is here). Use an ` +
+            `unaddressed message only for a genuine announcement to the whole room.`)
+        }
+        return text(`sent to ${named.map((n) => '@' + n).join(', ')}: ${body}`)
       }
       case 'hive_read_chat': {
         const me = requireSession().name
@@ -515,7 +526,8 @@ async function dispatch(req) {
           parts.push(got.mentions.map(formatMessage).join('\n'))
         }
         const ambient = got.messages.filter((m) => !mentionsName(m.text, s.name))
-        if (ambient.length) parts.push(`room activity (${ambient.length}):\n` + ambient.map(formatMessage).join('\n'))
+        const dig = ambientDigest(ambient)
+        if (dig) parts.push(dig)
         if (tasks.length) parts.push(`approved work queued for you:\n${tasks.map(fmtTask).join('\n')}`)
         return text(parts.join('\n\n'))
       }
@@ -552,10 +564,10 @@ async function dispatch(req) {
         const mentionBlock = (r) => (r.mentions && r.mentions.length)
           ? `${r.priority === 'stop' ? '🛑 STOP — handle this BEFORE anything else' : '📣 ADDRESSED TO YOU'}:\n${r.mentions.map(formatMessage).join('\n')}`
           : ''
-        const ambientBlock = (r) => {
-          const rest = (r.messages || []).filter((m) => !mentionsName(m.text, me))
-          return rest.length ? `room activity:\n${rest.map(formatMessage).join('\n')}` : ''
-        }
+        // Both delivery paths go through the SAME digest. They used to format ambient traffic
+        // separately, which is how two copies of a rule drift apart -- the exact hazard that
+        // already bit the duplicated reconcile() and the two HIVE_RULES copies.
+        const ambientBlock = (r) => ambientDigest((r.messages || []).filter((m) => !mentionsName(m.text, me)))
 
         if (r && r.paused) {
           const parts = [mentionBlock(r), ambientBlock(r)].filter(Boolean)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hivecode-mcp",
-  "version": "0.11.2",
+  "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.",
   "type": "module",
   "license": "MIT",
@@ -88,7 +88,8 @@
     "demo:panel": "node demo/record-panel.mjs",
     "demo:all": "node demo/record.mjs && node demo/record-panel.mjs",
     "check:files": "node scripts/check-files.mjs",
-    "prepublishOnly": "node scripts/check-files.mjs"
+    "prepublishOnly": "node scripts/check-files.mjs",
+    "demo:cast": "node demo/cast.mjs --dry-run"
   },
   "engines": {
     "node": ">=18"