hivecode-mcp 0.14.2 → 0.14.4

package/hive-mux.js

@@ -36,11 +36,13 @@ class FileProvider extends ObservableV2 {
   }
   get synced() { return !!(this._impl && this._impl.synced) }
   get wsconnected() { return !!(this._impl && this._impl.wsconnected) }
+  /** Bytes handed to this file's socket that the relay has not accepted yet (0.14.3 P0-1). */
+  get bufferedAmount() { return (this._impl && this._impl.bufferedAmount) || 0 }
   get transport() { return this._impl ? this._impl.transport : 'pending' }
   _bindLegacy(relay, wsOpts) {
     const p = new WebsocketProvider(relay, this.docName, this.doc, wsOpts)
     for (const ev of ['sync', 'status', 'connection-error', 'connection-close']) p.on(ev, (...args) => this.emit(ev, args))
-    this._impl = { transport: 'socket', get synced() { return p.synced }, get wsconnected() { return p.wsconnected }, destroy: () => p.destroy() }
+    this._impl = { transport: 'socket', get synced() { return p.synced }, get wsconnected() { return p.wsconnected }, get bufferedAmount() { return (p.ws && p.ws.bufferedAmount) || 0 }, destroy: () => p.destroy() }
   }
   destroy() {
     if (this.destroyed) return
@@ -73,6 +75,7 @@ class Channel {
     doc.on('update', this._onUpdate)
   }
   get wsconnected() { return this.opened && this.mux.connected }
+  get bufferedAmount() { return (this.mux.ws && this.mux.ws.bufferedAmount) || 0 }
   sendOpen() {
     if (this.destroyed || !this.mux.connected) return
     clearTimeout(this.retryTimer); this.retryTimer = null

package/hive-notify.js

@@ -27,6 +27,7 @@ import crypto from 'crypto'
 import { startSync, parseLink } from './sync.js'
 import { makeNotifier, scrub } from './hive-webhook.js'
 import { relayFetch } from './hive-transport.js'
+import * as SEEN from './hive-seen.js' // what was already looked at, by Yjs id (0.14.4)
 
 const oneLine = (s, n = 200) => { const t = String(s || '').replace(/\s+/g, ' ').trim(); return t.length > n ? `${t.slice(0, n - 1)}…` : t }
 const esc = (s) => String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
@@ -99,7 +100,14 @@ export function makeWatch({ hive, forNames, title, send, now = () => Date.now(),
   const owners = hive.doc.getMap('owners')
   const chat = hive.doc.getArray('chat')
   const sent = loadSent(stateFile)
-  let seenChat = chat.length // what was said before this started is not news
+  // SEEN BY IDENTITY, NOT BY COUNT (0.14.4). A count missed a late message: one a peer pushed while
+  // its update was in flight integrates BEHIND what was already counted, and `slice(seenChat)` never
+  // looked there, so a mention of someone away was never notified (hive-seen.js has the incident).
+  // A plain array (a test double) is append-only, so the count stays exact for it.
+  const ych = SEEN.isYArray(chat)
+  const seen = ych ? SEEN.makeFrontier() : null
+  if (ych) for (const { id } of SEEN.itemsOf(chat)) seen.add(id) // what was said before this started is not news
+  let seenChat = chat.length
   const buffer = []
   let lastFlush = 0
   let lostSince = 0
@@ -142,13 +150,21 @@ export function makeWatch({ hive, forNames, title, send, now = () => Date.now(),
     }
 
     // MESSAGES NAMING THEM, from agents, while they are away: batched.
-    const all = chat.toArray()
-    if (all.length < seenChat) seenChat = 0 // the relay restarted and the room's history went with it
-    for (const m of all.slice(seenChat)) {
+    let fresh
+    if (ych) {
+      // A rebuilt room needs no special case: its messages carry ids this frontier has never seen.
+      fresh = []
+      for (const { id, value } of SEEN.itemsOf(chat)) { if (seen.has(id)) continue; seen.add(id); fresh.push(value) }
+    } else {
+      const all = chat.toArray()
+      if (all.length < seenChat) seenChat = 0 // the relay restarted and the room's history went with it
+      fresh = all.slice(seenChat)
+      seenChat = all.length
+    }
+    for (const m of fresh) {
       if (!m || m.kind !== 'ai') continue
       for (const p of people) if (addresses(m.text, p) && !here(p)) { buffer.push({ by: m.by, to: p, text: m.text }); break }
     }
-    seenChat = all.length
     if (buffer.length && t - lastFlush >= every * 60000) {
       const shown = buffer.slice()
       const to = [...new Set(shown.map((b) => b.to))].join(', ')

package/hive-pr.js

@@ -36,7 +36,7 @@ import path from 'path'
 import { spawnSync } from 'child_process'
 import { fileURLToPath } from 'url'
 import { startSync, parseLink } from './sync.js'
-import { accountFor, verdict, explain, DIVERGED, sameText } from './hive-pr-staleness.js'
+import { accountFor, verdict, explain, DIVERGED, DESCENDS, UNPROVEN, sameText } from './hive-pr-staleness.js'
 const toLF = (s) => (typeof s === 'string' && s.indexOf('\r\n') !== -1 ? s.replace(/\r\n/g, '\n') : s)
 import { contentHash } from './substrate.js'
 
@@ -48,6 +48,8 @@ const has = (k) => argv.includes('--' + k)
 // required reason has to be written down, ends up in the PR body, and is the thing somebody asks
 // about later. hive_release already works this way for exactly the same argument.
 const FORCE = flag('force')
+// --seed <commit>: the commit a branch room was seeded from (hive-land passes the binding's record).
+const SEED = flag('seed')
 
 const REPO = flag('repo')
 const DRY = has('dry-run')
@@ -107,7 +109,20 @@ export function sanitizeIntent(raw) {
   return clean.length > 200 ? clean.slice(0, 200).trim() : clean
 }
 
+// An intent that already starts with the agent's own name ("Claude-cloud: Issue #6 ...", the way
+// agents often phrase them) must not be prefixed again: the mock run's commit read
+// "Claude-cloud: Claude-cloud: Issue #6 ..." (0.14.3 P1-9). Case-insensitive, repeated prefixes too.
+export function withoutOwnName(agent, intent) {
+  let s = String(intent || '')
+  const a = String(agent || '').trim()
+  if (!a) return s
+  const re = new RegExp(`^\\s*@?${a.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*:\\s*`, 'i')
+  for (let i = 0; i < 5 && re.test(s); i++) s = s.replace(re, '')
+  return s.trim() || String(intent || '').trim()
+}
+
 export function truncateSubject(agent, intent, max = 72) {
+  intent = withoutOwnName(agent, intent)
   const prefix = `${agent}: `
   const full = `${prefix}${intent}`
   if (full.length <= max) return full
@@ -230,7 +245,7 @@ export function commitMessage(g, room) {
       lines.push(`  - ${intent}`)
     }
     for (const ci of coauthorIntents) {
-      lines.push(`  - ${ci.name}: ${ci.intent}`)
+      lines.push(`  - ${ci.name}: ${withoutOwnName(ci.name, ci.intent)}`)
     }
     lines.push('')
     lines.push('Files:')
@@ -391,7 +406,21 @@ if (isMain) {
         const sha = git(['rev-parse', `${base}:${f.rel}`])
         const branchText = sha.code === 0 ? gitRaw(['cat-file', 'blob', sha.out]).out : null
         const roomText = toLF(fs.readFileSync(f.abs, 'utf8'))
-        decisions.push({ ...accountFor({ rel: f.rel, branchText, roomText, receipts: hive.provenanceOf(f.rel) || [] }), _f: f })
+        let d = accountFor({ rel: f.rel, branchText, roomText, receipts: hive.provenanceOf(f.rel) || [] })
+        // UNCHANGED ON THE BRANCH SINCE THE ROOM WAS SEEDED FROM IT (0.14.3 P0-3). A branch room
+        // starts as the branch at the seed commit, so a file whose branch copy is still that exact blob
+        // is one the room provably held at its start: writing the room's copy over it deletes nothing
+        // the room has not seen, whatever its receipts say. demo-3 (9 Nov) was refused here (Q506) on
+        // an untouched branch because one unsigned edit had cut test.js's chain off from the seed.
+        // Only a broken or missing chain is overruled; a file the branch changed since is still judged
+        // by its chain alone, so a real change under the room is still refused.
+        if (SEED && (d.state === DIVERGED || d.state === UNPROVEN) && sha.code === 0) {
+          const atSeed = git(['rev-parse', `${SEED}:${f.rel}`])
+          if (atSeed.code === 0 && atSeed.out === sha.out) {
+            d = { ...d, state: DESCENDS, why: `unchanged on the branch since the room was seeded from it (${SEED.slice(0, 7)}), so the room started from exactly this copy` }
+          }
+        }
+        decisions.push({ ...d, _f: f })
       }
     }
     const v = verdict(decisions)
@@ -417,7 +446,7 @@ if (isMain) {
       }
     }
 
-    if (DRY) {
+    if (DRY && !groups.length) {
       writePlanJson()
       console.log('\n--dry-run: nothing written')
       return finish(0)
@@ -428,6 +457,9 @@ if (isMain) {
       return finish(1)
     }
 
+    // A DRY RUN ANSWERS WHAT THE REAL ONE WILL (0.14.3). It used to return "would land" before this
+    // check, so the watcher's dry pass went green and the real landing then refused with Q506, and
+    // nobody heard (9 Nov, issue #9). The same verdict, the same refusal, nothing written either way.
     if (!v.ok) {
       writePlanJson()
       const lastTouch = (rel) => git(['log', '-1', '--format=%h %an %ad %s', '--date=short', base, '--', rel]).out
@@ -437,7 +469,12 @@ if (isMain) {
       // A forced run is still reported in full, and the reason travels into the PR body. The
       // point is not to make forcing hard, it is to make it visible.
       console.error('')
-      console.error(`--force given: "${FORCE}" -- overwriting ${v.blocked.length} file(s) anyway. This is recorded in the PR body.`)
+      console.error(`--force given: "${FORCE}" -- ${DRY ? 'would overwrite' : 'overwriting'} ${v.blocked.length} file(s) anyway. This is recorded in the PR body.`)
+    }
+    if (DRY) {
+      writePlanJson()
+      console.log('\n--dry-run: nothing written')
+      return finish(0)
     }
 
     const co = git(['checkout', '-b', BRANCH, base])

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'
 
@@ -460,7 +461,11 @@ export function filterRoomMembers(rawMembers = []) {
 
   for (const m of rawMembers) {
     if (!m || !m.name) continue
-    if (m.name === 'GitHub' || m.passive || m.listener) continue
+    // A LISTENER IS THE AGENT, NOT A BOT (P1-6, 9 Nov 2026). hive-await joins under the agent's own
+    // name, tagged `listener` and deliberately NOT passive, and presence is merged by name: every
+    // agent that keeps its listener armed (the room's rule) came back with listener: true and was
+    // dropped here, so the first issue comment said "In the room now: none yet" with agents present.
+    if (m.name === 'GitHub' || m.passive) continue
     // Exclude Recorder or ControlRoom viewer
     if (/recorder|control[-_ ]?room/i.test(m.name) || /control[-_ ]?room/i.test(m.app || '')) continue
 
@@ -705,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
@@ -735,6 +751,7 @@ export async function postIssue(opts = {}) {
       verified: true,
       members: members.agents,
       comment,
+      postFrontier,
     }
   } finally {
     if (hive && typeof hive.stop === 'function') {
@@ -842,6 +859,76 @@ function evaluateFileReview(hive, rel, plan = [], hashes = null) {
   }
 }
 
+/**
+ * The passive "GitHub-done" connection whenDone reads the room through. Its own function so that
+ * landIssue can open it, hand it to whenDone, and keep it open for the Q576 fix task: whenDone
+ * stops a connection it opened itself, and 0.14.2 then wrote the fix task and the room warning
+ * into that stopped doc, so the room never got them (0.14.3 P0-2 (b)).
+ */
+export async function openDoneHive({ link, token } = {}) {
+  const parsed = parseLink(link)
+  if (!parsed || !parsed.room) return { error: 'invalid room link' }
+  const tempDir = path.join(os.tmpdir(), `hive-done-${crypto.randomBytes(6).toString('hex')}`)
+  fs.mkdirSync(tempDir, { recursive: true })
+  const hive = startSync({
+    relay: parsed.relay,
+    room: parsed.room,
+    dir: tempDir,
+    name: 'GitHub-done',
+    kind: 'ai',
+    passive: true,
+    syncFiles: false,
+    token: parsed.token || token,
+    log: () => {},
+  })
+  // Wait for sync to establish
+  await new Promise((res) => {
+    const timer = setTimeout(res, 15000)
+    if (hive.provider) {
+      if (hive.provider.synced) {
+        clearTimeout(timer)
+        return res()
+      }
+      hive.provider.on('sync', (synced) => {
+        if (synced) {
+          clearTimeout(timer)
+          res()
+        }
+      })
+    } else {
+      res()
+    }
+  })
+  const close = async ({ settleMs = 0 } = {}) => {
+    // A write made just before close must get the chance to leave this process (the same family
+    // as P0-1); the watcher's own confirmed room line is the guarantee, this is best effort.
+    if (settleMs > 0) await new Promise((r) => setTimeout(r, settleMs))
+    try { hive.stop() } catch {}
+    try { fs.rmSync(tempDir, { recursive: true, force: true }) } catch {}
+  }
+  return { hive, tempDir, close }
+}
+
+/**
+ * The branch's head on origin, for the landing fingerprint: a Q506 says the branch moved, and a
+ * push that fixes the branch must earn a new landing even when the room did not change (0.14.3
+ * P0-2, Claude's review). ls-remote first (the local ref is only as new as the last fetch), the
+ * local origin ref when the network does not answer, '' when neither exists.
+ */
+export function branchHeadOf(root, branch) {
+  if (!root || !branch) return ''
+  const env = { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never' }
+  try {
+    const r = spawnSync('git', ['ls-remote', '--heads', 'origin', `refs/heads/${branch}`], { cwd: root, encoding: 'utf8', timeout: 15000, windowsHide: true, env })
+    const m = r.status === 0 && String(r.stdout || '').match(/^([0-9a-f]{40,64})\s/m)
+    if (m) return m[1]
+    const l = spawnSync('git', ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${branch}`], { cwd: root, encoding: 'utf8', timeout: 15000, windowsHide: true, env })
+    return l.status === 0 ? String(l.stdout || '').trim() : ''
+  } catch {
+    return ''
+  }
+}
+
 /**
  * B3: Done Detection
  * Evaluates whether an issue task in the room is ready for landing.
@@ -872,42 +959,13 @@ export async function whenDone(opts = {}) {
     if (syncRunner) {
       hive = await syncRunner()
     } else {
-      const parsed = parseLink(link)
-      if (!parsed || !parsed.room) {
-        return { ready: false, why: 'invalid room link', reasons: ['invalid room link'] }
+      const opened = await openDoneHive({ link, token })
+      if (opened.error) {
+        return { ready: false, why: opened.error, reasons: [opened.error] }
       }
-      tempDir = path.join(os.tmpdir(), `hive-done-${crypto.randomBytes(6).toString('hex')}`)
-      fs.mkdirSync(tempDir, { recursive: true })
-      hive = startSync({
-        relay: parsed.relay,
-        room: parsed.room,
-        dir: tempDir,
-        name: 'GitHub-done',
-        kind: 'ai',
-        passive: true,
-        syncFiles: false,
-        token: parsed.token || token,
-        log: () => {},
-      })
+      hive = opened.hive
+      tempDir = opened.tempDir
       ownedHive = true
-      // Wait for sync to establish
-      await new Promise((res) => {
-        const timer = setTimeout(res, 15000)
-        if (hive.provider) {
-          if (hive.provider.synced) {
-            clearTimeout(timer)
-            return res()
-          }
-          hive.provider.on('sync', (synced) => {
-            if (synced) {
-              clearTimeout(timer)
-              res()
-            }
-          })
-        } else {
-          res()
-        }
-      })
     }
 
     // 1. Task check
@@ -975,6 +1033,11 @@ export async function whenDone(opts = {}) {
       const why = dryRes ? dryRes.why : 'dry landing returned false'
       return {
         ready: false,
+        // A DRY REFUSAL IS A REFUSAL, with its code. Once the dry run answers what the real one will
+        // (0.14.3 P0-3), Q506 arrives HERE, before any real landing: dropping the code made it read as
+        // "not ready yet", and the watcher stays quiet on that by design, so issue #9's silence came
+        // back by the other door (Claude-cloud's review of P0-3).
+        ...(dryRes && dryRes.code ? { refused: true, code: dryRes.code } : {}),
         why: `dry landing check refused: ${why}`,
         reasons: [why],
         task,
@@ -988,6 +1051,9 @@ export async function whenDone(opts = {}) {
     // 4. Review status check for every planned file
     const reasons = []
     const unreviewedFiles = []
+    // Who reviewed each landing file, from the reviews bound to the exact content that lands: the PR
+    // body names them (0.14.3 P1-10; the mock run's PR #7 did not say who reviewed it).
+    const reviewed = []
     let hasHardBlock = false
 
     for (const rel of plannedFiles) {
@@ -1004,6 +1070,9 @@ export async function whenDone(opts = {}) {
           unreviewedFiles.push(rel)
           if (!allowUnreviewed) reasons.push(`${rel} has not been reviewed`)
         }
+      } else if (revStatus.verdict === 'pass') {
+        const by = [...new Set((revStatus.reviews || []).filter((r) => r && r.verdict === 'pass' && r.by).map((r) => String(r.by)))]
+        reviewed.push({ file: rel, by })
       } else if (revStatus.verdict === 'fail') {
         hasHardBlock = true
         reasons.push(`${rel} has an unresolved fail review`)
@@ -1038,6 +1107,7 @@ export async function whenDone(opts = {}) {
     return {
       ready: true,
       unreviewedFiles,
+      reviewed,
       files: plannedFiles,
       deletions,
       task,
@@ -1062,6 +1132,19 @@ export async function whenDone(opts = {}) {
  * Implements plan fingerprint caching to avoid retry loops on failing tests.
  */
 export async function landIssue(opts = {}) {
+  if (opts.syncRunner) return await landIssueOn(opts)
+  const opened = await openDoneHive({ link: opts.link, token: opts.token })
+  if (opened.error) return { ok: false, why: `Not ready to land: ${opened.error}`, reasons: [opened.error] }
+  let res = null
+  try {
+    res = await landIssueOn({ ...opts, syncRunner: async () => opened.hive })
+    return res
+  } finally {
+    await opened.close({ settleMs: res && res.toldRoom ? 1500 : 0 })
+  }
+}
+
+async function landIssueOn(opts = {}) {
   const {
     link,
     taskId,
@@ -1073,6 +1156,7 @@ export async function landIssue(opts = {}) {
     allowUnreviewed = false,
     state = {},
     token,
+    headOf = branchHeadOf,
   } = opts
 
   // 1. Check readiness
@@ -1088,6 +1172,11 @@ export async function landIssue(opts = {}) {
   })
 
   if (!wd.ready) {
+    // Refused at the dry run (a coded refusal, not "not done yet"): handed back WITH its code, so the
+    // watcher says it once, on the issue and in the room, like a refusal of the real landing.
+    if (wd.refused && wd.code) {
+      return { ok: false, code: wd.code, why: wd.why, reasons: wd.reasons, refusedAt: 'dry' }
+    }
     return {
       ok: false,
       ...(wd.blocked === 'unreviewed' ? { blocked: 'unreviewed', files: wd.unreviewedFiles || wd.files || [] } : {}),
@@ -1098,7 +1187,10 @@ export async function landIssue(opts = {}) {
 
   // 2. Plan fingerprint (Claude addition a: NO RETRY LOOP)
   const hive = wd.hive
-  const fingerprint = computePlanFingerprint(wd.plan, wd.files, hive, wd.hashes)
+  // The branch head is part of it: the same room work against a branch that moved (or was fixed)
+  // is a new landing, not a repeat of the failed one.
+  const head = (() => { try { return headOf(root, branch) || '' } catch { return '' } })()
+  const fingerprint = `${computePlanFingerprint(wd.plan, wd.files, hive, wd.hashes)}${head ? `@${head}` : ''}`
 
   if (state.lastFailedFingerprint === fingerprint) {
     return {
@@ -1128,6 +1220,13 @@ export async function landIssue(opts = {}) {
   if (wd.unreviewedFiles && wd.unreviewedFiles.length > 0) {
     summary += `\n\nNot reviewed by a second agent: ${wd.unreviewedFiles.join(', ')}`
   }
+  if (wd.reviewed && wd.reviewed.length > 0) {
+    // Names in code spans with any leading @ dropped: a room name like "@someone" must not ping a
+    // GitHub user from a PR body.
+    const who = (n) => `\`${String(n).replace(/^@+/, '').replace(/`/g, "'").slice(0, 60)}\``
+    summary += '\n\nReviewed in the room (hive_review, bound to the exact content that lands):\n' +
+      wd.reviewed.map((r) => `- ${r.file}: ${r.by.length ? r.by.map(who).join(', ') : 'a reviewer the room could not name'}`).join('\n')
+  }
 
   const landFn = landRunner || landAndOpen
 
@@ -1159,6 +1258,7 @@ export async function landIssue(opts = {}) {
         why: landRes.why,
         fingerprint,
         state: nextState,
+        toldRoom: Boolean(hive && (hive.assign || hive.say)),
       }
     }
 
@@ -1296,7 +1396,13 @@ export function collectPrFeedback(opts = {}) {
     )
   }
   if (issueNumber) {
-    streams.push(['ic', () => (gh && gh.comments ? gh.comments(issueNumber) : []), 'comment on the issue'])
+    // A DELETED ISSUE answers 404 on its comments forever; 0.14.2 threw here on every tick, so the
+    // watcher jammed with Q603 until restart while the PR was still open (0.14.3 P1). Gone means
+    // no comments; any other failure (rate limit, 5xx) still throws and is retried next tick.
+    streams.push(['ic', () => {
+      if (!gh || !gh.comments) return []
+      try { return gh.comments(issueNumber) } catch (e) { if (e && e.status === 404) return []; throw e }
+    }, 'comment on the issue'])
   }
 
   const fresh = []