hivecode-mcp 0.14.2 → 0.14.4

package/sync.js

@@ -27,7 +27,8 @@ import ignore from 'ignore'
 import { applyDiff, summarizeChange, changedRange, hasConflictMarkers, merge3 } from './core.js'
 import { icrMerge3 } from './icr-merge.js' // structure/intent-aware merge; falls back to line merge3
 import { makeCoordinator } from './hive-coord.js' // decentralized claim layer (collision PREVENTION)
-import { gateConfig, runGate, verdictRecord, refusalMessage, forcedMessage } from './hive-gate.js' // the HANDOFF gate: a claim you cannot give back while your own check fails
+import { RULES_MD, AGENT_MANUAL } from './hive-instructions.js'
+import { gateConfig, runGate, verdictRecord, refusalMessage, forcedMessage, gateApproved, gatesDir, writeApproval, notApprovedMessage, notApprovedLine, GATE_CMD, GATE_NOT_APPROVED } from './hive-gate.js' // the HANDOFF gate: a claim you cannot give back while your own check fails
 import { fileRoom, decodeUnsafe, scopeForRoom, pathAllowed, writeAllowed, isSafeRelPath } from './token.js'
 import { validateMemberName } from './hive-mailbox.js' // a name the mention parser cannot produce is not a name
 import { genIdentity, authorChange, verifyReceipt, contentHash } from './substrate.js' // convergent-substrate: signed provenance for every landed change
@@ -229,149 +230,12 @@ const OWN_LOCAL = new Set([SHADOW_FILE, SHADOW_FILE + '.tmp', LOCK_FILE, '.hive-
 // Written into every room folder on sync (like the rules). An AI agent that opens
 // this project reads it to learn it's a Hivecode room and how to JOIN — via the
 // .hive.json already in the folder, so no human has to paste a link.
-const AGENT_MANUAL_TEXT = `# Hivecode — for AI agents working in this folder
-
-This project is part of a live Hivecode room: humans and AI agents editing the same
-codebase together, in real time, with no git push/pull. If you are an AI assistant
-asked to collaborate here, follow this.
-
-## Join the room
-1. If you do NOT have a \`hive_join\` tool and you can run terminal commands, register
-   the Hivecode MCP server, then reload so the tools load:
-     claude mcp add hivecode -- npx -y hivecode-mcp@latest
-2. Call: hive_join({ dir: ".", name: "<your name>", owner: "<the human you work for>" })
-   The room, relay, and token are already saved in .hive.json in this folder, so you
-   do NOT need a link — hive_join reads them automatically.
-3. Read the HIVE_RULES it returns, and follow them.
-
-## Work the loop
-- hive_read_chat() and hive_read_board() BEFORE editing — see what others are doing.
-- hive_claim("path/to/file") BEFORE you edit a file. If you get it, edit then
-  hive_release it. If you DON'T, someone else holds it — pick other work
-  (hive_claims() shows what's open). This is how agents avoid colliding.
-- hive_say("taking X: doing Y") to announce intent before you edit.
-- ADDRESS EVERY MESSAGE. Put @Name on it for each agent it is for -- hive_say("@Ana I need the churn numbers before I touch pricing.md"). Any agent may address any other agent directly; there is no lead to route through and nobody needs permission. A message that names nobody lands in every agent's "room activity", where they are told to skip it, so it will most likely be ignored. Use @all when you genuinely need the whole room -- it wakes everyone, so spending it on chatter is how a room learns to ignore you.
-- ANSWER EVERY QUESTION AIMED AT YOU. "Not yet -- I am on X, I will come back to you" is a complete answer; silence is the one thing the asker cannot act on, because nothing tells them you stopped. hive_check lists anyone still waiting on you.
-- BEFORE A LONG STRETCH OF WORK, call hive_busy("what you are doing"). It posts no message and silences nothing -- it tells anyone who @mentions you, at the moment they send, that you are mid-task rather than ignoring them. hive_busy(clear:true) when you finish.
-- Edit ONLY inside the folders you were granted. Edits merge live; rewrites are logged.
-- Block on hive_wait(); when it returns approved work, do it, then hive_complete(id).
-- A task aimed at you stays PENDING until your owner approves it — act only on 'accepted'.
-
-## Rules of the road
-- Stay in your lane — never edit folders you weren't granted.
-- Announce before editing; coordinate in chat; ask before anything destructive in others' areas.
-- If a human PAUSES you, finish your current step and stop until resumed.
-- Resolve <<<<<<< conflict markers properly — never blindly overwrite.
-- A human can ROLL BACK your changes at any time; that's normal — re-read and continue.
-
-## If something breaks
-Support is support@getgrm.tech. Mention it only if the human asks, or if something
-here is genuinely broken and they need somewhere to send it. Never volunteer it
-otherwise, and never write it into a file.
-`
+const AGENT_MANUAL_TEXT = AGENT_MANUAL // hive-instructions.js: one source for every agent-facing text (0.14.4)
 
 // The hive's law. Auto-written into every room folder so it is ALWAYS present —
 // no setup, no relying on an agent to remember it. The sync layer enforces the
 // hard parts (merge, board); this is the rest, in plain imperative language.
-const HIVE_RULES_TEXT = `# HIVE RULES — read this first. Everyone in this room (human or AI) follows these.
-
-You are in a Hivecode room: a shared live workspace where humans and AI agents
-edit ONE project together in real time. These rules keep anyone from destroying
-another's work. The sync layer enforces the hard parts automatically; you do the rest.
-
-## Identity
-- You are automatically "human" (you ran the editor) or "ai" (you ran the agent
-  client). Nobody declares it — running the client is the declaration.
-
-## Know who you are working with
-- Read HIVE_MEMBERS.md — who (humans + AIs) is in the room right now, and how many.
-
-## DESIGN BEFORE YOU WRITE — mandatory (Ganesh, 19 Sep 2026)
-Before you build any new feature, post in the room, BEFORE your first edit:
-1. WHO uses it, and when — name the person or agent and the moment they reach for it.
-2. WHAT IT COSTS when it is wrong — one sentence someone who did not write it can act on at 3am.
-3. EVERY EDGE CASE you can name — empty, missing, offline, refused, concurrent, already-done,
-   called twice, called by the wrong person.
-Then build it.
-This is not process for its own sake. Every defect this project has produced has been a FALSE
-SUCCESS — nothing crashed, every signal was green, the result was wrong. That class is never
-caught by testing the happy path afterwards; it is caught by asking first what "wrong but green"
-would look like for this particular feature. If you cannot say what breaks, you do not understand
-it well enough to write it — say so in the room and ask. That is a complete answer.
-
-## Before you touch a file
-1. Read HIVE_CHAT.md — what is everyone doing right now.
-2. Read HIVE_BOARD.md — which files were just rewritten (and what was touched).
-3. If a file you plan to edit appears there, RE-READ it before changing it.
-
-## CLAIM before you edit (this is how the hive avoids collisions)
-- Before editing a file, CLAIM it: call the hive_claim tool with the file path
-  (and a short intent). This is the most important coordination step.
-  • If you GOT it: edit it, then call hive_release when you finish.
-  • If you could NOT get it: someone else holds it — do NOT edit it. Pick other
-    work; call hive_claims to see what's open.
-- Claims auto-expire, so a stalled agent never blocks the hive — but always
-  hive_release the moment you finish, so others can take it.
-
-## While you work
-4. ANNOUNCE first: post to chat what you are taking, e.g.
-   call hive_say with "taking auth.js: adding login validation"
-5. PREFER SMALL PATCHES — grep to the spot, edit a few lines. Patches from
-   different agents merge automatically with no conflict.
-6. AVOID full-file rewrites unless necessary. If you must rewrite, RE-READ the
-   file first so you build on the latest code (rewrites are auto-logged for all).
-7. STAY IN YOUR LANE — if someone said "I own X" (e.g. the backend), read X but
-   do not edit it; leave that to the owner.
-
-## When things collide
-8. If you see <<<<<<<  =======  >>>>>>> markers in a file, the system could not
-   auto-merge — RESOLVE it: keep the right code, delete the markers. Never ignore
-   them or blindly overwrite.
-9. If your edit was merged/reworked, that is normal — re-read and continue.
-
-## Talking
-10. Coordinate in chat. ASK before anything destructive (delete, rename, big
-    refactor) that touches another participant's area.
-
-## Directed work + permission (the asymmetric gate)
-11. AI -> AI is COORDINATION: if another agent hands you work (via hive_assign), it is auto-accepted
-    and you may proceed. If there is no Lead PM setting global state, use hive_assign and hive_say 
-    to assign tasks directly to other agents to divide and conquer. This is how a leaderless hive 
-    plans and divides work by itself.
-12. A HUMAN directing you is different. If a human who is NOT your owner assigns
-    you a task, you do NOT act on it — it stays PENDING until YOUR OWNER approves
-    ("do it or ignore?"). Your own owner's requests proceed. Act only on tasks
-    whose status is 'accepted'.
-13. If you are an MCP agent: loop on hive_wait — it blocks until accepted work
-    arrives, then you do it and call hive_complete. No need to poll. A pending
-    human request will NOT wake you until your owner approves it.
-
-## Mission control (a human can pause/steer you)
-- If you are PAUSED, finish your current step and STOP — do not start new work
-  until you are resumed. (MCP agents: hive_wait returns no work while paused.)
-- A human may REASSIGN your focus at any time; treat a fresh directive from your
-  owner as the new priority.
-
-## When a ping arrives while you are mid-task (interruptions)
-14. hive_wait only checks BETWEEN steps, so a ping never interrupts mid-step.
-    Finish your current atomic step first (never abandon half-done work), then
-    handle queued coordination. If it's urgent (build broken, blocking others),
-    do it now.
-15. ACKNOWLEDGE a ping as soon as you see it so the sender isn't left hanging,
-    e.g. say "got it — finishing X (~2 min), then on your fix".
-16. YOU triage: announce do-now vs after-current. Your OWNER can override anytime
-    — if your owner says "do it now" or "skip that", that wins.
-
-## State-Machine Prompting (SMP)
-17. The Lead PM controls the [GLOBAL PROJECT STATE] via hive_set_state.
-18. ONLY use short enum flags (e.g. "APPROVED", "LOCKED"). Do NOT store paragraphs of text in the state, it will bloat the context window.
-19. If you are a worker agent, block on hive_wait until your specific state flag turns to APPROVED/READY. Do not write code if you are LOCKED.
-
-Read → announce → patch → respect lanes → resolve conflicts → talk → triage pings → wait for approval.
-
----
-Support: support@getgrm.tech
-`
+const HIVE_RULES_TEXT = RULES_MD // hive-instructions.js (0.14.4); HIVE_RULES.md in the package is generated from it
 
 /**
  * Where an account licence may come from, in precedence order — and where it may NOT.
@@ -461,7 +325,10 @@ export function acquireFolderLock(root, room, log = console.log) {
   return release
 }
 
-export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir = '.', name = 'anon', kind = 'human', owner = '', token = '', license = '', log = console.log, syncFiles = true, passive = false, listener = false, app = '' }) {
+export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir = '.', name = 'anon', kind = 'human', owner = '', token = '', license = '', log = console.log, syncFiles = true, passive = false, listener = false, app = '', gatesDir: gatesDirOpt = '' }) {
+  // Where this machine keeps its gate approvals (0.14.4 S-1): outside the synced folder, so no peer can write one.
+  const GATES_DIR = gatesDirOpt || gatesDir()
+  const gateSkipSaid = new Set() // (agent, command) pairs already announced as unchecked
   // BEFORE ANY DISK OR SOCKET WORK. A name outside the mention grammar joins successfully and is
   // then unreachable: its mail, its obligations and its wake-on-mention are all silently dead,
   // and the only symptom is other people being told "@X is NOT in the room" about someone who is
@@ -753,6 +620,26 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
       })
     } catch { /* provenance must never break the sync path */ }
   }
+  // NOTHING THIS CLIENT PUBLISHES ENTERS THE ROOM UNSIGNED (0.14.3 P0-3). With the fork gate on, a
+  // local edit is signed by captureLocal, which needs a baseline (`shadow`) to diff against. An edit
+  // made before the file first synced on a fresh join has none, and the rejoin and creation-race
+  // merges publish without passing through it at all. The content still landed, so the file's chain
+  // broke: `pr` then refused with a false Q506 ("the branch holds content this room has never seen")
+  // on a branch nobody had touched, and credited the file to the last agent that HAD signed (8-9 Nov
+  // mock run, test.js in demo-3). So after any local publish: if no receipt yields exactly what was
+  // published, sign it now, from the room's copy it replaced -- the state the room provably held.
+  // Only when THIS client's own edit went out unsigned: if captureLocal signed the authored text (or
+  // anyone signed what was published), nothing is added, so the fork gate sees exactly what it saw
+  // before. A receipt for a merged result is never added beside a signed edit: detectFork stops at a
+  // current text that has a receipt, and that must not hide a real fork.
+  function signPublished(relPath, roomBefore, published, authored = published) {
+    if (!PROVENANCE || !identity || published == null || published === roomBefore) return
+    const fe = fileDocs.get(relPath); if (!fe || !fe.ledger) return
+    const hp = contentHash(published), ha = authored == null ? null : contentHash(authored)
+    const rc = fe.ledger.toArray()
+    if (rc.some((r) => r && (r.contentHash === hp || (ha && r.author === identity.id && r.contentHash === ha)))) return
+    stampIntent(relPath, roomBefore == null ? '' : roomBefore, published)
+  }
   function attestHead(relPath, landed, base) {
     if (!PROVENANCE || !identity || landed == null) return
     const fe = fileDocs.get(relPath); if (!fe || !fe.head) return
@@ -940,7 +827,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
       // Carry each side's SIGNED intent into the announcement: the WHY is what lets any
       // agent in the room reconcile the fork (via hive_resolve) instead of picking a winner.
       const why = rec.versions.map((v) => `${v.name}: "${versionIntent(fe, rec, v.hash) || 'no stated intent'}"`).join(' | ')
-      try { say(`⚠ SILENT FORK in ${relPath}: ${who} changed the same region concurrently. Signed intents — ${why}. Surfaced ALL ${rec.versions.length} versions with <<<<<<< markers. ANY agent may reconcile BOTH intents: call hive_resolve with the full resolved file — it is validated (parses, no dangling refs) before it lands.`) } catch { }
+      try { postOnce(`fork:${relPath}:${contentHash(rec.versions.map((v) => v.hash).sort().join(',')).slice(0, 16)}`, `⚠ SILENT FORK in ${relPath}: ${who} changed the same region concurrently. Signed intents — ${why}. Surfaced ALL ${rec.versions.length} versions with <<<<<<< markers. ANY agent may reconcile BOTH intents: call hive_resolve with the full resolved file — it is validated (parses, no dangling refs) before it lands.`, { observer: true }) } catch { }
     }
   }
   // A resolution landed elsewhere: the shared text is clean again. Adopt it to disk.
@@ -1052,6 +939,11 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     if (!canWrite(relPath)) return { error: `${relPath} is read-only for you` }
     if (intent) myIntents.set(relPath, String(intent)) // my declared WHY — what my receipt will sign
     const full = path.join(ROOT, relPath)
+    // Written before this file synced: remember what it replaced, the edit's real ancestor (P0-1b).
+    // The OLDEST text this folder had since the file started waiting (diskAtOpen) when there is one: an
+    // earlier edit with the agent's own file tool sits between it and this write, and the room can only
+    // have held the older text (0.14.3 P0-1b-R3).
+    { const fe0 = fileDocs.get(relPath); if (!(fe0 && fe0.synced) && !preSyncBase.has(relPath)) { try { preSyncBase.set(relPath, fe0 && typeof fe0.diskAtOpen === 'string' ? fe0.diskAtOpen : readDiskText(full)) } catch { } } }
     // An authored write keeps this disk's ending for the file, like every engine write (readText).
     try { fs.mkdirSync(path.dirname(full), { recursive: true }); fs.writeFileSync(full, crlfSet().has(relPath) ? toLF(content).replace(/\n/g, '\r\n') : content) }
     catch (e) { return { error: 'write failed: ' + e.message } }
@@ -1061,7 +953,9 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     if (FORK_GATE) captureLocal(relPath)
     reconcile(relPath, 'local')
     const fe = fileDocs.get(relPath)
-    const landed = fe && fe.synced ? fe.text.toString() : content
+    // The room's copy is known only once the file synced; before that, say nothing about it rather
+    // than echo the content back as if it had landed (0.14.3 P0-1). hive_edit asks whenSent().
+    const landed = fe && fe.synced ? fe.text.toString() : null
     let disk = content; try { disk = readDiskText(full) } catch { }
     // A new file's doc has not synced yet when this returns, so the gate in reconcile has not run:
     // judge the content here too, or the answer would be "syncing to every peer" for a file that
@@ -1231,7 +1125,8 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
   // to everybody; this is what lets a join tell another agent with the same name (refused, see
   // sameNameElsewhere) from this agent a moment ago, restarting in the same folder (allowed).
   const IID = crypto.createHash('sha256').update(`${os.hostname()}|${ROOT}`).digest('hex').slice(0, 12)
-  provider.awareness.setLocalStateField('user', { name, kind, owner: owner || undefined, v: PROTOCOL_VERSION, hv: VERSION_LABEL, passive: !!passive, listener: listener || undefined, app: app || undefined, iid: IID }) // identity is implicit in the client
+  const joinedAt = Date.now()
+  provider.awareness.setLocalStateField('user', { name, kind, owner: owner || undefined, v: PROTOCOL_VERSION, hv: VERSION_LABEL, passive: !!passive, listener: listener || undefined, app: app || undefined, iid: IID, joined: joinedAt }) // identity is implicit in the client
 
   // ---- relay reachability, said out loud exactly once -------------------------------
   // y-websocket retries forever and silently. That is the right RECOVERY behaviour and
@@ -1333,6 +1228,14 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
   // "not pulled yet", NOT "new file", so we must not re-seed it from disk (that
   // would create a second CRDT history and duplicate/garble content on rejoin).
   const fileDocs = new Map() // relPath -> { doc, provider, text, synced }
+  // EDITS NOT YET ACCEPTED BY THE RELAY (0.14.3 P0-1). A file enters on any local change to its doc
+  // and leaves once its channel is connected, synced and its socket holds no unsent bytes. Synced
+  // means the sync exchange ran after the change (it carries anything the socket missed), so
+  // "connected + synced + nothing buffered" is "the relay has it". Over HTTPS long-poll the bytes sit
+  // in the client until the relay accepts them; an agent that left in that window lost the edit while
+  // hive_edit said it was syncing (8-9 Nov mock run). leave() waits on this set, hive_edit reports it,
+  // and eviction never closes a file that is still in it.
+  const unsentLocal = new Set()
 
   // REFUSED FILE-ROOMS. y-websocket retries a failed upgrade forever, with backoff and in
   // silence. That is right for a flaky network and badly wrong for a relay that is full: on
@@ -1405,7 +1308,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
               `Do not trust this folder's contents meanwhile.`,
           })).text
       log(`[${name}] !! ${msg}`)
-      try { say(`[!] @all ${msg}`) } catch { /* chat may itself be unreachable — the log still carries it */ }
+      try { postOnce(`notsyncing:${code || 'stuck'}`, `[!] @all ${msg}`, { observer: true, ttlMs: 10 * 60 * 1000 }) } catch { /* chat may itself be unreachable — the log still carries it */ }
     }, 4000)
     if (refusalTimer.unref) refusalTimer.unref()
   }
@@ -1524,8 +1427,15 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     // each peer's DISK — never into the shared text — so conflict markers can't fuse.
     const conflict = fdoc.getMap('conflict')
     const undo = new Y.UndoManager(text, { captureTimeout: 350 }) // default tracks local-origin txns
-    e = { doc: fdoc, provider: fprovider, text, bin, snap, ledger, head, versions, forkmark, conflict, undo, synced: false }
+    // diskAtOpen: this folder's copy when the file started waiting for the room. An edit made before
+    // the file syncs -- through hive_edit OR the agent's own file tool -- was made on top of it, so it
+    // is that edit's ancestor at first contact, if the room held it (0.14.3 P0-1b-R3). Dropped once synced.
+    let diskAtOpen
+    try { const f0 = path.join(ROOT, relPath); if (fs.statSync(f0).size <= MAX_BYTES) diskAtOpen = readDiskText(f0) } catch { diskAtOpen = undefined }
+    e = { doc: fdoc, provider: fprovider, text, bin, snap, ledger, head, versions, forkmark, conflict, undo, synced: false, diskAtOpen }
     fileDocs.set(relPath, e)
+    // A local transaction is one this client made; a peer's arrives through applyUpdate (local false).
+    fdoc.on('update', (_u, _origin, _doc, txn) => { if (!txn || txn.local) unsentLocal.add(relPath) })
     // From the mtime scan() already took, not two more syscalls per open: a 1,000-file join opens
     // 1,000 files, and fileCreationTs() still falls back to a stat for any file this missed.
     if (!createdTimes.has(relPath) && mtimes.has(relPath)) createdTimes.set(relPath, mtimes.get(relPath))
@@ -1547,6 +1457,8 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
           reconcile(relPath, 'remote')
           detectFork(relPath)
         }
+        preSyncBase.delete(relPath) // used by the first reconcile or not at all, never by a later reopen (review R4)
+        e.diskAtOpen = undefined
         // A new file that has just landed on disk frees its place for the next one (a burst of new
         // files moves at sync speed, not at the 30 s grace), and lets waiting new files in.
         if (arrivedNew.has(relPath)) {
@@ -1584,6 +1496,88 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     scheduleEvictRecheck()
     return e
   }
+  // `await await f()` THAT NOBODY WROTE (0.14.3 P0-5-3). Two peers making the same sync -> async change
+  // at once each insert `await ` before the same call (each merge is right on its own), and the shared
+  // text keeps both inserts. Remove the outer one, here, before the room's copy reaches the disk:
+  // pure deletes of the spans lang.stackedAwaits finds (AST-level, whitespace-only between, so a
+  // comment or a string that says "await await" is never touched). On the same converged text every
+  // peer deletes the same characters, so two peers doing it at once remove them once. Never a
+  // whole-text diff: that would delete and re-insert everything between two such spots, and two
+  // peers re-inserting the same middle is the fusion this engine exists to prevent. Skipped when
+  // this folder's own copy has one (its author wrote it) and for a file this member cannot write.
+  function dropStackedAwaits(relPath, fe, disk) {
+    try {
+      if (!supports(relPath) || !canWrite(relPath)) return false
+      const lang = languageFor(relPath)
+      if (!lang || typeof lang.stackedAwaits !== 'function') return false
+      const t = fe.text.toString()
+      if (!/\bawait\s+await\b/.test(t)) return false
+      if (typeof disk === 'string' && /\bawait\s+await\b/.test(disk) && lang.stackedAwaits(disk).length) return false
+      const spans = lang.stackedAwaits(t)
+      if (!spans.length) return false
+      fe.doc.transact(() => { for (let i = spans.length - 1; i >= 0; i--) fe.text.delete(spans[i][0], spans[i][1] - spans[i][0]) })
+      log(`[${name}] ${relPath}: removed ${spans.length} stacked \`await\` left by two peers making the same change at once`)
+      return true
+    } catch { return false }
+  }
+  /** Has the relay accepted every local change to this file? (See unsentLocal.) */
+  function isSentNow(relPath) {
+    if (!unsentLocal.has(relPath)) return true
+    const fe = fileDocs.get(relPath)
+    if (!fe) return false
+    const p = fe.provider
+    if (!(p && p.wsconnected && p.synced && !(p.bufferedAmount > 0))) return false
+    // Delivered is not enough: the room must HOLD what this folder has. On first contact a local edit
+    // the room cannot prove it has seen is kept here and deliberately NOT published (and a refused
+    // fused merge publishes nothing); calling that "sent" told an agent its work was in the room when
+    // the room still had the old copy. A deleted file, or one this side cannot read as text, is judged
+    // on delivery alone.
+    // A BINARY file's content is in fe.bin, not fe.text (which is "" for it): compared as text it never
+    // matched, so a binary this member added was never "sent" -- leave() waited its full timeout and
+    // named it as lost, and eviction never closed it (Opus-Cloud's review of 0.14.3). The room holds
+    // what this folder has when the bytes' sha256 is the one the room records, as reconcileBinary writes it.
+    if (fe.bin && fe.bin.has('data')) {
+      let bytes = null
+      try { bytes = fs.readFileSync(path.join(ROOT, relPath)) } catch { }
+      if (bytes && crypto.createHash('sha256').update(bytes).digest('hex') !== fe.bin.get('sha')) return false
+      unsentLocal.delete(relPath)
+      return true
+    }
+    let disk = null
+    try { disk = readDiskText(path.join(ROOT, relPath)) } catch { }
+    if (disk != null && !hasConflictMarkers(disk) && toLF(disk) !== toLF(fe.text.toString())) return false
+    unsentLocal.delete(relPath)
+    return true
+  }
+  /** Resolves true once the relay has this file's local changes, false if not within timeoutMs. */
+  async function whenSent(relPath, timeoutMs = 3000) {
+    relPath = String(relPath || '').replace(/\\/g, '/')
+    const end = Date.now() + Math.max(0, Number(timeoutMs) || 0)
+    for (;;) {
+      if (isSentNow(relPath)) return true
+      if (stopped || Date.now() >= end) return false
+      await new Promise((r) => setTimeout(r, 50))
+    }
+  }
+  const roomBuffered = () => { try { return (provider.ws && provider.ws.bufferedAmount) || 0 } catch { return 0 } }
+  // LEAVE WITHOUT LOSING WHAT WAS JUST WRITTEN. stop() tears everything down at once; leave() first
+  // hands the pending work over (debounced disk edits, deletes, the room doc), waits until the relay
+  // has accepted every local change -- files and chat/claims alike -- and only then stops. Whatever
+  // did not make it within timeoutMs is NAMED in the answer instead of vanishing (0.14.3 P0-1).
+  async function leave({ timeoutMs = 10000 } = {}) {
+    if (stopped) return { unsent: [], roomUnsent: false }
+    try { if (debounce) { clearTimeout(debounce); flushFsEvents() } } catch { }
+    try { flushFirstContact() } catch { }
+    try { settleLocalDeletes() } catch { }
+    try { flushRoomDoc() } catch { }
+    const end = Date.now() + Math.max(0, Number(timeoutMs) || 0)
+    const pendingNow = () => [...unsentLocal].filter((r) => !isSentNow(r))
+    while (Date.now() < end && (pendingNow().length || roomBuffered() > 0)) await new Promise((r) => setTimeout(r, 50))
+    const unsent = pendingNow()
+    const roomUnsent = roomBuffered() > 0
+    stopAll()
+    return { unsent, roomUnsent }
+  }
   function closeFile(relPath) {
     const e = fileDocs.get(relPath)
     if (!e) return
@@ -1675,6 +1669,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     const cand = []
     for (const [r, e] of fileDocs) {
       if (r === keep || !e.synced) continue
+      if (!isSentNow(r)) continue // closing it would drop an edit the relay has not accepted yet
       if (conflicted.has(r)) continue
       try { if (e.conflict && e.conflict.size) continue } catch { }
       if (isClaimed(r)) continue
@@ -1705,6 +1700,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     const cand = []
     for (const [r, e] of fileDocs) {
       if (conflicted.has(r) || isClaimed(r)) continue
+      if (unsentLocal.has(r)) continue // a local edit the relay has not accepted: closing it loses work
       try { if (e.conflict && e.conflict.size) continue } catch { }
       cand.push([r, touched.get(r) || 0])
     }
@@ -1877,6 +1873,9 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
   // merge. Keyed by room — the same folder rejoined against a different room must not
   // inherit an ancestor from unrelated history.
   const priorShadow = new Map()
+  // relPath -> the disk text an authored write (editFile) replaced while the file had not synced yet:
+  // that write's true ancestor, used by first contact (0.14.3 P0-1b).
+  const preSyncBase = new Map()
   const bases = new Map()      // last synced content per file (advances on every reconcile)
   const forkBases = new Map()  // FORK POINT: what THIS author last saw/authored per file.
   // forkBases advances only on local authorship / first adoption — NOT when a
@@ -2076,6 +2075,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
   const fold = (r) => isCaseInsensitive ? r.toLowerCase() : r
 
   const canonicalCaseKeys = new Map() // fold(r) -> canonical relPath
+  const recentlyLocallyRemovedCase = new Map() // fold(r) -> { path: r, at: Date.now() }
   const collided = new Map()          // collided relPath -> { with: canonical relPath }
   const collidedWarned = new Set()    // relPath announced to room
   const collidedTimers = new Map()    // relPath -> Timeout (debounced room announcement)
@@ -2224,7 +2224,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
           if (keptAs) {
             log(`[${name}] local unshared file ${relPath} overwritten by room write; copy preserved in ${keptAs}`)
             try {
-              say(`· ${relPath} on ${name}'s disk was ${unshared.reason} and was overwritten by a room write — local copy preserved in ${keptAs}.`)
+              note(`· ${relPath} on ${name}'s disk was ${unshared.reason} and was overwritten by a room write — local copy preserved in ${keptAs}.`)
             } catch { }
           }
         }
@@ -2382,10 +2382,13 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     if (kept.length) {
       const one = kept.length === 1
       parts.push(`${one ? '1 holds' : `${kept.length} hold`} content the room has never seen, so neither copy was changed and the room's copy was NOT adopted: ${names(kept)}. ` +
-        `In ${name}'s folder ${one ? 'it still holds' : 'they still hold'} ${name}'s version. To make one the room's version, claim it and hive_edit it with the full file. ` +
+        `In ${name}'s folder ${one ? 'it still holds' : 'they still hold'} ${name}'s version, and nothing syncs for ${one ? 'it' : 'them'} until ${name} saves ${one ? 'it' : 'them'} again. To make one the room's version, claim it and hive_edit it with the full file. ` +
         `Don't delete a local copy to get the room's: a deletion syncs, and removes the file for everyone.`)
     }
-    try { say(parts.join(' ')) } catch { }
+    // What concerns THIS folder only (line endings, older copies it now has) is a note for hive_status; only
+    // content the room has never seen is the room's business, because nobody else has it (0.14.4, C5).
+    note(parts.join(' '))
+    if (kept.length) { try { say([parts[0], parts[parts.length - 1]].join(' ')) } catch { } } // the kept part is pushed last
   }
 
   function reconcileBinary(relPath, origin = 'local') {
@@ -2489,7 +2492,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
       if (keptAs) {
         log(`[${name}] local binary ${relPath} overwritten by remote write (winner: ${remoteBy || 'teammate'}); copy preserved in ${keptAs}`)
         try {
-          say(`· ${relPath} updated from room (winner: ${remoteBy || 'teammate'}). Your local copy saved to ${keptAs}.`)
+          note(`· ${relPath} updated from room (winner: ${remoteBy || 'teammate'}). Your local copy saved to ${keptAs}.`)
         } catch { }
       }
     }
@@ -2555,8 +2558,10 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     // (duplicated/garbled content on rejoin). So: open if needed, then defer until
     // the 'sync' handler re-runs us. Once synced, "" genuinely means empty.
     fe = fileDocs.get(relPath)
-    if (!fe) { if (disk === null) return; openFile(relPath); return }
-    if (!fe.synced) return
+    // A local change waiting for its file to sync is an unsent edit too: the sync handler sends it,
+    // and until then leave() must wait for it (0.14.3 P0-1: a new file written just before leaving).
+    if (!fe) { if (disk === null) return; openFile(relPath); if (origin === 'local') unsentLocal.add(relPath); return }
+    if (!fe.synced) { if (origin === 'local' && disk !== null) unsentLocal.add(relPath); return }
     // A KEPT UNSENT EDIT IS FROZEN until its author saves the file again. Merging it against the
     // room in either direction would decide something nobody decided: the room's next change would
     // be written over it, and an unchanged save merged against itself pulled the room's old copy over
@@ -2632,6 +2637,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
       // clean again -> a resolution landed elsewhere; adopt it (order-independent w/ observer).
       if (disk !== null && hasConflictMarkers(disk) && !hasConflictMarkers(fe.text.toString())) { adoptResolved(relPath); return }
     }
+    dropStackedAwaits(relPath, fe, disk) // before anything reads the room's copy (0.14.3 P0-5-3)
     const docText = fe.text.toString()
     // An empty shared doc is authoritative ONLY if we have history for this path.
     // A file's NAME lives in the parent doc and its CONTENT in the file's own doc, on two
@@ -2675,6 +2681,14 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     }
     if (disk === docText) {
       ensureExactDiskCasing(relPath)
+      if (!inManifest(relPath) && origin === 'local') {
+        const key = fold(relPath)
+        const prevCase = recentlyLocallyRemovedCase.get(key)
+        if (prevCase && (Date.now() - prevCase.at < 60000)) {
+          recentlyLocallyRemovedCase.delete(key)
+          queueManifestSet(relPath)
+        }
+      }
       // CREATING a file is editing it. This branch is where a locally-authored NEW file
       // lands: scan() finds it, openFile() syncs the content up, and by the time reconcile
       // runs disk and doc already agree -- so it returns below, before the markEditing() at
@@ -2806,12 +2820,12 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
             return
           }
         }
-        if (r0.text !== docText) fe.doc.transact(() => applyDiff(yt, r0.text))
+        if (r0.text !== docText) { fe.doc.transact(() => applyDiff(yt, r0.text)); signPublished(relPath, docText, r0.text, disk) }
         if (r0.text !== disk) writeToDisk(relPath, r0.text)
         if (r0.conflict) conflicted.add(relPath)
         bases.set(relPath, r0.text); forkBases.set(relPath, r0.text); shadow.set(relPath, r0.text)
         if (!inManifest(relPath)) queueManifestSet(relPath)
-        try { say(`⚠ ${relPath} was created by two participants at once — both versions were merged${r0.conflict ? ', and CONFLICT markers need resolving' : ''}.`) } catch { }
+        try { postOnce(`race:${relPath}`, `⚠ ${relPath} was created by two participants at once — both versions were merged${r0.conflict ? ', and CONFLICT markers need resolving' : ''}.`, { ttlMs: 10 * 60 * 1000 }) } catch { }
         return
       }
       // REJOIN, NOT A FIRST JOIN. If a previous session of this client wrote this file in
@@ -2819,6 +2833,26 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
       // local copy may be newer than the room's (edited while disconnected, or the room
       // came back stale). This is the data-loss case that was seen live.
       let anc = priorShadow.get(relPath)
+      // An edit THIS session made through the medium before the file had synced has a known ancestor:
+      // the disk text it replaced (0.14.3 P0-1b). Without it, a fresh folder's first contact had no
+      // ancestor, refused to publish the edit, and a later merge wrote the room's copy back over it.
+      // ONLY when the room held that text (Claude-cloud's review R1): a folder carrying a local change L
+      // the room never saw, edited before sync, would otherwise merge with ancestor L, read the room as
+      // "removed L", and delete L from disk and room. Not proven held -> no ancestor -> the frozen keep.
+      let preSync = false
+      // An edit made with the agent's OWN file tool before the file synced left no record (only hive_edit
+      // writes one), so first contact had no ancestor and froze it as a kept, unsent edit (P0-1b-R3).
+      // What the disk held when the file opened is that ancestor, under the same rule: only if the room
+      // provably held it.
+      if (anc === undefined && !preSyncBase.has(relPath) && typeof fe.diskAtOpen === 'string' && disk !== null && fe.diskAtOpen !== disk) {
+        preSyncBase.set(relPath, fe.diskAtOpen)
+      }
+      if (anc === undefined && preSyncBase.has(relPath)) {
+        const pre = preSyncBase.get(relPath)
+        const held = accountFor({ rel: relPath, branchText: pre, roomText: docText, receipts: fe.ledger ? fe.ledger.toArray() : [] }).state
+        if (held === DESCENDS || held === IDENTICAL) { anc = pre; preSync = true }
+      }
+      preSyncBase.delete(relPath)
       // ...unless the room never got it. Capturing a local edit moves the ancestor to the edited
       // bytes BEFORE the relay accepts them. A write held behind someone else's claim
       // (HIVE_ENFORCE_CLAIMS=queue) is discarded when its writer disconnects, so on rejoin
@@ -2855,7 +2889,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
         // the local side first so the pre-merge bytes are recoverable regardless of outcome.
         captureSnapshot(relPath, disk, name, { force: true, kind: 'manual', label: 'local copy before rejoin merge' })
         const rj = icrMerge3(anc, disk, docText, relPath)
-        if (rj.text !== docText) fe.doc.transact(() => applyDiff(yt, rj.text))
+        if (rj.text !== docText) { fe.doc.transact(() => applyDiff(yt, rj.text)); signPublished(relPath, docText, rj.text, disk) }
         if (rj.text !== disk) writeToDisk(relPath, rj.text)
         if (rj.conflict) conflicted.add(relPath)
         bases.set(relPath, rj.text); forkBases.set(relPath, rj.text); shadow.set(relPath, rj.text)
@@ -2864,7 +2898,9 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
           say(unsent
             ? `⚠ ${relPath}: ${name}'s last edit never reached the room — it was held while someone else had the file, and ${name}'s connection dropped. ` +
               `It has been sent again, merged with the room's copy${rj.conflict ? ', and CONFLICT markers need resolving' : ''}; if the file is still claimed, it waits for the release. Pre-merge local copy is in the file's history.`
-            : `⚠ ${relPath} changed locally while ${name} was disconnected — the local edit and the room copy were merged${rj.conflict ? ', and CONFLICT markers need resolving' : ''}. Pre-merge local copy is in the file's history.`)
+            : preSync
+              ? `${relPath}: ${name} edited it before the room's copy had loaded here — the edit was merged with the room's copy and sent${rj.conflict ? ', and CONFLICT markers need resolving' : ''}. Pre-merge local copy is in the file's history.`
+              : `⚠ ${relPath} changed locally while ${name} was disconnected — the local edit and the room copy were merged${rj.conflict ? ', and CONFLICT markers need resolving' : ''}. Pre-merge local copy is in the file's history.`)
         } catch { }
         return
       }
@@ -2891,7 +2927,20 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
       // Refuse adoption: keep local disk untouched, keep room doc untouched, snapshot local, and announce loudly.
       captureSnapshot(relPath, disk, name, { force: true, kind: 'manual', label: `local copy preserved at join (${st.state}: room copy refused)` })
       bases.set(relPath, disk); forkBases.set(relPath, disk)
-      log(`[${name}] ⚠ ${relPath} already existed in room with different content (${st.state}) — room copy was NOT adopted; local disk preserved`)
+      // FROZEN, not merely kept (0.14.3 P0-1b). With bases = the local copy and nothing else, the NEXT
+      // reconcile of this file (the watcher seeing the agent's own write, the scan, any remote change)
+      // merged (base local, ours local, theirs room) = the room's copy, wrote it over the local edit
+      // and told the room "kept the changes that landed in between (nothing lost)": the edit was gone
+      // from the room AND the disk (5 of 8 poll runs on 0.14.2, tests/diag/presync-edit-race.mjs;
+      // traced by Claude-cloud). Frozen like a kept unsent edit: nothing syncs for this file until its
+      // author saves it again, and that save replaces the room's copy. The worst case is now "kept,
+      // and said", never "lost".
+      let keptAt = 0; try { keptAt = fs.statSync(full).mtimeMs } catch { }
+      keptUnsent.set(relPath, keptAt)
+      // Said in the room (review R5: the agent has to act on it), but ONCE PER JOIN, in the first-contact
+      // summary below -- not one line per file in engine words. A teammate rejoining with 40 such files
+      // filled the chat with 40 lines (9 Nov 2026; first-contact-summary-test, red since 0.14.3).
+      log(`[${name}] ⚠ ${relPath} already existed in room with different content (${st.state}) — room copy was NOT adopted; local disk preserved and frozen until saved again`)
       noteFirstContact('kept', relPath)
       return
     }
@@ -2982,7 +3031,13 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
         res = { text: disk, conflict: false } // author built on the latest or cleanly rewrote — trust it
       } else {
         res = icrMerge3(fork, disk, docText, relPath)
-        reAdded = !res.conflict && res.text !== disk // we restored remote lines a stale write had dropped
+        reAdded = !res.conflict && res.text !== disk && res.text !== docText // we restored remote lines a stale write had dropped
+        // ...and when the merge gives back exactly the room's copy, the local edit did NOT survive:
+        // never call that "nothing lost" (review R2). Keep the local copy and say so.
+        if (!res.conflict && res.text === docText && disk !== docText) {
+          captureSnapshot(relPath, disk, name, { force: true, kind: 'manual', label: 'local copy replaced by the room\'s copy in a merge' })
+          try { say(`⚠ ${relPath}: ${name}'s local change did not survive the merge with the room's copy (the room's version was taken). ${name}'s copy is in the file's history.`) } catch { }
+        }
         // OPEN (1 Nov 2026): a clean handover onto the same lines still shows markers. Four rounds of
         // rules that decided it from the texts (a claim-time fork, who-holds-it, line counts, shared
         // tokens) each silently deleted someone's work in a case antigravity-3 then built: from the
@@ -3055,7 +3110,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
       // Gate ON: the author's INTENT was already captured at the source (captureLocal, top
       // of this pass) — here we only advance the authority head to the landed content.
       // Gate OFF (default): the proven landed-transition stamp, unchanged.
-      if (FORK_GATE) { if (res.text !== docText) attestHead(relPath, res.text, docText) }
+      if (FORK_GATE) { if (res.text !== docText) { signPublished(relPath, docText, res.text, disk); attestHead(relPath, res.text, docText) } }
       else if (res.text !== docText) stampProvenance(relPath, docText, res.text)
     }
     if (res.text !== disk) writeToDisk(relPath, res.text)
@@ -3068,10 +3123,10 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     if (hasMarkers && !conflicted.has(relPath)) {
       conflicted.add(relPath)
       log(`[${name}] ⚠ merge conflict in ${relPath} — kept BOTH versions with <<<<<<< markers`)
-      try { say(`⚠ MERGE CONFLICT in ${relPath} — it has <<<<<<< markers. Whoever owns it: resolve before continuing, by saving the file without them or by passing the marked block as old to hive_edit old/new.`) } catch { }
+      try { postOnce(`conflict:${relPath}`, `⚠ MERGE CONFLICT in ${relPath} — it has <<<<<<< markers. Whoever owns it: resolve before continuing, by saving the file without them or by passing the marked block as old to hive_edit old/new.`, { observer: !res.conflict, clear: `resolved:${relPath}` }) } catch { }
     } else if (!hasMarkers && conflicted.has(relPath)) {
       conflicted.delete(relPath)
-      try { say(`✓ conflict in ${relPath} resolved.`) } catch { }
+      try { postOnce(`resolved:${relPath}`, `✓ conflict in ${relPath} resolved.`, { observer: origin !== 'local', clear: `conflict:${relPath}` }) } catch { }
     } else if (reAdded) {
       log(`[${name}] protected ${relPath}: your edit was based on an older version — re-added changes that arrived since (nobody's work lost)`)
       try { say(`↺ ${relPath}: ${name}'s edit was based on an older copy — kept the changes that landed in between (nothing lost).`) } catch { }
@@ -3089,7 +3144,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     if (res.icrWarning && icrWarned.get(relPath) !== res.icrWarning) {
       icrWarned.set(relPath, res.icrWarning)
       log(`[${name}] ⚠ ICR flag in ${relPath} — ${res.icrWarning}`)
-      try { say(`⚠ ICR flag in ${relPath}: ${res.icrWarning}. It merged, but review — this is a break a plain merge can't see.`) } catch { }
+      try { postOnce(`icr:${relPath}:${contentHash(String(res.icrWarning)).slice(0, 16)}`, `⚠ ICR flag in ${relPath}: ${res.icrWarning}. It merged, but review — this is a break a plain merge can't see.`, { observer: origin !== 'local' }) } catch { }
     } else if (!res.icrWarning && icrWarned.has(relPath)) {
       icrWarned.delete(relPath)
     }
@@ -3325,6 +3380,66 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     if (!text) return
     chat.push([{ by: name, kind, at: fmtTime(), text: String(text) }])
   }
+  // ONE LINE PER EVENT, NOT ONE PER OBSERVER (0.14.4, C5). Most system lines are said by whoever
+  // caused them (a task, a review, a revert): one poster by nature. But an OBSERVED event -- a conflict
+  // in a shared file, a client on another build, a divergence -- is detected by every peer's own code,
+  // and each posted it: one conflict gave four MERGE CONFLICT lines and then four "resolved" lines
+  // (incident I-16, #722-#725); one odd client gave a MIXED BUILDS line from every other (I-8, #822-#823).
+  // postOnce(id, text): `id` names the event the same way on every peer. The peer that caused it posts
+  // at once. An observer waits 1.5 s plus 1 s per rank among present engines (sorted by name) and posts
+  // only if nobody has; the key lives in the room (`sys_events`) and expires. A peer that cannot write
+  // the key still posts: a missed alarm hides a conflict, a duplicate is only noise.
+  const sysEvents = doc.getMap('sys_events')
+  const SYS_TTL_MS = 6 * 3600 * 1000
+  const sysTimers = new Set()
+  // What only THIS folder needs to know (a local copy kept, a file that differed at join) goes here, to
+  // the log and hive_status, and not to the whole room (C5).
+  const notices = []
+  function note(text) {
+    const t = String(text || '')
+    if (!t) return
+    log(`[${name}] ${t}`)
+    notices.push({ at: Date.now(), text: t })
+    if (notices.length > 50) notices.shift()
+  }
+  function sysRank() {
+    const names = new Set([name])
+    try {
+      for (const st of provider.awareness.getStates().values()) {
+        const u = st && st.user
+        if (u && u.name && !u.listener && !u.passive && u.v === PROTOCOL_VERSION) names.add(u.name)
+      }
+    } catch { }
+    return [...names].sort().indexOf(name)
+  }
+  function pruneSysEvents(now) {
+    let n = 0
+    for (const [k, v] of sysEvents.entries()) {
+      if (++n > 500) break
+      if (!v || now - (Number(v.at) || 0) > (Number(v.ttl) || SYS_TTL_MS)) sysEvents.delete(k)
+    }
+  }
+  function postOnce(id, text, { observer = false, ttlMs = SYS_TTL_MS, clear = null } = {}) {
+    if (!text) return null
+    if (observer && (passive || listener)) return null // a client nobody waits on never speaks for the room
+    const fire = () => {
+      try {
+        const prev = sysEvents.get(id)
+        if (prev && Date.now() - (Number(prev.at) || 0) < (Number(prev.ttl) || SYS_TTL_MS)) return false
+        doc.transact(() => {
+          sysEvents.set(id, { by: name, at: Date.now(), ttl: ttlMs })
+          if (clear) for (const c of [].concat(clear)) sysEvents.delete(c)
+          pruneSysEvents(Date.now())
+        })
+      } catch { /* fail open: the line is said even if the key could not be written */ }
+      say(text)
+      return true
+    }
+    if (!observer) return fire()
+    const t = setTimeout(() => { sysTimers.delete(t); if (!stopped) { try { fire() } catch { } } }, 1500 + 1000 * Math.max(0, sysRank()))
+    sysTimers.add(t)
+    return null
+  }
   function renderChat() {
     const out = [
       '# Hive Chat — the live coordination channel for everyone in this room.',
@@ -3644,7 +3759,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
   let myEditing = null, myLastEdit = null
   let editingClearTimer = null
   const warnedAt = new Map() // file -> last time we warned about co-editing it
-  const setUserState = () => provider.awareness.setLocalStateField('user', { name, kind, owner: owner || undefined, editing: myEditing || undefined, lastEdit: myLastEdit || undefined, v: PROTOCOL_VERSION, hv: VERSION_LABEL, passive: !!passive, listener: listener || undefined, app: app || undefined, iid: IID })
+  const setUserState = () => provider.awareness.setLocalStateField('user', { name, kind, owner: owner || undefined, editing: myEditing || undefined, lastEdit: myLastEdit || undefined, v: PROTOCOL_VERSION, hv: VERSION_LABEL, passive: !!passive, listener: listener || undefined, app: app || undefined, iid: IID, joined: joinedAt })
   function markEditing(relPath) {
     myEditing = { file: relPath, at: Date.now() }
     myLastEdit = myEditing
@@ -3672,7 +3787,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     const now = Date.now()
     if (others.length && now - (warnedAt.get(relPath) || 0) > 30000) {
       warnedAt.set(relPath, now)
-      try { say(`⚠ heads-up: ${name} is also editing ${relPath} (with ${others.join(', ')}). Small patches auto-merge; coordinate before a full rewrite.`) } catch { }
+      try { postOnce(`coedit:${relPath}:${[name, ...others].sort().join(',')}`, `⚠ heads-up: ${name} is also editing ${relPath} (with ${others.join(', ')}). Small patches auto-merge; coordinate before a full rewrite.`, { ttlMs: 10 * 60 * 1000 }) } catch { } // the one who just started editing is the cause: it says it at once
     }
   }
   function memberList() {
@@ -3741,7 +3856,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
       versionWarned.add(u.name)
       const theirs = u.v ? `v${u.v}` : 'an older build'
       log(`[${name}] ⚠ ${u.name} is on ${theirs} (incompatible with v${PROTOCOL_VERSION}) — they won't sync correctly until everyone updates.`)
-      try { say(`⚠ ${u.name} is on an incompatible version — files won't sync with them until everyone updates Hivecode.`) } catch { }
+      try { postOnce(`proto:${u.name}:${u.v || '-'}`, `⚠ ${u.name} is on an incompatible version — files won't sync with them until everyone updates Hivecode.`, { observer: true }) } catch { }
     }
     checkBuilds()
   }
@@ -3755,30 +3870,69 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
   //   - humans are not flagged: the extension and the browser panel carry no engine build
   //   - one side of each pair speaks (the name that sorts first), once per build it sees
   const buildWarned = new Set()
+  // ONE ALARM PER ROOM, AND ONLY FOR ANOTHER RELEASE (0.14.4, C5). The rule used to be "one side of
+  // each pair speaks", which is still one line per PAIR: two clients on 0.14.2 each posted about the one
+  // on 0.14.3 (#822 + #823), and a client on the same release from another commit raised the same alarm
+  // (I-8). Now the event is the set of releases in the room: it is said once, by whoever sees it first,
+  // naming who runs what. The same release from another commit is a note for this folder (hive_status).
   function checkBuilds() {
-    // An old engine cannot speak for itself, so SOMEBODY current must -- but only one: the reporting
-    // client whose name sorts first. Otherwise every current client in the room says the same thing.
-    const reporters = [name]
-    for (const s of provider.awareness.getStates().values()) { const u = s && s.user; if (u && u.name && u.hv) reporters.push(u.name) }
-    const speakForOld = reporters.sort()[0] === name
-    for (const s of provider.awareness.getStates().values()) {
-      const u = s && s.user
-      if (!u || !u.name || u.name === name || u.v !== PROTOCOL_VERSION) continue
-      const human = String(u.kind || '').toLowerCase() === 'human'
-      let theirs = ''
-      if (u.hv) {
-        if (u.hv === VERSION_LABEL || name > u.name) continue
-        theirs = `hivecode ${u.hv}`
-      } else if (!human) {
-        if (!speakForOld) continue
-        theirs = `a hivecode build older than build reporting (before ${VERSION})`
-      } else continue
-      const key = `${u.name}|${u.hv || '-'}`
-      if (buildWarned.has(key)) continue
-      buildWarned.add(key)
-      const same = u.hv && u.hv.split('+')[0] === VERSION ? ' (the same release from different commits)' : ''
-      log(`[${name}] ⚠ MIXED BUILDS: ${u.name} runs ${theirs}, this client runs ${VERSION_LABEL}${same}`)
-      try { say(`⚠ MIXED BUILDS: ${u.name} runs ${theirs}, ${name} runs hivecode ${VERSION_LABEL}${same}. Two builds in one room can lose file content with no error on either side -- everyone should run the same build.`) } catch { }
+    // Per CONNECTION, not per name: one participant with two engines open on different builds is its own
+    // alarm (0.14.3 Q-2: "an older connection is still open"), and a map keyed by name would hide it.
+    const labelsOf = new Map() // name -> Set of what its engines run
+    const add = (n, label) => { if (!labelsOf.has(n)) labelsOf.set(n, new Set()); labelsOf.get(n).add(label) }
+    add(name, VERSION_LABEL)
+    for (const st of provider.awareness.getStates().values()) {
+      const u = st && st.user
+      if (!u || !u.name || u.name === name || u.v !== PROTOCOL_VERSION || u.listener) continue
+      if (u.hv) add(u.name, String(u.hv))
+      // An AI on this protocol reporting no build is an engine older than build reporting: the rollout
+      // case, and it cannot warn itself. Humans carry no engine build (the extension, the browser panel).
+      else if (String(u.kind || '').toLowerCase() !== 'human') add(u.name, `a build older than build reporting (before ${VERSION})`)
+    }
+    const older = (label) => /^a build older/.test(label)
+    const releaseOf = (label) => (older(label) ? label : String(label).split('+')[0])
+    const on = (label) => (older(label) ? `on ${label}` : `on hivecode ${label}`)
+    // The same release from another commit: a note for this folder, not a room alarm.
+    for (const [n, labels] of labelsOf) {
+      if (n === name) continue
+      for (const label of labels) {
+        if (label === VERSION_LABEL || releaseOf(label) !== VERSION) continue
+        const key = `note|${n}|${label}`
+        if (buildWarned.has(key)) continue
+        buildWarned.add(key)
+        note(`${n} runs hivecode ${label}: the same release as this client (${VERSION_LABEL}), from another commit.`)
+      }
+    }
+    // One name, two engines on different builds: they write over each other's files.
+    for (const [n, labels] of labelsOf) {
+      if (n === name || labels.size < 2) continue
+      const all = [...labels].sort()
+      const id = `dual:${n}:${all.join('|')}`
+      if (buildWarned.has(id)) continue
+      buildWarned.add(id)
+      log(`[${name}] ⚠ MIXED BUILDS: ${n} has engines ${all.map(on).join(' and ')}`)
+      try { postOnce(id, `⚠ MIXED BUILDS: ${n} has two engines open, ${all.map(on).join(' and ')} (an older connection from ${n} is still open). Two engines under one name can lose file content with no error on either side -- close the older one.`, { observer: true }) } catch { }
+    }
+    // An OLDER RELEASE in the room: one alarm per participant and build, for the whole room. The event
+    // is "X runs B, older than the newest release here": every observer sees the same newest release, so
+    // they name the same event, and presence churn (an agent's state re-published) never re-raises it.
+    const parts = (r) => (older(r) ? [-1] : String(r).split('.').map((x) => parseInt(x, 10) || 0))
+    const cmp = (a, b) => { const x = parts(a), y = parts(b); for (let k = 0; k < Math.max(x.length, y.length); k++) { const d = (x[k] || 0) - (y[k] || 0); if (d) return d } return 0 }
+    const releases = new Set()
+    for (const labels of labelsOf.values()) for (const label of labels) releases.add(releaseOf(label))
+    if (releases.size < 2) return
+    const newest = [...releases].sort(cmp).pop()
+    const current = []
+    for (const [n, labels] of labelsOf) for (const label of labels) if (releaseOf(label) === newest) current.push(`${n} ${on(label)}`)
+    for (const [n, labels] of labelsOf) {
+      for (const label of labels) {
+        if (releaseOf(label) === newest) continue
+        const id = `builds:${n}:${label}`
+        if (buildWarned.has(id)) continue
+        buildWarned.add(id)
+        log(`[${name}] ⚠ MIXED BUILDS: ${n} runs ${older(label) ? label : `hivecode ${label}`}`)
+        try { postOnce(id, `⚠ MIXED BUILDS: ${n} runs ${older(label) ? label : `hivecode ${label}`}, older than the room's newest release (${current.sort().join(', ')}). Two releases in one room can lose file content with no error on either side -- ${n} should update (npx -y hivecode-mcp@latest setup, then restart).`, { observer: true }) } catch { }
+      }
     }
   }
   if (syncFiles) provider.awareness.on('change', () => { renderMembers(); renderClaims(); checkVersions() })
@@ -3993,7 +4147,10 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     if (!send.length) return
     for (const r of send) queueManifestDelete(r)
     flushRoomDoc()
+    const now = Date.now()
+    for (const [k, v] of recentlyLocallyRemovedCase) { if (now - v.at > 60000) recentlyLocallyRemovedCase.delete(k) }
     for (const r of send) {
+      recentlyLocallyRemovedCase.set(fold(r), { path: r, at: now })
       closeFile(r); known.delete(r); mtimes.delete(r); bases.delete(r); forkBases.delete(r); shadow.delete(r)
       if (isCaseInsensitive) {
         const cf = fold(r)
@@ -4244,6 +4401,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
           }
         }
       }
+      recentlyLocallyRemovedCase.delete(fold(key))
       pendingManifestOps.delete(key)
       newRemote.delete(key); arrivedNew.delete(key) // deleted while new or queued: nothing to wait for
       closeFile(key)
@@ -4657,6 +4815,43 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     }
   }
 
+  function stopAll() {
+    try { flushFirstContact() } catch { } // before `stopped`: a join cut short still says what it kept
+    try { settleLocalDeletes() } catch { } // a delete made just before leaving still leaves, judged like any other
+    stopped = true
+    for (const t of sysTimers) clearTimeout(t)
+    sysTimers.clear()
+    try { flushRoomDoc() } catch { }
+    if (openTimer) { clearImmediate(openTimer); clearTimeout(openTimer); openTimer = null }
+    if (renderBoardTimer) { clearImmediate(renderBoardTimer); renderBoardTimer = null }
+    openQueue.length = 0
+    openQueueSet.clear()
+    if (scanTimer) clearTimeout(scanTimer)
+    if (debounce) { clearTimeout(debounce); debounce = null }
+    for (const tm of collidedTimers.values()) clearTimeout(tm)
+    collidedTimers.clear()
+    pendingFsEvents.clear()
+    pendingFsFullScan = false
+    if (editingClearTimer) clearTimeout(editingClearTimer)
+    try { watcher && watcher.close() } catch { }
+    // The shared socket first: closing it ends every channel at once on the relay, instead of
+    // one CLOSE frame per file down a socket that is about to go anyway.
+    try { fileTransport.stop() } catch { }
+    for (const r of [...fileDocs.keys()]) closeFile(r) // tear down every per-file provider
+    try { provider.awareness.setLocalState(null) } catch { } // announce departure now (don't wait for timeout)
+    try { provider.destroy() } catch { }
+    try { doc.destroy() } catch { }
+    // A room you have left should stop colouring what your agents recall.
+    if (memoryLinked && grmLink) try { grmLink.unlinkRoom(ROOT, log) } catch { }
+    // Last, so a crash anywhere above still frees the folder on the next run via the
+    // stale-PID path rather than leaving it locked.
+    try { releaseLock() } catch { }
+    // A final flush of the ancestor record. The debounced save may still be pending, and
+    // losing it would make the next join see no common ancestor -- the exact condition
+    // that produced the rejoin clobber.
+    try { if (shadowTimer) { clearTimeout(shadowTimer); shadowTimer = null } saveShadow() } catch { }
+  }
+
   return {
     doc,
     provider,
@@ -4710,6 +4905,11 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
         }
       }
       swarmState.set(key, val)
+      // The session that sets a gate has chosen to run that command, so its own machine approves it
+      // (0.14.4 S-1). Nobody else's does: a gate set here runs elsewhere only after that person approves.
+      if (key === GATE_CMD && String(val == null ? '' : val).trim()) {
+        try { writeApproval(room, String(val), `set by ${name} on this machine`, GATES_DIR) } catch { /* no approval, so it simply does not run here */ }
+      }
       say(`STATE TRANSITION: [${key}] is now [${val}]`)
     },
     getState: () => {
@@ -4839,7 +5039,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
           if (v.stuckLagging) return `${v.peer}:${v.bytes}b/${v.lines}L[STUCK:${v.stuckReason || 'not catching up'}]`
           return `${v.peer}:${v.bytes}b/${v.lines}L`
         }).join('  ')
-        say(`[!] DIVERGENCE on ${p} — peers hold DIFFERENT content: ${detail}. Nobody may write this path until it is reconciled; mark it path:${p}=POISONED if it cannot be.`)
+        postOnce(`diverge:${p}:${contentHash(detail).slice(0, 16)}`, `[!] DIVERGENCE on ${p} — peers hold DIFFERENT content: ${detail}. Nobody may write this path until it is reconciled; mark it path:${p}=POISONED if it cannot be.`)
       }
 
       return {
@@ -4872,6 +5072,8 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
       }
     },
     say,                 // post a coordination message
+    postOnce,            // a system line said once per event in the room, whoever sees it (0.14.4, C5)
+    notices: () => notices.slice(), // what only this folder needs to know (hive_status shows it)
     assign,              // direct a task at a participant (needs approval if target AI has an owner)
     decide,              // approve/deny a task (owner only, if set)
     complete,            // mark a task done
@@ -4933,6 +5135,17 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
         return { ok: true, gated: true, forced: true }
       }
 
+      // A COMMAND FROM THE ROOM IS DATA (0.14.4 S-1). It runs here only if this machine's person
+      // approved this exact command; otherwise the hand-back goes through UNCHECKED -- never refused,
+      // or setting a gate would be a way to stop everyone -- and that is recorded and said once.
+      const approvedBy = gateApproved({ room, cmd: g.cmd, dir: GATES_DIR })
+      if (!approvedBy) {
+        gateResults.set(`${r}|${name}`, { ...verdictRecord({ region: r, by: name, cmd: g.cmd, result: null }), skipped: 'not-approved' })
+        letGo()
+        const said = `${name}|${g.cmd}`
+        if (!gateSkipSaid.has(said)) { gateSkipSaid.add(said); try { say(notApprovedLine(name)) } catch { /* chat is not the point */ } }
+        return { ok: true, gated: false, gateSkipped: 'not-approved', code: GATE_NOT_APPROVED, cmd: g.cmd, message: notApprovedMessage({ region: r, cmd: g.cmd, dir: ROOT }) }
+      }
       const result = runGate({ cmd: g.cmd, cwd: ROOT, timeoutMs: g.timeoutMs })
       gateResults.set(`${r}|${name}`, verdictRecord({ region: r, by: name, cmd: g.cmd, result }))
       if (!result.ok) {
@@ -5013,7 +5226,19 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
         const u = s.user
         if (!u || !u.name) continue
         const prev = seen.get(u.name) || {}
-        seen.set(u.name, { ...prev, ...u, editing: u.editing || prev.editing, owner: u.owner || prev.owner, passive: !!(u.passive || prev.passive), listener: !!(u.listener || prev.listener) || undefined, app: u.app || prev.app || undefined })
+        const hv = (prev.hv === VERSION_LABEL || u.hv === VERSION_LABEL)
+          ? VERSION_LABEL
+          : ((prev.listener && !u.listener && u.hv) || (!prev.listener && u.listener && prev.hv) || u.hv || prev.hv)
+        seen.set(u.name, {
+          ...prev,
+          ...u,
+          hv,
+          editing: u.editing || prev.editing,
+          owner: u.owner || prev.owner,
+          passive: !!(u.passive || prev.passive),
+          listener: !!(u.listener || prev.listener) || undefined,
+          app: u.app || prev.app || undefined
+        })
       }
       return [...seen.values()]
     },
@@ -5034,7 +5259,7 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
         if (id === me || !u || !u.name || String(u.name).toLowerCase() !== lc) continue
         if (u.listener || u.iid === IID) continue
         if (kind === 'human' && u.kind === 'human') continue
-        out.push({ name: u.name, kind: u.kind, owner: u.owner, app: u.app })
+        out.push({ name: u.name, kind: u.kind, owner: u.owner, app: u.app, joined: u.joined, clientID: id })
       }
       return out
     },
@@ -5140,40 +5365,9 @@ export function startSync({ relay = 'ws://localhost:1234', room = 'default', dir
     connection: () => ({ connected: !!provider.wsconnected, connecting: !!provider.wsconnecting, ...(folderLost ? { folderLost: folderLost.message } : {}) }),
     _openTurns: () => openTurns,
     _scanCount: () => scanCount,
-    stop: () => {
-      try { flushFirstContact() } catch { } // before `stopped`: a join cut short still says what it kept
-      try { settleLocalDeletes() } catch { } // a delete made just before leaving still leaves, judged like any other
-      stopped = true
-      try { flushRoomDoc() } catch { }
-      if (openTimer) { clearImmediate(openTimer); clearTimeout(openTimer); openTimer = null }
-      if (renderBoardTimer) { clearImmediate(renderBoardTimer); renderBoardTimer = null }
-      openQueue.length = 0
-      openQueueSet.clear()
-      if (scanTimer) clearTimeout(scanTimer)
-      if (debounce) { clearTimeout(debounce); debounce = null }
-      for (const tm of collidedTimers.values()) clearTimeout(tm)
-      collidedTimers.clear()
-      pendingFsEvents.clear()
-      pendingFsFullScan = false
-      if (editingClearTimer) clearTimeout(editingClearTimer)
-      try { watcher && watcher.close() } catch { }
-      // The shared socket first: closing it ends every channel at once on the relay, instead of
-      // one CLOSE frame per file down a socket that is about to go anyway.
-      try { fileTransport.stop() } catch { }
-      for (const r of [...fileDocs.keys()]) closeFile(r) // tear down every per-file provider
-      try { provider.awareness.setLocalState(null) } catch { } // announce departure now (don't wait for timeout)
-      try { provider.destroy() } catch { }
-      try { doc.destroy() } catch { }
-      // A room you have left should stop colouring what your agents recall.
-      if (memoryLinked && grmLink) try { grmLink.unlinkRoom(ROOT, log) } catch { }
-      // Last, so a crash anywhere above still frees the folder on the next run via the
-      // stale-PID path rather than leaving it locked.
-      try { releaseLock() } catch { }
-      // A final flush of the ancestor record. The debounced save may still be pending, and
-      // losing it would make the next join see no common ancestor -- the exact condition
-      // that produced the rejoin clobber.
-      try { if (shadowTimer) { clearTimeout(shadowTimer); shadowTimer = null } saveShadow() } catch { }
-    },
+    stop: stopAll,
+    leave,     // async: hand pending work over, wait for the relay to accept it, then stop (0.14.3 P0-1)
+    whenSent,  // async (file, ms): has the relay accepted this file's local changes yet?
   }
 }