hivecode-mcp 0.14.3 → 0.14.5

package/hive-receipts.js

@@ -53,11 +53,18 @@
 // and exactly the shape that already bit this repo once as a duplicated reconcile(): two
 // descriptions of one thing, only one of which is ever checked against reality.
 import { mentionedNames, mentionsAll } from './hive-mailbox.js'
+import { covers, makeFrontier } from './hive-seen.js'
 
 export const READ = 'READ'
 export const UNREAD = 'UNREAD'
 export const UNKNOWN = 'UNKNOWN'
 export const UNREACHABLE = 'UNREACHABLE'
+// HANDED (0.14.4): the recipient's LISTENER took it and woke (or tried to wake) their app, but the
+// agent itself has not read it. Before 0.14.4 the listener published the agent's read cursor, so this
+// was reported as READ -- and an app that was never woken, or crashed first, lost the mail on its next
+// session while the sender was told it had been read (Claude-cloud's attack 6, incident I-1).
+// HANDED is not delivered: a listener holding a message is not an agent knowing it.
+export const HANDED = 'HANDED'
 
 /** Only these count as delivered. Anything else is an absence of evidence, not evidence. */
 export const DELIVERED_STATES = [READ]
@@ -84,6 +91,31 @@ export function publishCursor(cursors, name, at, now = Date.now) {
   return rec
 }
 
+/**
+ * Publish my read and handed FRONTIERS (hive-seen.js) into the room: record version 2.
+ *
+ *   read    advanced only by the agent's own hive_wait / hive_check / hive_read_chat
+ *   handed  advanced by its listener as well; a read is also handed, so read is merged into it
+ *   at      how many leading messages `read` covers without a gap. Kept so a peer on an older build,
+ *           which only knows counts, is never told more than was read. It CAN go down, when a late
+ *           message integrates inside that prefix, and that is the honest answer: no clamp here.
+ *
+ * Both frontiers only move forward (merged with what is already published). Writes nothing when
+ * nothing changed, for the same reason as publishCursor: an identical write wakes every observer.
+ */
+export function publishFrontier(cursors, name, { read = null, handed = null, at = null, handedAt = '' } = {}, now = Date.now) {
+  if (!cursors || !name) return null
+  const prev = cursors.get(String(name))
+  const p = prev && prev.ver >= 2 ? prev : null
+  const r = makeFrontier(p && p.read); if (read) r.merge(read)
+  const h = makeFrontier(p && p.handed); if (handed) h.merge(handed); h.merge(r.toJSON())
+  const nextAt = at == null ? ((prev && Number(prev.at)) || 0) : Math.max(0, Number(at) || 0)
+  const rec = { ver: 2, at: nextAt, read: r.toJSON(), handed: h.toJSON(), handedAt: handed ? String(handedAt || '') : ((p && p.handedAt) || ''), ts: now() }
+  if (p && p.at === rec.at && JSON.stringify(p.read) === JSON.stringify(rec.read) && JSON.stringify(p.handed) === JSON.stringify(rec.handed)) return prev
+  cursors.set(String(name), rec)
+  return rec
+}
+
 /** Case-insensitive, because @Builder and @builder are one agent everywhere else in this system. */
 export function cursorOf(cursors, name) {
   if (!cursors) return null
@@ -117,12 +149,26 @@ export function findIndex(chat, msg) {
  * Absence outranks a stale cursor for the same reason it does in hive-busy.js: it is the more
  * actionable of the two.
  */
-export function stateFor({ cursors, name, index, present = true, connected = true }) {
+/**
+ * With a message's Yjs id and a version-2 record, the answer comes from the frontiers, so a message
+ * that integrated behind a reader's position is UNREAD, never a false READ. Without either, the count
+ * rule below still answers -- for a peer on an older build that only publishes counts.
+ */
+function byFrontier(cur, id, name) {
+  if (!id || !cur || !(cur.ver >= 2) || !cur.read) return null
+  if (covers(cur.read, id)) return { name, state: READ, at: cur.ts, why: `@${name} has read it` }
+  if (covers(cur.handed, id)) return { name, state: HANDED, at: cur.ts, why: `@${name}'s listener took it${cur.handedAt ? ` at ${cur.handedAt}` : ''}, but ${name} has NOT read it yet` }
+  return null
+}
+
+export function stateFor({ cursors, name, index, id = null, present = true, connected = true }) {
   if (!connected) return { name, state: UNREACHABLE, why: 'this client is offline — the message is in your local copy only and has not left this machine' }
   if (!present) return { name, state: UNREACHABLE, why: `@${name} is not in the room, so nobody is going to read it` }
   if (index < 0) return { name, state: UNKNOWN, why: 'that message is not in the room log — it may not have synced' }
   const cur = cursorOf(cursors, name)
   if (!cur) return { name, state: UNKNOWN, why: `@${name} publishes no read position (an older build, a bridge, or a human client) — silence from them means nothing either way` }
+  const f = byFrontier(cur, id, name); if (f) return f
+  if (id && cur.ver >= 2 && cur.read) return { name, state: UNREAD, at: cur.ts, why: `@${name} has NOT been handed this one` }
   // A cursor of N means N messages consumed, i.e. indexes 0..N-1. So the message at `index` has
   // been handed over exactly when the cursor is strictly greater than it.
   if (Number(cur.at) > index) return { name, state: READ, at: cur.ts, why: `@${name} has read it` }
@@ -161,10 +207,15 @@ export function stateFor({ cursors, name, index, present = true, connected = tru
  * design argued in the room over four rounds. Tests are antigravity1's, written before the code
  * existed and verified red first: tests/transcript-receipts-test.mjs.
  */
-export function transcriptStateFor({ cursors, name, index, present = true }) {
+export function transcriptStateFor({ cursors, name, index, id = null, present = true }) {
   if (index < 0) return { name, state: UNKNOWN, why: 'that message is not in the room log — it may not have synced' }
   const cur = cursorOf(cursors, name)
   if (!cur) return { name, state: UNKNOWN, why: `@${name} publishes no read position (an older build, a bridge, or a human client) — silence from them means nothing either way` }
+  const f = byFrontier(cur, id, name); if (f) return f
+  if (id && cur.ver >= 2 && cur.read) {
+    if (!present) return { name, state: UNREACHABLE, at: cur.ts, why: `@${name} is not in the room, and left without reading this message` }
+    return { name, state: UNREAD, at: cur.ts, why: `@${name} has NOT been handed this one` }
+  }
   // A cursor of N means N messages consumed, i.e. indexes 0..N-1. So the message at `index` has
   // been handed over exactly when the cursor is STRICTLY greater than it. A cursor sitting exactly
   // at `index` means NOT read; an off-by-one here is a receipt that lies quietly.
@@ -185,7 +236,7 @@ export const countDelivered = (states) => states.filter((s) => DELIVERED_STATES.
  * `@all` is skipped for the same reason a broadcast creates no reply debt in hive-mailbox.js --
  * one message obliging eight receipts is the storm, not the signal.
  */
-export function receipts({ chat, cursors, me, present = () => true, connected = true, limit = 10 }) {
+export function receipts({ chat, ids = null, cursors, me, present = () => true, connected = true, limit = 10 }) {
   const list = Array.isArray(chat) ? chat : []
   const out = []
   for (let i = list.length - 1; i >= 0 && out.length < limit; i--) {
@@ -197,13 +248,13 @@ export function receipts({ chat, cursors, me, present = () => true, connected =
     out.push({
       at: m.at,
       text: String(m.text || '').slice(0, 120),
-      to: named.map((n) => stateFor({ cursors, name: n, index: i, present: present(n), connected })),
+      to: named.map((n) => stateFor({ cursors, name: n, index: i, id: ids ? ids[i] : null, present: present(n), connected })),
     })
   }
   return out.reverse()
 }
 
-const MARK = { [READ]: '✓', [UNREAD]: '…', [UNKNOWN]: '?', [UNREACHABLE]: '✗' }
+const MARK = { [READ]: '✓', [HANDED]: '↪', [UNREAD]: '…', [UNKNOWN]: '?', [UNREACHABLE]: '✗' }
 
 /** One line per message. The marks make a column a human can scan; the words carry the meaning. */
 export function describe(r) {

package/hive-room-mode.js

@@ -23,6 +23,7 @@ import crypto from 'crypto'
 import { spawnSync } from 'child_process'
 import { parseLink, startSync } from './sync.js'
 import { landAndOpen, testCommandFor } from './hive-land.js'
+import * as SEEN from './hive-seen.js' // what the room held when the issue was posted, by Yjs id (0.14.4)
 
 export const MIN_ROOM_MODE_VERSION = '0.13.0'
 
@@ -709,6 +710,17 @@ export async function postIssue(opts = {}) {
     // 3. Post chat message
     const chatText = formatIssueChat({ issue, waysOfWorking })
     if (hive.say) hive.say(chatText)
+    // Everything this poster held once its own post was in: the watcher counts an agent reply as
+    // "since the issue was posted" when its id is NOT in here, wherever it integrates (0.14.4).
+    const postFrontier = (() => {
+      try {
+        const ch = hive.doc && hive.doc.getArray('chat')
+        if (!SEEN.isYArray(ch)) return null
+        const f = SEEN.makeFrontier()
+        for (const { id } of SEEN.itemsOf(ch)) f.add(id)
+        return f.toJSON()
+      } catch { return null }
+    })()
 
     // 4. Verify delivery via fresh passive peek
     const chatMarker = attempt > 1
@@ -739,6 +751,7 @@ export async function postIssue(opts = {}) {
       verified: true,
       members: members.agents,
       comment,
+      postFrontier,
     }
   } finally {
     if (hive && typeof hive.stop === 'function') {

package/hive-room-watcher.js

@@ -22,6 +22,7 @@
 import fs from 'fs'
 import os from 'os'
 import path from 'path'
+import * as SEEN from './hive-seen.js' // replies since the post, by Yjs id (0.14.4)
 import { startSync, parseLink } from './sync.js'
 import * as ACT from './hive-activity.js'
 import { LABEL, HUMAN_LABEL, PUSHERS } from './hive-github.js'
@@ -193,7 +194,7 @@ export function makeRoomWatcher(o) {
       log(`#${n}: withdrawn`)
       return
     }
-    const peek = await deps.peek({ issueNumber: n, taskId: a.taskId, since: a.postedAt })
+    const peek = await deps.peek({ issueNumber: n, taskId: a.taskId, since: a.postedAt, postFrontier: a.postFrontier || null })
     if (peek && peek.ok && peek.engaged && !a.engagedAt) a.engagedAt = now()
 
     // A LONE AGENT CANNOT GET A SECOND AGENT'S REVIEW. When the work is done and the only thing
@@ -395,7 +396,7 @@ export function makeRoomWatcher(o) {
         return { postFailed: n }
       }
       it.status = 'active'
-      state.active = { n, taskId: p.taskId, postedAt: now(), engagedAt: 0, runs: 0, fallback: null, lastFailedFingerprint: '' }
+      state.active = { n, taskId: p.taskId, postedAt: now(), postFrontier: p.postFrontier || null, engagedAt: 0, runs: 0, fallback: null, lastFailedFingerprint: '' }
       // Commands already on the issue (a "/hivecode stop" from before this run) are history: only
       // what is said from now on stops it.
       try { await commands(n, 0) } catch { /* read again next tick */ }
@@ -583,7 +584,30 @@ export async function runRoomMode({ f, opt, gh, id, info, root, gitDir, label, l
 }
 
 /** A passive look at the room: who can hear, and whether anyone has engaged with this issue. */
-export async function peekRoom({ link, issueNumber, taskId, since = 0, token = '', timeoutMs = 60000 }) {
+/**
+ * Has an agent said something about this issue since the room's post of it?
+ *
+ * BY IDENTITY WHEN WE CAN (0.14.4). "After the post" by POSITION missed an agent reply that was in
+ * flight when the issue was posted: it integrates BEFORE the post and read as "nobody replied". With
+ * the frontier the poster held right after posting (postIssue returns it), a reply counts if its Yjs id
+ * is not in it, wherever it landed. A run posted by an older build has no frontier and keeps the
+ * position rule: lines after the LAST post of this issue (a retry is "Issue #12 (attempt 2): ...").
+ */
+export function agentRepliedSince({ chat, issueNumber, taskId = '', postFrontier = null }) {
+  const ref = new RegExp(`#${Number(issueNumber)}(?!\\d)`)
+  const isAgent = (m) => m && m.kind !== 'human' && !/^GitHub/.test(String(m.by || ''))
+  const replies = (m) => isAgent(m) && (ref.test(String(m.text || '')) || (taskId && String(m.text || '').includes(taskId)))
+  if (postFrontier && typeof postFrontier === 'object' && SEEN.isYArray(chat)) {
+    return SEEN.itemsOf(chat).some(({ id, value }) => !SEEN.covers(postFrontier, id) && replies(value))
+  }
+  const list = SEEN.isYArray(chat) ? chat.toArray() : (Array.isArray(chat) ? chat : [])
+  const posted = new RegExp(`Issue #${Number(issueNumber)}(?: \\(attempt \\d+\\))?:`)
+  let from = -1
+  for (let i = list.length - 1; i >= 0; i--) if (/^GitHub/.test(String(list[i].by || '')) && posted.test(String(list[i].text || ''))) { from = i; break }
+  return from >= 0 && list.slice(from + 1).some(replies)
+}
+
+export async function peekRoom({ link, issueNumber, taskId, since = 0, postFrontier = null, token = '', timeoutMs = 60000 }) {
   const { relay, room } = parseLink(link)
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'hive-room-peek-'))
   const peek = startSync({ relay, room, dir, name: 'GitHub-peek', kind: 'ai', passive: true, syncFiles: false, token, log: () => {} })
@@ -598,15 +622,9 @@ export async function peekRoom({ link, issueNumber, taskId, since = 0, token = '
     const members = peek.members().filter((m) => m && m.name && !/^GitHub/.test(m.name) && m.kind !== 'human' && !m.passive)
     const reachable = members.filter((m) => ACT.describe(activity.get(m.name), { present: true, listener: m.listener, app: m.app, now: Date.now() }).reachable).map((m) => m.name)
     const chat = peek.doc.getArray('chat').toArray()
-    // Chat times are clock strings ("21:04:39") with no date, so "since the issue was posted" is
-    // told by POSITION: lines after the room's own post of this issue.
-    const ref = new RegExp(`#${Number(issueNumber)}(?!\\d)`)
-    const isAgent = (m) => m && m.kind !== 'human' && !/^GitHub/.test(String(m.by || ''))
-    let from = -1
-    // The LAST post of this issue: a retry is posted as "Issue #12 (attempt 2): ...".
-    const posted = new RegExp(`Issue #${Number(issueNumber)}(?: \\(attempt \\d+\\))?:`)
-    for (let i = chat.length - 1; i >= 0; i--) if (/^GitHub/.test(String(chat[i].by || '')) && posted.test(String(chat[i].text || ''))) { from = i; break }
-    const said = from >= 0 && chat.slice(from + 1).some((m) => isAgent(m) && (ref.test(String(m.text || '')) || (taskId && String(m.text || '').includes(taskId))))
+    // Chat times are clock strings ("21:04:39") with no date, so "since the issue was posted" is told
+    // by Yjs identity when the post's frontier is known, else by position (agentRepliedSince).
+    const said = agentRepliedSince({ chat: peek.doc.getArray('chat'), issueNumber, taskId, postFrontier })
     const t = peek.doc.getMap('tasks').get(taskId)
     const claimed = [...peek.doc.getMap('claims').values()].some((c) => c && c.by && Number(c.since || c.at || 0) >= since)
     return {

package/hive-seen.js

@@ -0,0 +1,135 @@
+// hive-seen.js -- which chat messages has this reader seen? Answered by IDENTITY, never by position.
+//
+// THE DEFECT THIS EXISTS FOR (9 Nov 2026, found live in room-6UlP…; reproduced by Opus-Cloud and
+// Claude-cloud on real Yjs at d5b6f56, urgent mail missed in 15 of 40 trials). Every "how far have I
+// read" marker in Hivecode was a COUNT or an ARRAY POSITION: the mailbox behind hive_wait/hive_check
+// and the [!] gate, the room read cursors behind hive_delivered, hive-await's cursor file, the stop
+// hook's watermark, hive-notify, the room watcher, the Slack bridge. But a Y.Array is not append-only.
+// A peer that pushed while its update was still in flight (offline, a stuck long-poll outbox, a crash
+// and rejoin) carries its own clock, and Yjs orders concurrent inserts by (clientID, clock), not by
+// arrival -- so the late message integrates BEHIND messages everyone already read. A position reader
+// never looks there again: it re-delivers a shifted old message and silently drops the new one.
+// antigravity-VM's "@Opus-Cloud … env variables" was stamped 10:22, reached the relay at 11:05 and
+// landed at #818, behind 13 messages the whole room had read. Nobody's reader delivered it.
+//
+// THE IDENTITY. Every element of a Y.Array has a global id {client, clock}: the client that inserted
+// it and that client's clock at the insert. It never changes, wherever the element ends up.
+//
+// "SEEN" IS A FRONTIER: per client, the HIGHEST clock this reader has seen. An id is seen iff
+// frontier[client] >= clock. A late element from a client carries a clock above that client's
+// frontier, so it is unseen wherever Yjs places it. A frontier is exact because one client's inserts
+// into one array integrate in clock order: Yjs never surfaces clock k+1 of a client before clock k.
+//
+// NOT A STATE VECTOR. Yjs's own state vector (Y.encodeStateVector) stores the NEXT clock it expects,
+// highest + 1. This stores the highest SEEN. Building one from the other is off by one and drops
+// exactly one message per client, silently -- so nothing here reads or writes a Yjs state vector, and
+// tests/mail-identity-test.mjs pins the difference. (Claude-cloud's review, attack 2.)
+//
+// PRUNED. Every MCP restart is a new Y.Doc clientID, so a long-lived room accumulates writers. A
+// frontier is pruned to clients that still have an undeleted element in the array. That only ever
+// costs a re-read, never a skip: a later element from a pruned client is unseen and is delivered.
+//
+// THE ONE INTERNAL. `itemsOf` walks the array's item list (`yarr._start`, `item.right`) because Yjs
+// has no public API that pairs a value with its id. yjs is pinned in package.json, and the test
+// asserts `itemsOf(a)` yields exactly `a.toArray()` in order, so a yjs change that breaks the walk
+// fails CI instead of silently mis-reading mail.
+
+/** Is this a Y.Array (or anything with Yjs item structure), as opposed to a plain JS array? */
+export function isYArray(x) {
+  return !!x && !Array.isArray(x) && typeof x.toArray === 'function' && '_start' in x
+}
+
+/**
+ * The array's elements in order, each with its Yjs id: [{ id: { client, clock }, value }].
+ * Deleted elements are skipped, as toArray() skips them. Element k of an item carries clock + k.
+ */
+export function itemsOf(yarr) {
+  const out = []
+  if (!isYArray(yarr)) return out
+  for (let it = yarr._start; it; it = it.right) {
+    if (it.deleted || !it.countable) continue
+    const vals = it.content.getContent()
+    for (let k = 0; k < vals.length; k++) out.push({ id: { client: it.id.client, clock: it.id.clock + k }, value: vals[k] })
+  }
+  return out
+}
+
+/** The clients that still have an undeleted element in the array. */
+export function liveClients(yarr) {
+  const s = new Set()
+  for (const { id } of itemsOf(yarr)) s.add(id.client)
+  return s
+}
+
+/** id as a short string, "client:clock" -- what HIVE_CHAT.md carries for readers without Yjs. */
+export const idKey = (id) => `${id.client}:${id.clock}`
+export function parseIdKey(s) {
+  const m = /^(\d+):(\d+)$/.exec(String(s || '').trim())
+  return m ? { client: Number(m[1]), clock: Number(m[2]) } : null
+}
+
+/** Does a serialized frontier ({ "client": clock }) cover this id? Absent or malformed covers nothing. */
+export function covers(json, id) {
+  if (!json || typeof json !== 'object' || !id) return false
+  const v = json[String(id.client)]
+  return Number.isFinite(Number(v)) && Number(v) >= id.clock
+}
+
+/**
+ * A mutable frontier. `version` counts real advances, so a publisher can tell "nothing new" from
+ * "something new" without comparing two objects.
+ */
+export function makeFrontier(json = null) {
+  const m = new Map()
+  let version = 0
+  const add = (id) => {
+    if (!id || !Number.isFinite(id.clock)) return false
+    const cur = m.has(id.client) ? m.get(id.client) : -1
+    if (id.clock <= cur) return false
+    m.set(id.client, id.clock); version++
+    return true
+  }
+  const merge = (other) => {
+    if (!other || typeof other !== 'object') return false
+    let changed = false
+    for (const [c, v] of Object.entries(other)) {
+      const client = Number(c), clock = Number(v)
+      if (Number.isFinite(client) && Number.isFinite(clock) && add({ client, clock })) changed = true
+    }
+    return changed
+  }
+  if (json) merge(json)
+  return {
+    has: (id) => !!id && m.has(id.client) && m.get(id.client) >= id.clock,
+    add,
+    merge,
+    get version() { return version },
+    get size() { return m.size },
+    /** Serialize. With `prune` (a Y.Array), keep only clients that still have an element in it. */
+    toJSON({ prune = null } = {}) {
+      const keep = prune ? liveClients(prune) : null
+      const o = {}
+      for (const [c, v] of m) if (!keep || keep.has(c)) o[String(c)] = v
+      return o
+    },
+  }
+}
+
+/** The frontier that covers the array's first n elements -- the one-time migration from a count. */
+export function frontierOfPrefix(yarr, n) {
+  const f = makeFrontier()
+  const items = itemsOf(yarr)
+  for (let i = 0; i < Math.min(Math.max(0, Number(n) || 0), items.length); i++) f.add(items[i].id)
+  return f
+}
+
+/**
+ * How many leading elements a frontier covers without a gap. Published beside the frontier as `at`,
+ * so a peer on an older build -- which only knows counts -- is never told more than was really read.
+ * It can go DOWN when a late element integrates inside the prefix, and that is the honest answer.
+ */
+export function coveredPrefix(yarr, json) {
+  let n = 0
+  for (const { id } of itemsOf(yarr)) { if (!covers(json, id)) break; n++ }
+  return n
+}

package/hive-slack.js

@@ -31,6 +31,7 @@ import path from 'path'
 import WebSocket from 'ws'
 import { startSync, parseLink } from './sync.js'
 import { scrub } from './hive-webhook.js'
+import * as SEEN from './hive-seen.js' // what was already forwarded, by Yjs id (0.14.4)
 import { realpathSync as __hiveRealpath } from 'fs'
 import { resolve as __hiveResolve } from 'path'
 import { fileURLToPath as __hiveFileURLToPath } from 'url'
@@ -38,6 +39,25 @@ import { fileURLToPath as __hiveFileURLToPath } from 'url'
 const DEFAULT_API = 'https://slack.com/api'
 const ROOM_THREAD_KEY = '__room__'
 const CURSOR_KEY = '__cursor__'
+
+/**
+ * The room->Slack observer: hands `onChat` every chat message not yet forwarded, by Yjs id, wherever it
+ * integrated (0.14.4; see runBridge for why not by count). `forwarded` is a Y.Map of frontiers keyed by
+ * channel, `at` the old count cursor (used to seed a frontier once, when none was saved), `threads` the
+ * map that keeps that count for older bridges. Returns the function to pass to chat.observe.
+ */
+export function makeChatForwarder({ chat, forwarded, key, at, threads, onChat }) {
+  const saved = forwarded.get(key)
+  const fwd = saved && typeof saved === 'object' ? SEEN.makeFrontier(saved) : SEEN.frontierOfPrefix(chat, at)
+  return () => {
+    const fresh = []
+    for (const { id, value } of SEEN.itemsOf(chat)) { if (fwd.has(id)) continue; fwd.add(id); fresh.push(value) }
+    if (!fresh.length) return
+    onChat(fresh)
+    try { forwarded.set(key, fwd.toJSON({ prune: chat })) } catch { }
+    try { const n = SEEN.coveredPrefix(chat, fwd.toJSON()); if (n > (Number(threads.get(CURSOR_KEY)) || 0)) threads.set(CURSOR_KEY, n) } catch { }
+  }
+}
 const MAX_SEEN_EVENTS = 500
 
 export const USAGE = `usage:
@@ -2396,8 +2416,13 @@ export async function main(argv = process.argv.slice(2), { log = console.log, lo
   }
   const chat = hive.doc.getArray('chat')
   const savedCursor = Number(bridge.threads.get(CURSOR_KEY)) || 0
-  let at = savedCursor > 0 && savedCursor <= chat.length ? savedCursor : chat.length
-  chat.observe(() => { const all = chat.toArray(); bridge.onChat(all.slice(at), at); at = all.length })
+  const at = savedCursor > 0 && savedCursor <= chat.length ? savedCursor : chat.length
+  // FORWARDED BY IDENTITY, NOT BY COUNT (0.14.4). `all.slice(at)` never looked behind `at`, so a message
+  // a peer pushed while its update was in flight -- which integrates BEHIND what was already counted --
+  // was never sent to Slack (hive-seen.js has the incident). What was forwarded is now a frontier of
+  // Yjs ids, kept in its own room map: the thread map's other keys are Slack thread ids, and an older
+  // bridge would try to poll any new key there as a thread. The count stays beside it, for those.
+  chat.observe(makeChatForwarder({ chat, forwarded: hive.doc.getMap('slack_forwarded'), key: String(CHANNEL), at, threads: bridge.threads, onChat: bridge.onChat }))
   await bridge.watchRoom()
   log(`READY: [hive-slack] @${pre.botUser} bridging ${room} -> #${pre.channelName} (${CHANNEL}) — resume: ${allowParsed.ids.length ? allowParsed.ids.join(', ') : 'off'}`)
   return 0

package/hive-stop-hook.js

@@ -55,6 +55,7 @@
  */
 import fs from 'fs'
 import path from 'path'
+import crypto from 'crypto'
 import { mentionsName, unansweredFor } from './hive-mailbox.js'
 import { isArmed, listenCommand, listenHow, listenOrder } from './hive-listen.js'
 import { readAgents, agentForHook } from './hive-session.js'
@@ -128,32 +129,46 @@ export function decide(o) {
   return { ...d, block: true, reason: d.block ? `${d.reason}\n\n${listenLine}` : listenLine, listenBlocks: listenBlocks + 1 }
 }
 
-function obligations({ chat, tasks, me, seen, taskBlocks, nudged = [] }) {
+// WHICH MENTIONS WERE ALREADY BLOCKED ON, BY IDENTITY, NOT BY LINE (0.14.4). The watermark was a line
+// count, `seen`: everything after line N was new. But the room's chat is a Y.Array, and a message a
+// peer pushed while its update was in flight integrates at its ORIGINAL position, behind lines already
+// counted -- so a late mention was rendered mid-file and this hook never blocked on it (hive-seen.js
+// has the incident). This file has no Yjs, so a mention is identified by what HIVE_CHAT.md carries:
+// author, time and text. The only messages that can share that are exact duplicates -- the same author
+// saying the same words in the same second -- and blocking once for both is the right answer anyway.
+const fingerprint = (m) => crypto.createHash('sha1').update(`${m.by}\u0000${m.at}\u0000${m.text}`).digest('hex').slice(0, 16)
+
+function obligations({ chat, tasks, me, seen, handled = null, 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) =>
+  const isMail = (m) =>
     m.kind !== 'system' &&
     String(m.by).toLowerCase() !== String(me).toLowerCase() &&  // never block on our own post
-    mentionsName(m.text, me))
+    mentionsName(m.text, me)
+  // `handled` (0.14.4): the fingerprints of every mention already blocked on. A state written by an
+  // older build has only the count; it is migrated once, as the prefix it described. A count past the
+  // end means a different (rebuilt or switched) room: start over rather than block on its history.
+  let done
+  if (Array.isArray(handled)) done = new Set(handled)
+  else done = new Set(msgs.slice(0, seen > nowSeen ? 0 : seen).filter(isMail).map(fingerprint))
+  const mail = msgs.filter((m) => isMail(m) && !done.has(fingerprint(m)))
+  // After this decision every mention in the file is handled: blocked on now, or before. Kept to what
+  // the file holds, so it is bounded by the room's history and a rebuilt room sheds the old ones.
+  const nextHandled = [...new Set(msgs.filter(isMail).map(fingerprint))]
 
   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,
+      block: true, seen: nowSeen, handled: nextHandled, 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.`,
+        `it), then stay reachable the way this client does it (your listener, or hive_wait): a ` +
+        `participant who stops hearing still looks present, and nobody in the room finds out.`,
     }
   }
 
@@ -172,7 +187,7 @@ function obligations({ chat, tasks, me, seen, taskBlocks, nudged = [] }) {
   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,
+      block: true, seen: nowSeen, handled: nextHandled, 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.
@@ -181,7 +196,7 @@ function obligations({ chat, tasks, me, seen, taskBlocks, nudged = [] }) {
         `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.`,
+        `stopped. Then stay reachable (your listener, or hive_wait).`,
     }
   }
 
@@ -189,11 +204,11 @@ function obligations({ chat, tasks, me, seen, taskBlocks, nudged = [] }) {
   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,
+      block: true, seen: nowSeen, handled: nextHandled, 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 ` +
+        `hive_say (@ the person who assigned it). Then stay reachable. If you genuinely cannot ` +
         `proceed, say so in the room first -- do not just stop, nobody would learn that you had.`,
     }
   }
@@ -202,7 +217,7 @@ function obligations({ chat, tasks, me, seen, taskBlocks, nudged = [] }) {
   // 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 }
+  return { block: false, seen: nowSeen, handled: nextHandled, taskBlocks: open.length ? taskBlocks : 0, nudged }
 }
 
 /** Walk up from `start` looking for the session file; the hook's cwd is usually but not always
@@ -266,7 +281,7 @@ async function main() {
 
     const d = decide({
       chat, tasks: read('HIVE_TASKS.md'), me: session.name,
-      seen: Number(st.seen) || 0, taskBlocks: Number(st.taskBlocks) || 0,
+      seen: Number(st.seen) || 0, handled: Array.isArray(st.handled) ? st.handled : null, taskBlocks: Number(st.taskBlocks) || 0,
       nudged: Array.isArray(st.nudged) ? st.nudged : [],
       listening, listenLine, listenBlocks: Number(st.listenBlocks) || 0,
     })
@@ -274,7 +289,7 @@ async function main() {
     // 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 || [], listenBlocks: d.listenBlocks, at: Date.now() }
+      prev[key] = { seen: d.seen, handled: d.handled, taskBlocks: d.taskBlocks, nudged: d.nudged || [], listenBlocks: d.listenBlocks, 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 */ }
 

package/hive-transport.js

@@ -24,7 +24,8 @@
 // set when node started, so the WebSocket died with ENOTFOUND, the long-poll probe died the same
 // way, and hive_join said "the relay refused the connection" about a relay it never reached. Now:
 //   - proxyFor(url) picks the proxy: HIVE_PROXY (a URL, or off), else HTTPS_PROXY for wss:/https:
-//     and HTTP_PROXY for ws:/http:. NO_PROXY is honoured; loopback never goes through a proxy.
+//     and HTTP_PROXY for ws:/http:. NO_PROXY is honoured; loopback never goes through a proxy,
+//     including where node's env-proxy mode would send it there (directFetch).
 //   - Both pipes ride an HTTP CONNECT tunnel through it: the WebSocket (an agent for `ws`) and the
 //     long-poll requests (fetchFor). Through a tunnel to a wss:// relay the proxy sees only
 //     "CONNECT host:443"; the path and query -- where the room token rides -- stay inside TLS.
@@ -184,13 +185,46 @@ function tunnelAgent(proxy, secure, kind = 'fetch') {
 
 /** A fetch-shaped call carried over the tunnel agent: just what offersPoll and PollSocket use. */
 function proxyFetch(proxy, url, init = {}) {
+  return agentFetch(url, init, (secure) => tunnelAgent(proxy, secure))
+}
+
+// DIRECT MEANS DIRECT, EVEN WHERE NODE APPLIES THE ENV PROXY ITSELF. With env-proxy mode on
+// (NODE_USE_ENV_PROXY=1 or --use-env-proxy, what Antigravity's VMs run), the built-in fetch AND http's
+// global agent send every request through http(s)_proxy unless node's own NO_PROXY exempts it. So a
+// call proxyFor() had decided was direct -- loopback, a NO_PROXY match, HIVE_PROXY=off -- went to the
+// proxy anyway: a self-hosted relay on localhost was "unreachable" for an invite revoke or the /health
+// probe while its WebSockets worked (antigravity-VM, 9 Nov 2026; tests/loopback-direct-fetch-test.mjs).
+// Measured on node 22.23 and 24.22: an agent of our own is never proxied. Used only in env-proxy mode,
+// so everywhere else a direct call is still the built-in fetch, exactly as before.
+// Node fixes the mode ONCE, AT STARTUP: clearing NODE_USE_ENV_PROXY later does not turn it off (a
+// first version read it per call, and proxy-fetch-test, which clears it mid-run, still went to the
+// proxy). So the mode is read when this module loads -- the nearest point to node's own decision --
+// and a per-call env can only add it, never take it away.
+const envProxyIn = (env) => {
+  if (/^(1|true|yes|on)$/i.test(String((env && env.NODE_USE_ENV_PROXY) || '').trim())) return true
+  return /(^|\s)--use-env-proxy(\s|=|$)/.test(String((env && env.NODE_OPTIONS) || ''))
+}
+const ENV_PROXY_AT_START = envProxyIn(process.env) || process.execArgv.includes('--use-env-proxy')
+const envProxyMode = (env = process.env) => ENV_PROXY_AT_START || envProxyIn(env)
+const directAgents = new Map()
+function directAgent(secure) {
+  let a = directAgents.get(secure)
+  if (!a) { a = new (secure ? https.Agent : http.Agent)({ keepAlive: true, maxFreeSockets: 4 }); directAgents.set(secure, a) }
+  return a
+}
+function directFetch(url, init = {}) {
+  return agentFetch(url, init, directAgent)
+}
+
+/** The request behind proxyFetch and directFetch: `agentFor(secure)` picks the agent that carries it. */
+function agentFetch(url, init, agentFor) {
   return new Promise((resolve, reject) => {
     const u = new URL(url)
     const secure = u.protocol === 'https:'
     const body = init.body == null ? null : Buffer.from(init.body)
     const headers = { ...(init.headers || {}) }
     if (body) headers['content-length'] = String(body.length)
-    const req = (secure ? https : http).request(u, { method: init.method || 'GET', headers, agent: tunnelAgent(proxy, secure) }, (res) => {
+    const req = (secure ? https : http).request(u, { method: init.method || 'GET', headers, agent: agentFor(secure) }, (res) => {
       const chunks = []
       res.on('data', (c) => chunks.push(c))
       res.on('error', reject)
@@ -218,10 +252,11 @@ function proxyFetch(proxy, url, init = {}) {
   })
 }
 
-/** The fetch to reach `url` with: through the proxy tunnel when one applies, else the built-in one. */
+/** The fetch to reach `url` with: through the proxy tunnel when one applies, else direct (see directFetch). */
 export function fetchFor(url, env = process.env) {
   const p = proxyFor(url, env)
-  return p ? (u, init) => proxyFetch(p, u, init) : globalThis.fetch
+  if (p) return (u, init) => proxyFetch(p, u, init)
+  return envProxyMode(env) ? directFetch : globalThis.fetch
 }
 
 /**

package/icr-merge.js

@@ -36,7 +36,8 @@ function describeConflicts(conflicts) {
 // fixed-point, verified by icr-converge-test.js), so its 'auto' result is used as the
 // merged bytes for supported files; merge3 covers conflicts, fallbacks, and other languages.
 export function icrMerge3(base, mine, theirs, relPath) {
-  const lm = merge3(base, mine, theirs)
+  // The sync merge: edits on adjacent lines that each replace lines one for one go side by side (#17).
+  const lm = merge3(base, mine, theirs, { sideBySide: true })
   if (!supports(relPath)) return lm
 
   let r
@@ -44,6 +45,12 @@ export function icrMerge3(base, mine, theirs, relPath) {
   catch { return lm } // ICR must never break a sync
 
   if (r.status === 'auto') {
+    // THE LINE MERGE KEEPS THE AUTHORS' LAYOUT (#19). A one-line top-level statement is a unit keyed by
+    // its own text, so the structural merge sees an edit as a delete plus an insert and can leave the
+    // deleted line's blank lines behind. When the line merge is clean and the two differ only in blank
+    // lines, the line merge is exactly both sides' edits: take it.
+    const blankless = (t) => t.split('\n').filter((l) => l.trim() !== '').join('\n')
+    if (!lm.conflict && r.text !== lm.text && blankless(r.text) === blankless(lm.text)) return lm
     const renamed = r.renames && r.renames.length
     return {
       text: r.text, conflict: false, icr: renamed ? 'rename' : 'structural',