hivecode-mcp 0.14.2 → 0.14.3

package/hive-room-watcher.js

@@ -68,7 +68,7 @@ export function saveRoomState(file, s) {
 export function makeRoomWatcher(o) {
   const {
     gh, link, branch, label = LABEL, stateFile, deps,
-    ackMinutes = 10, maxMinutes = 120, maxRuns = 6, maxRunsPerDay = 20, soloGraceMinutes = 2,
+    ackMinutes = 10, maxMinutes = 120, maxRuns = 6, maxRunsPerDay = 20, soloGraceMinutes = 2, refusalRetryMinutes = 10,
     fallbackAgent = '', host = os.hostname(),
     now = () => Date.now(), log = () => {},
   } = o
@@ -100,10 +100,23 @@ export function makeRoomWatcher(o) {
     .split(roomId).join('[room id removed]')
     .replace(/wss?:\/\/[^\s|)'"`]+(\|[^\s)'"`]*)?/g, '[relay link removed]')
     .replace(/\broom-[A-Za-z0-9_-]{12,}/g, '[room id removed]')
+    // LOCAL PATHS: a refusal's "why" names files on the watcher's machine (a home folder, a temp
+    // checkout); the issue is public (0.14.3 P0-2, Claude's review). Not inside URLs.
+    .replace(/(?<![\w.:/\\-])(?:[A-Za-z]:[\\/]|\\\\|\/(?:home|Users|tmp|var|root|private|opt|mnt|srv|workspace|data)\/)[^\s'"`)\]]*/g, '[local path removed]')
   const comment = (n, body) => { try { gh.comment(n, scrubRoom(body)) } catch (e) { log(`#${n}: could not comment on GitHub: ${e.message}`) } }
   const today = () => new Date(now()).toISOString().slice(0, 10)
   const runsToday = () => { if (state.day.date !== today()) state.day = { date: today(), runs: 0 }; return state.day.runs }
 
+  // A room line that may not arrive: deps.say is roomSay, confirmed by a second client. When it is
+  // not confirmed (or throws) the watcher logs it and carries on; the caller has already put the
+  // same news on GitHub, so nobody is left with neither (0.14.3 P0-2).
+  async function sayChecked(n, text) {
+    let r = null
+    try { r = await deps.say(text) } catch (e) { r = { ok: false, why: e && e.message } }
+    if (!r || !r.ok) log(`#${n}: could not confirm the room heard it (${(r && (r.why || r.code)) || 'no answer'}); the GitHub comment stands`)
+    return r
+  }
+
   function needsHuman(n, why, lines = []) {
     const it = state.issues[n]
     if (it) it.status = 'needs-human'
@@ -197,9 +210,15 @@ export function makeRoomWatcher(o) {
     const solo = (a.agentsSeen || []).length <= 1
     const graceMs = (solo ? soloGraceMinutes : ackMinutes) * 60000
     const allowUnreviewed = !!(a.unreviewedSince && now() - a.unreviewedSince >= graceMs && peek && peek.ok && peek.reachable.length <= 1)
-    const r = await deps.landIssue({ taskId: a.taskId, issue: { number: n, title: it.title }, lastFailedFingerprint: a.lastFailedFingerprint || '', allowUnreviewed })
+    // A REFUSAL IS TRIED AGAIN AFTER A PAUSE even when nothing changed (a push answered 503, a lock
+    // on the remote): once per refusalRetryMinutes, never every tick, and a repeat of the same
+    // refusal is neither said again nor counted again (antigravity-VM's attack 1). Failing tests
+    // are not retried this way: they wait for the room to change.
+    let lastFp = a.lastFailedFingerprint || ''
+    if (lastFp && a.lastRefusal && now() - (a.refusalTriedAt || a.lastRefusal.at) >= refusalRetryMinutes * 60000) { lastFp = ''; a.refusalTriedAt = now() }
+    const r = await deps.landIssue({ taskId: a.taskId, issue: { number: n, title: it.title }, lastFailedFingerprint: lastFp, allowUnreviewed })
     if (r && !r.ok && r.blocked === 'unreviewed') {
-      if (!a.unreviewedSince) {
+      if (!a.unreviewedSince && !a.unreviewedSaid) {
         a.unreviewedSince = now()
         const files = (r.files || []).slice(0, 6).join(', ') || 'the changed files'
         if (solo) {
@@ -208,8 +227,16 @@ export function makeRoomWatcher(o) {
         } else {
           await deps.say(`@all issue #${n} is done and waiting for a review of ${files} by someone who did not write them (hive_review). Nothing lands until then.`)
         }
+        a.unreviewedSaid = true
       }
-    } else if (r && !r.ok) a.unreviewedSince = 0
+      if (!a.unreviewedSince) a.unreviewedSince = now()
+    } else if (r && !r.ok && !r.skipped && !r.code && !r.fingerprint) {
+      // Only "not ready" (work reopened, a claim taken) restarts the review wait. A refusal or a
+      // skipped landing is not a change in the work: resetting here made a refused solo landing
+      // re-announce "nobody else to review" every grace period (antigravity-VM's attack 3).
+      a.unreviewedSince = 0
+      a.unreviewedSaid = false
+    }
     if (r && r.state && 'lastFailedFingerprint' in r.state) a.lastFailedFingerprint = r.state.lastFailedFingerprint || ''
     if (r && r.ok && a.kind === 'review') {
       const pr = r.pr || {}
@@ -234,8 +261,38 @@ export function makeRoomWatcher(o) {
     }
     if (r && r.code === 'Q576' && !r.skipped) {
       a.runs = (a.runs || 0) + 1
+      a.lastRefusal = null // failing tests wait for the room to change; they are not retried on a timer
       if (a.runs >= maxRuns) return needsHuman(n, `the tests failed ${a.runs} times in a row (the limit is ${maxRuns}).`, (peek && peek.lastLines) || [])
       comment(n, `The tests failed on the agents' work, so nothing was pushed. It went back to the room (attempt ${a.runs} of ${maxRuns}).\n\n${MARK('room', { kind: 'tests-failed', run: a.runs })}`)
+      // SAID BY THE WATCHER, CONFIRMED: landIssue's own room line went through a connection that
+      // whenDone had already stopped, so the room never heard its tests failed (0.14.3 P0-2).
+      await sayChecked(n, `@all the tests failed when landing issue #${n} (attempt ${a.runs} of ${maxRuns}): ${oneLine(r.why, 300)} Nothing was pushed. Fix them in the room; the landing is tried again when the room's files or the branch change.`)
+    }
+    // A LANDING REFUSED FOR ANY OTHER REASON IS SAID, never swallowed (0.14.3 P0-2). On 0.14.2 a
+    // refusal (Q506, a push refused, no git identity...) matched no branch here: nothing in the
+    // room, nothing on the issue, and the next tick's identical fingerprint was a silent skip, so
+    // issue #9 sat "done" and landed nothing with no word anywhere. Said once per refusal (same
+    // code, same fingerprint), counted like failing tests, then a person. The issue comment goes
+    // FIRST: an unreachable room must never mean nobody heard (Claude's review).
+    if (r && !r.ok && !r.skipped && r.blocked !== 'unreviewed' && r.code !== 'Q576' && (r.code || r.fingerprint)) {
+      const fp = r.fingerprint || (r.state && r.state.lastFailedFingerprint) || ''
+      const key = `${r.code || ''}|${fp || oneLine(r.why, 120)}`
+      if (a.refusedKey !== key) {
+        a.refusedKey = key
+        a.refusals = (a.refusals || 0) + 1
+        const code = r.code || 'refused'
+        const why = oneLine(r.why, 300) || 'no reason given'
+        a.lastRefusal = { code, why, at: now() }
+        log(`#${n}: landing refused (${code}): ${why}`)
+        if (a.refusals >= maxRuns) return needsHuman(n, `the landing was refused ${a.refusals} times (the limit is ${maxRuns}); the last time ${code}: ${why}`, (peek && peek.lastLines) || [])
+        comment(a.kind === 'review' ? a.pr : n, `The agents' work is done, but Hivecode refused to land it (${code}): ${oneLine(r.why, 400) || 'no reason given'} Nothing was pushed. It went back to the room (refusal ${a.refusals} of ${maxRuns}); it is tried again when the room's files or the branch change.\n\n${MARK('room', { kind: 'refused', code })}`)
+        await sayChecked(n, `@all issue #${n} is done, but its landing was REFUSED (${code}): ${why} Nothing was pushed. Fix the cause in the room; the landing is tried again when the room's files or the branch change.`)
+      } else if (a.lastRefusal) {
+        // The same refusal again (a retry after the pause): not said or counted again, but
+        // `github status` shows it is still happening, so a silent wait is never mistaken for
+        // progress (Claude's review).
+        a.lastRefusal.seen = now()
+      }
     }
     if (now() - a.postedAt > maxMinutes * 60000) return needsHuman(n, `the room worked on it for more than ${maxMinutes} minutes without a landing.`, (peek && peek.lastLines) || [])
 
@@ -395,6 +452,10 @@ export function describeRoomState(s, { now = Date.now(), maxRunsPerDay = (s && s
     out.push(`  working on ${what} for ${mins(a.postedAt)} min; ${a.engagedAt ? 'an agent has taken it' : 'NO agent has taken it yet'}${a.runs ? `; tests failed ${a.runs} time(s)` : ''}`)
     if (a.fallback) out.push(`  fallback agent started ${mins(a.fallback.at)} min ago (${a.fallback.why})`)
     if (a.unreviewedSince) out.push(`  done, waiting ${mins(a.unreviewedSince)} min for a review by an agent that did not write it`)
+    if (a.lastRefusal) {
+      const still = a.lastRefusal.seen ? `; still refused (same reason) for ${mins(a.lastRefusal.at)} min, last tried ${mins(a.lastRefusal.seen)} min ago` : ''
+      out.push(`  landing refused ${mins(a.lastRefusal.at)} min ago (${a.lastRefusal.code}): ${oneLine(a.lastRefusal.why, 200)}${still}`)
+    }
   } else if (s.openPr) {
     out.push(`  waiting for PR #${s.openPr} to be merged or closed before the next issue (one open PR per room)`)
   } else {

package/hive-slack.js

@@ -180,6 +180,28 @@ export function makeQueue({
 
 export const SLACK_TIMEOUT_MS = 15000
 
+// HOW SLACK READS A CALL'S ARGUMENTS (0.14.3 P0-4). Read methods take their arguments only from the
+// query string or a form body: a JSON body is ignored, so on 0.14.2 conversations.info answered
+// invalid_arguments and users.info user_not_found in a real workspace (measured 9 Nov 2026), which
+// broke `slack check`, the --slack-channel preflight, inbound stop/retry and stop verification.
+// Every fake Slack in the tests accepted JSON, so all of it was green. Write methods (chat.*,
+// agents.*, reactions.*...) take JSON and stay JSON: their blocks and metadata are nested objects.
+const FORM_METHOD = /^(?:(?:conversations|users|team|bots)\.[A-Za-z.]+|auth\.test)$/
+export function slackEncoding(method) {
+  return FORM_METHOD.test(String(method || '')) ? 'form' : 'json'
+}
+
+/** A form body Slack reads: undefined and null are LEFT OUT (never the text "undefined", which Slack
+ *  would read as a real channel or user id); a nested value is JSON inside its field, as Slack takes it. */
+export function slackForm(body = {}) {
+  const p = new URLSearchParams()
+  for (const [k, v] of Object.entries(body || {})) {
+    if (v === undefined || v === null) continue
+    p.append(k, typeof v === 'object' ? JSON.stringify(v) : String(v))
+  }
+  return p.toString()
+}
+
 /** POST to Slack's Web API. Kept tiny and injectable so the bridge can be tested without a
  *  workspace -- the thing worth testing is our routing, not Slack's HTTP.
  *  Applies a 15s AbortSignal timeout by default so a hung TCP socket never stalls the queue. */
@@ -191,10 +213,14 @@ export async function slackPost(
   apiBase = process.env.HIVE_SLACK_API || DEFAULT_API,
   timeoutMs = Number(process.env.HIVE_SLACK_TIMEOUT_MS) || SLACK_TIMEOUT_MS,
 ) {
+  const form = slackEncoding(method) === 'form'
   const r = await fetchImpl(`${apiBase}/${method}`, {
     method: 'POST',
-    headers: { 'Content-Type': 'application/json; charset=utf-8', Authorization: `Bearer ${token}` },
-    body: JSON.stringify(body),
+    headers: {
+      'Content-Type': form ? 'application/x-www-form-urlencoded; charset=utf-8' : 'application/json; charset=utf-8',
+      Authorization: `Bearer ${token}`,
+    },
+    body: form ? slackForm(body) : JSON.stringify(body),
     signal: AbortSignal.timeout(timeoutMs),
   })
   const retryHeader = r.headers && typeof r.headers.get === 'function' ? Number(r.headers.get('retry-after') || 0) : 0
@@ -2120,6 +2146,13 @@ export async function runSlackCheck({
     clearTimeout(waitTimer)
 
     if (!arrived) {
+      // Over HTTPS polling nothing is subscribed: the bridge reads the thread itself, and its read
+      // scopes were checked above. So no reply means nobody replied in time, and sending the person
+      // off to reinstall the app was wrong (9 Nov, the first real check: 0 replies in the thread).
+      if (pollInbound) {
+        logErr(`Q634 no reply arrived in the thread within ${Math.round(timeoutMs / 1000)} s. Replies are read over HTTPS, which needs no event subscription, and the read scopes are in place: reply anything in the thread of "Hivecode check: reply anything in this thread" in #${channelName} while the check waits (raise --timeout for more time).`)
+        return 1
+      }
       const manifestName = agent ? 'slack-app-manifest-agent.json' : 'slack-app-manifest-inbound.json'
       logErr(`Q634 replies did not arrive. Event subscriptions are probably missing: reinstall from ${manifestName}`)
       return 1

package/hive-transport.js

@@ -373,6 +373,7 @@ export class PollSocket extends SocketShape {
   _lost(reason, code = 1006) {
     if (this.readyState === CLOSED) return
     this.readyState = CLOSED
+    clearTimeout(this._closeTimer)
     if (this._sid) this._req('close', undefined, {}, 5000).catch(() => { })
     fire(this, 'close', { type: 'close', code, reason, wasClean: false, target: this })
   }
@@ -392,7 +393,7 @@ export class PollSocket extends SocketShape {
     // A proxy that cuts long requests shows up as a failure after a long wait: hold shorter.
     if (startedAt && now - startedAt > 5000 && this._hold > 4000) this._hold = Math.max(4000, Math.floor(this._hold / 2))
     await sleep(Math.min(2000, 250 * 2 ** Math.min(3, Math.floor((now - this._troubleSince) / 5000))))
-    return this.readyState === OPEN
+    return this.readyState === OPEN || this.readyState === CLOSING
   }
   _ok() { this._troubleSince = 0 }
   async _recvLoop() {
@@ -429,17 +430,18 @@ export class PollSocket extends SocketShape {
     if (!this._flushQueued) { this._flushQueued = true; setImmediate(() => { this._flushQueued = false; this._flush() }) }
   }
   async _flush() {
-    if (this._sending || !this._outbox.length || this.readyState !== OPEN) return
+    const live = () => this.readyState === OPEN || this.readyState === CLOSING
+    if (this._sending || !this._outbox.length || !live()) { this._closeIfDrained(); return }
     this._sending = true
     try {
-      while (this._outbox.length && this.readyState === OPEN) {
+      while (this._outbox.length && live()) {
         let n = 0, bytes = 0
         while (n < this._outbox.length && n < 512 && (n === 0 || bytes + this._outbox[n].length <= 4 * 1048576)) { bytes += this._outbox[n].length; n++ }
         const batch = this._outbox.slice(0, n)
         const first = this._outSeq
         const body = packFrames(batch)
         for (;;) {
-          if (this.readyState !== OPEN) return
+          if (!live()) return
           const started = Date.now()
           let r
           try { r = await this._req('send', body, { 'content-type': 'application/octet-stream', 'x-hive-seq': String(first) }, 60000) }
@@ -455,17 +457,54 @@ export class PollSocket extends SocketShape {
         this._outbox.splice(0, n)
         this._outSeq = first + n
       }
-    } finally { this._sending = false }
+    } finally { this._sending = false; this._closeIfDrained() }
   }
+  // CLOSE DELIVERS WHAT WAS SENT FIRST, as a WebSocket's does (0.14.3 P0-1). A WebSocket hands its
+  // bytes to the OS on send(), so ws.close() still delivers them; this socket keeps them in _outbox
+  // until the relay accepts them, and close() used to drop that array: an edit made just before the
+  // agent left never reached the room while hive_edit had already said it was syncing (8-9 Nov mock
+  // run, both Antigravity VM agents). Now close() keeps sending for up to CLOSE_DRAIN_MS, then ends
+  // the session. The pending request keeps the process alive meanwhile, so an exit waits for it.
   close(code = 1000, reason = '') {
     if (this.readyState === CLOSING || this.readyState === CLOSED) return
+    if (this.readyState === OPEN && (this._outbox.length || this._sending)) {
+      this.readyState = CLOSING
+      this._closeWith = { code, reason }
+      this._closeTimer = setTimeout(() => this._endClose(false), PollSocket.CLOSE_DRAIN_MS)
+      this._flush()
+      return
+    }
+    this._closeWith = { code, reason }
+    this._endClose(true)
+  }
+  _closeIfDrained() {
+    if (this.readyState === CLOSING && !this._sending && !this._outbox.length) this._endClose(true)
+  }
+  _endClose(drained) {
+    if (this.readyState === CLOSED) return
+    clearTimeout(this._closeTimer)
     const had = !!this._sid
+    const { code, reason } = this._closeWith || { code: 1000, reason: '' }
     this.readyState = CLOSED
     if (had) this._req('close', undefined, {}, 5000).catch(() => { })
-    setImmediate(() => fire(this, 'close', { type: 'close', code, reason, wasClean: true, target: this }))
+    setImmediate(() => fire(this, 'close', { type: 'close', code, reason, wasClean: drained, target: this }))
+  }
+  /** Resolves once nothing is waiting to reach the relay (or the socket is gone): the drain, observable. */
+  drained(timeoutMs = PollSocket.CLOSE_DRAIN_MS) {
+    const end = Date.now() + timeoutMs
+    return new Promise((resolve) => {
+      const tick = () => {
+        if (this.readyState === CLOSED || (!this._outbox.length && !this._sending)) return resolve(!this._outbox.length)
+        if (Date.now() >= end) return resolve(false)
+        setTimeout(tick, 25)
+      }
+      tick()
+    })
   }
-  terminate() { this.close(1006, 'terminated') }
+  // terminate is for a dead link (the liveness check): nothing can be delivered on it, so no drain.
+  terminate() { this._closeWith = { code: 1006, reason: 'terminated' }; this._endClose(false) }
 }
+PollSocket.CLOSE_DRAIN_MS = 10000
 
 /**
  * The socket every provider gets: a WebSocket, or long-poll where WebSockets are refused (above).

package/icr.js

@@ -802,12 +802,17 @@ export function structuralMerge(base, a, b, opts = {}) {
   // ASYNC/AWAIT SYNCHRONIZATION (intent):
   // When a declaration was synchronous in base and became ASYNC in the merged result,
   // upgrade call sites inside async callers with `await` so the contract holds.
+  // ONLY a function that EXISTED in the base as sync (0.14.3 P0-5). A function new in this merge was
+  // written async by its author, together with its callers: nothing was "made async" under anyone.
+  // Counting it rewrote authored lines (`return f()` -> `return await f()`, credited to the author,
+  // silently), and two peers making the same insert at once stacked in the shared text: the room's
+  // own server.js read `return await await await admitMux(req, q)` (9 Nov).
   const asyncUpgrades = []
   if (lang.isAsyncDecl && lang.upgradeCallSitesToAwait) {
     for (const name of mergedNames) {
-      const wasAsyncInBase = baseNames.has(name) ? lang.isAsyncDecl(base, name) : false
+      const wasSyncInBase = baseNames.has(name) && !lang.isAsyncDecl(base, name)
       const isAsyncInMerged = lang.isAsyncDecl(merged, name)
-      if (!wasAsyncInBase && isAsyncInMerged) {
+      if (wasSyncInBase && isAsyncInMerged) {
         const upgraded = lang.upgradeCallSitesToAwait(merged, name)
         if (upgraded !== merged && lang.parses(upgraded)) {
           merged = upgraded

package/lang-js.js

@@ -230,45 +230,63 @@ function isAsyncDecl(src, name) {
 
 // Upgrade free call sites of `fnName` to `await fnName(...)` if they are inside an async parent
 // and not already awaited.
+//
+// Left alone (0.14.3 P0-5): a call that is already awaited (`await f()`, `await (f())`); a call that
+// IS the value an async function returns (`return f()`, `async () => f()`) -- OUTSIDE a try, where
+// returning the promise resolves to the same value. Inside a try (its block or its catch) `return f()`
+// is NOT the same once f is async: a rejection escapes the catch and a finally runs before f settles,
+// so there it is upgraded, which is what the feature is for (Claude-cloud's review). A call that is an
+// argument of an awaited call (`await g(f())`) is NOT awaited by that await and is upgraded too.
+// Each position is inserted at most once.
 function upgradeCallSitesToAwait(src, fnName) {
   try {
     const ast = parse(src)
-    const spots = []
+    const spots = new Set()
 
-    function walkAST(node, parent, isAsyncScope = false) {
+    // awaited: this node IS the operand of an await (through parentheses or an optional chain only).
+    // inTry: this node sits in a try block or catch clause of the current function.
+    function walkAST(node, parent, isAsyncScope = false, awaited = false, inTry = false) {
       if (!node || typeof node.type !== 'string') return
 
       let childAsyncScope = isAsyncScope
+      let childInTry = inTry
       if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
         childAsyncScope = !!node.async
+        childInTry = false // a nested function has its own try scopes
       }
+      const passAwait = node.type === 'AwaitExpression' ? true
+        : (node.type === 'ParenthesizedExpression' || node.type === 'ChainExpression') ? awaited : false
 
       if (node.type === 'CallExpression') {
         let isTarget = false
         if (node.callee.type === 'Identifier' && node.callee.name === fnName) isTarget = true
         if (isTarget && childAsyncScope) {
-          const alreadyAwaited = parent && parent.type === 'AwaitExpression'
-          if (!alreadyAwaited) {
-            spots.push(node.start)
-          }
+          const alreadyAwaited = awaited || (parent && parent.type === 'AwaitExpression')
+          const returnedAsIs = !inTry && parent && (parent.type === 'ReturnStatement' ||
+            (parent.type === 'ArrowFunctionExpression' && parent.body === node))
+          if (!alreadyAwaited && !returnedAsIs) spots.add(node.start)
         }
       }
 
       for (const k of Object.keys(node)) {
         if (k === 'type' || k === 'start' || k === 'end' || k === 'loc' || k === 'range') continue
         const v = node[k]
+        // A try's block and its catch clause are "in try"; its finally is not (a return there is final).
+        const kInTry = node.type === 'TryStatement' ? (k === 'block' || k === 'handler') || childInTry : childInTry
         if (Array.isArray(v)) {
-          for (const c of v) walkAST(c, node, childAsyncScope)
+          for (const c of v) walkAST(c, node, childAsyncScope, passAwait, kInTry)
         } else if (v && typeof v.type === 'string') {
-          walkAST(v, node, childAsyncScope)
+          walkAST(v, node, childAsyncScope, passAwait, kInTry)
         }
       }
     }
 
     walkAST(ast, null, false)
-    if (!spots.length) return src
+    if (!spots.size) return src
 
-    spots.sort((a, b) => b - a)
+    const order = [...spots].sort((a, b) => b - a)
+    spots.clear()
+    for (const p of order) spots.add(p)
     let out = src
     for (const pos of spots) {
       out = out.slice(0, pos) + 'await ' + out.slice(pos)
@@ -279,6 +297,31 @@ function upgradeCallSitesToAwait(src, fnName) {
   }
 }
 
+// STACKED AWAITS LEFT BY A CRDT UNION (0.14.3 P0-5-3). Two peers making the same sync -> async
+// change at once each insert `await ` before the same call; the shared text keeps BOTH inserts, so
+// the room reads `await await f()`. No merge can prevent that (each peer's merge is right on its own),
+// so the engine removes it afterwards. Returns the [start, end) spans to delete: for every
+// `await await x`, the OUTER `await` and the whitespace after it, and only when nothing but whitespace
+// separates the two (so `await (await x)`, a comment, or a string is never touched). On the same
+// converged text every peer computes the same spans, so their deletes are of the same characters.
+function stackedAwaits(src) {
+  let ast
+  try { ast = parse(src) } catch { return [] }
+  const spans = []
+  const walk = (node) => {
+    if (!node || typeof node.type !== 'string') return
+    if (node.type === 'AwaitExpression' && node.argument && node.argument.type === 'AwaitExpression' &&
+        /^await\s+$/.test(src.slice(node.start, node.argument.start))) spans.push([node.start, node.argument.start])
+    for (const k of Object.keys(node)) {
+      if (k === 'type' || k === 'start' || k === 'end' || k === 'loc' || k === 'range') continue
+      const v = node[k]
+      if (Array.isArray(v)) { for (const c of v) walk(c) } else if (v && typeof v.type === 'string') walk(v)
+    }
+  }
+  walk(ast)
+  return spans.sort((a, b) => a[0] - b[0])
+}
+
 // Find callers of `fnName` that are synchronous (cannot be auto-awaited without changing the caller's signature)
 function syncCallSitesOf(src, fnName) {
   const syncCallers = []
@@ -641,6 +684,7 @@ export const javascript = {
   declBody,
   isAsyncDecl,
   upgradeCallSitesToAwait,
+  stackedAwaits,        // spans of `await await` a CRDT union left (P0-5-3)
   syncCallSitesOf,
   renameRefs,           // rewrites every matching identifier (kept for reference)
   renameFreeRefs,       // scope-aware — only rewrites references that resolve to the binding

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hivecode-mcp",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "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",
@@ -36,7 +36,11 @@
     "hive-version.js",
     "hive-pr-staleness.js",
     "hive-pr.js",
-    "hive-branch.js", "hive-land.js", "hive-repos.js", "hive-room-mode.js", "hive-room-watcher.js",
+    "hive-branch.js",
+    "hive-land.js",
+    "hive-repos.js",
+    "hive-room-mode.js",
+    "hive-room-watcher.js",
     "hive-mailbox.js",
     "hive-obligations.js",
     "hive-receipts.js",
@@ -188,5 +192,9 @@
     "doc": "docs",
     "test": "tests"
   },
-  "author": "Ganesh Shivlal Kute <support@getgrm.tech>"
+  "author": "Ganesh Shivlal Kute <support@getgrm.tech>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ganesh-Kute/HiveCode.git"
+  }
 }