heyquilt 0.3.90 → 0.3.106

package/src/relay-sync.js

@@ -1,18 +1,20 @@
 // GitHub → session, through the relay's git mirror (relay-git.js). A push on GitHub (a webhook,
 // or the relay's own look) is fetched into the mirror and merged into the session's branch
 // document file by file: base, the commit the session's content is measured from; theirs, the
-// new head; ours, the session's content now. Files that merge cleanly land at once; a file whose
-// lines overlap, or that a member holds, is held aside with its own base and theirs (so a later
-// head never reinterprets it against another ancestor) and everything else lands. The session
+// new head; ours, the session's content now. Every file lands at once: where both sides changed
+// the same lines Quilt combines them itself, the newer edit keeping those lines (upstream.js
+// combine; relay-clash.js tells whoever's lines lost). Only a file a member holds (or one the
+// relay can't read) is held aside with its own base and theirs (so a later head never
+// reinterprets it against another ancestor), and merged the same way once they let go. The session
 // is the master node: every folder and agent gets the merged files from here, and a folder
 // follows the relay's commit with git instead of pulling (session.js). Never a history merge;
 // nothing is written to GitHub here.
 import * as Y from 'yjs'
-import { openClash, reviewClashes, finishClash, noteMerged, upstreamCommits, memberForAuthor, suggestCandidate } from './relay-clash.js'
-import { upstreamsOf, handClash, closeLanded, ignoreOf, docKey, fingerprint, hasMarkers, clashRegions, parseRepo, catcherAble, RELAY_ORIGIN } from './relay-upstream.js'
+import { noteMerged, upstreamCommits, memberForAuthor, tellAutoMerge, storeBlob, noteResolved, closeOldClash, lostLines } from './relay-clash.js'
+import { upstreamsOf, closeLanded, ignoreOf, docKey, parseRepo, catcherAble, RELAY_ORIGIN } from './relay-upstream.js'
 import { syncStateOf, runGit, GitFailed, authEnv } from './relay-git.js'
-import { planCatchUp, publishedOf } from './upstream.js'
-import { mergeAdditive, mergeSmart, unionMatcher } from './merge3.js'
+import { planCatchUp, publishedOf, combine } from './upstream.js'
+import { unionMatcher } from './merge3.js'
 import { applyTextDiff } from './textdiff.js'
 import { looksBinary, sha1 } from './fsutil.js'
 import { LARGE_FILE_BYTES, MAX_TEXT_BYTES, isIgnored, isSafeRelPath } from './pathrules.js'
@@ -26,7 +28,6 @@ export const BACKSTOP_MS = 60 * 1000
 export const ACTIVE_BACKSTOP_MS = 60 * 1000
 
 const plural = (k, w) => `${k} ${w}${k === 1 ? '' : 's'}`
-const isText = (k) => typeof k === 'string' && !k.startsWith('bin:')
 const SHA = /^[0-9a-f]{40,64}$/
 
 /** The paths that differ between two commits: Map path -> A, M or D (a type change counts as M; a rename as D plus A). */
@@ -116,9 +117,10 @@ export async function keepRefs (dir, room, key, { base, others = [] }) {
 /**
  * One look at session branch `key` through the mirror (the caller checked relayLooks). Fetches the
  * branch, and when the head moved on from the sync state's base, merges every changed file into
- * the branch document; files that clash or that a member holds are held with their own base and
- * theirs, and looked at again each time. Returns what happened: { state, ... } (for tests and the
- * log). Never throws.
+ * the branch document, combining what both sides changed (the newer edit keeps the lines both
+ * changed: GitHub's commit time against the session's last edit of the file); files a member
+ * holds are held with their own base and theirs, and merged once they let go. Returns what
+ * happened: { state, ... } (for tests and the log). Never throws.
  */
 export async function bringInBranch (room, key, { log = () => {}, now = () => Date.now(), inQueue = false } = {}) {
   const recs = upstreamsOf(room)
@@ -198,20 +200,7 @@ export async function bringInBranch (room, key, { log = () => {}, now = () => Da
     const disk = (rel) => docKey(e, rel)
     let landed = 0
     let released = []
-    // The open clashes: proposals nobody reviewed, mergers gone quiet, nobody to merge (relay-clash.js).
-    try { await reviewClashes(room, key, { now: started }) } catch (err) { log(`[${room.name}] ${key}: could not look at the clashes: ${err.message}`) }
-    // Held files first, each against its own base and theirs: a claim let go of, a clash merged.
-    for (const h of state.held) {
-      if (h.why !== 'clash' || h.parties || h.kind === 'offline' || !h.base || !h.theirs) continue
-      try {
-        const [b, t] = await Promise.all([filesAt(dir, h.base, [h.path]), filesAt(dir, h.theirs, [h.path])])
-        const bb = keyOf(b.get(h.path), h.path, { bins, tooLarge }); const tt = keyOf(t.get(h.path), h.path, { bins, tooLarge })
-        const m = isText(bb) && isText(disk(h.path)) && isText(tt) ? mergeSmart(bb, disk(h.path), tt, { union: (await unionFor(e, dir, null))(h.path) }) : null
-        if (m && !m.conflicts.length) continue // settleHeld lands it below
-        h.was = fingerprint(disk(h.path))
-        await openClash(room, key, rec, h, { dir, texts: { base: bb, ours: disk(h.path), theirs: tt }, now: started })
-      } catch (err) { log(`[${room.name}] ${key}: could not open the clash on ${h.path}: ${err.message}`) }
-    }
+    // Held files first, each against its own base and theirs: a claim let go of (and an older relay's clash) merged.
     try {
       const r = await settleHeld(room, key, { e, state, rec, dir, disk, bins, tooLarge, now: started, log })
       landed += r.landed; released = r.released
@@ -225,7 +214,7 @@ export async function bringInBranch (room, key, { log = () => {}, now = () => Da
       // The session is at GitHub's head: the record that folders follow (session.js memberAt) says so too.
       if (rec.sha !== head) { rec.sha = head; rec.relayHead = head }
       await keepRefs(dir, room.name, key, { base, others: keptObjects(state) })
-      if (!state.held.some((h) => h.why === 'clash')) { said(null); closeLanded(room, key, rec, `Brought in at ${head.slice(0, 7)}: the session on ${key} is at ${rec.name} ${head.slice(0, 7)}.`) }
+      if (!state.held.some((h) => h.why === 'claimed' || h.why === 'unread')) { said(null); closeLanded(room, key, rec, `Brought in at ${head.slice(0, 7)}: the session on ${key} is at ${rec.name} ${head.slice(0, 7)}.`) }
       return done({ state: 'up-to-date', head, landed, released, ...(probe ? { probe } : {}) })
     }
     // A folder's commit that isn't on GitHub (not pushed, or dropped) is never what the session is measured from: the
@@ -286,49 +275,39 @@ export async function bringInBranch (room, key, { log = () => {}, now = () => Da
     // A held file that changed again on GitHub keeps its base and takes the newest head as theirs.
     for (const h of state.held) {
       if (!changes.has(h.path)) continue
-      if (h.kind === 'offline') { h.upstreamMoved = { base: h.upstreamMoved ? h.upstreamMoved.base : base, theirs: head }; changes.delete(h.path); continue }
       h.theirs = head; h.head = head; changes.delete(h.path)
-      // A proposal was for the version GitHub had: it no longer is (addendum 16.8: a changed side invalidates it).
-      if (h.candidate) {
-        h.candidate = null
-        if (h.merger && room.postChat) room.postChat({ by: RELAY_BY, to: h.merger, kind: 'nudge', text: `${h.path} changed on GitHub again (${head.slice(0, 7)}) while your merge was waiting: propose it again against the new version (quilt_clash status, and the clash task).` })
-      }
     }
     const heldPaths = new Set(state.held.map((h) => h.path))
     const published = publishedOf(room.doc)
     const why = (c) => tooLarge.has(c.path) ? { ...c, why: `too large for the relay to bring in (binaries over ${LARGE_FILE_BYTES / 1024} KB, text over ${MAX_TEXT_BYTES / 1024 / 1024} MB): a member's folder brings it in` } : c
-    let plan = planCatchUp({ changes, base: baseMap, theirs, disk, published })
-    // §7.3 step 2 (structural): what still clashes line by line is tried again ignoring whitespace, word by word, or as a union for merge=union files.
+    // Files both sides changed: who changed each last, on each side, settles which edit is the newer (combine).
     const union = await unionFor(e, dir, head)
-    const structural = []
-    const suggested = new Map()
-    const settled = new Map() // structural merges that land by themselves: kept through any re-plan below
-    if (plan.conflicts.length) {
-      for (const c of plan.conflicts) {
-        const b = baseMap.get(c.path); const o = disk(c.path); const t = theirs.get(c.path)
-        if (!isText(b) || !isText(o) || !isText(t)) continue
-        const m = mergeSmart(b, o, t, { union: union(c.path) })
-        // Whitespace-only and merge=union land by themselves; a word-by-word merge is only a suggestion (addendum 16.8).
-        if (!m.conflicts.length && m.how !== 'words') settled.set(c.path, m.text)
-        else if (!m.conflicts.length) suggested.set(c.path, m.text)
-      }
-      if (settled.size) {
-        plan = planCatchUp({ changes: new Map([...changes].filter(([rel]) => !settled.has(rel))), base: baseMap, theirs, disk, published })
-        for (const [rel, t] of settled) { if (t !== disk(rel)) plan.writes.set(rel, t); structural.push(rel) }
-      }
+    const tops = new Map()
+    const parties = new Map()
+    for (const rel of changes.keys()) {
+      const b = baseMap.get(rel); const o = disk(rel); const t = theirs.get(rel)
+      if (b === undefined || o === undefined || t === undefined || o === b || o === t || t === b) continue
+      tops.set(rel, (await upstreamCommits(dir, base, head, rel))[0] || null)
+      parties.set(rel, sessionPartyOf(e, rel))
     }
-    const conflicts = plan.conflicts.map(why)
-    if (conflicts.length) {
-      // Those files are held; everything else lands.
-      plan = planCatchUp({ changes: new Map([...changes].filter(([rel]) => !conflicts.some((c) => c.path === rel) && !settled.has(rel))), base: baseMap, theirs, disk, published })
-      for (const [rel, t] of settled) if (t !== disk(rel)) plan.writes.set(rel, t)
-      for (const c of conflicts) if (!heldPaths.has(c.path)) state.held.push({ path: c.path, why: 'clash', base, theirs: head, head, was: fingerprint(disk(c.path)), regions: clashRegions(baseMap.get(c.path), disk(c.path), theirs.get(c.path)) || [], since: started })
+    if (room.ended || room.destroyed || !room.meta.branches[key] || !current() || state.base !== base) return done({ state: 'moved-on' })
+    // A commit's time is in whole seconds: it counts as made at the end of its second, so a commit
+    // and an edit in the same second go to the commit.
+    const oursNewer = (rel) => ((parties.get(rel) || {}).ts || 0) > ((tops.get(rel) || {}).ts || 0) + 999
+    let plan = planCatchUp({ changes, base: baseMap, theirs, disk, published, oursNewer, union })
+    // Only files the relay couldn't read are left: held (never overwritten with the session's copy), and everything else lands.
+    const unread = plan.conflicts.map(why)
+    if (unread.length) {
+      plan = planCatchUp({ changes: new Map([...changes].filter(([rel]) => !unread.some((c) => c.path === rel))), base: baseMap, theirs, disk, published, oursNewer, union })
+      for (const c of unread) if (!heldPaths.has(c.path)) state.held.push({ path: c.path, why: 'unread', base, theirs: head, head, since: started })
     }
+    // Planned against the session's content as it is now: a file edited before the writes is held and merged on the next look (below).
+    const captured = new Map([...plan.writes.keys(), ...plan.merged.map((m) => m.path)].map((rel) => [rel, disk(rel)]))
     // A file someone holds is never written under them: held with its own base and theirs until they let go (Room.noteClaimsChanged looks again).
     const claimed = []
     for (const rel of plan.writes.keys()) {
       const c = room.claimFor ? room.claimFor(rel, key) : null
-      if (c && !(rec.clash && c.clash === rec.clash.task)) claimed.push({ rel, by: c.by, pattern: c.pattern })
+      if (c) claimed.push({ rel, by: c.by, pattern: c.pattern })
     }
     for (const { rel, by, pattern } of claimed) {
       plan.writes.delete(rel)
@@ -339,25 +318,33 @@ export async function bringInBranch (room, key, { log = () => {}, now = () => Da
       rec.waitingOn = { path: rel, by, pattern }
     }
     if (!claimed.length) delete rec.waitingOn
-    // Files both sides changed, merged on the way in: on record with both parties, so failing checks after the push can pull them in (relay-clash.js).
-    const captured = new Map([...plan.writes.keys()].map((rel) => [rel, disk(rel)]))
-    const mergedBy = new Map()
-    for (const [rel, k] of plan.writes) {
-      const b = baseMap.get(rel); const o = captured.get(rel); const t = theirs.get(rel)
-      if (!(isText(k) && isText(b) && isText(o) && isText(t) && o !== b && t !== b && k !== t)) continue
-      const top = (await upstreamCommits(dir, base, head, rel))[0] || null
-      mergedBy.set(rel, { session: sessionPartyOf(e, rel), github: top ? { name: top.name, email: top.email, ts: top.ts, sha: top.sha, subject: top.subject, member: memberForAuthor(room, top) } : null })
+    // The session's version of a file whose lines lost is kept in the mirror too (a binary's history has no bytes), for RESOLVED_KEEP_MS.
+    const gh = (rel) => { const top = tops.get(rel); return top ? { name: top.name, email: top.email, ts: top.ts, sha: top.sha, subject: top.subject, member: memberForAuthor(room, top) } : null }
+    const merges = plan.merged.filter((m) => !claimed.some((c) => c.rel === m.path))
+    for (const m of merges) {
+      if (!m.lost.some((l) => l.side === 'ours')) continue
+      const buf = sessionBuf(e, m.path)
+      m.oursBlob = buf ? await storeBlob(dir, buf).catch(() => null) : null
     }
     crashPoint(room, 'merge')
     // Addendum 16.1: each write was planned against the session's content as it was then. A file edited since (the awaits above
     // let edits in) is not overwritten: it is held against its base and theirs, and merged with the newer edit on the next look.
+    const raced = new Set()
     for (const rel of [...plan.writes.keys()]) {
       if (disk(rel) === captured.get(rel)) continue
+      raced.add(rel)
       plan.writes.delete(rel)
       if (!state.held.some((h) => h.path === rel)) state.held.push({ path: rel, why: 'raced', base, theirs: head, head, since: started })
     }
-    for (const [rel, parties] of mergedBy) if (plan.writes.has(rel)) noteMerged(room, key, rel, parties, { now: started })
+    const landedMerges = merges.filter((m) => !raced.has(m.path))
+    // Files both sides changed, merged on the way in: on record with both parties, so failing checks after the push tell them (relay-clash.js).
+    for (const m of landedMerges) noteMerged(room, key, m.path, { session: parties.get(m.path) || null, github: gh(m.path) }, { now: started })
     const written = applyWrites(room, e, plan.writes, { bins, now: started })
+    // Whoever's lines lost is told (a direct message for the session's, the activity log for GitHub's); the losing version is kept.
+    for (const m of landedMerges) {
+      if (m.oursBlob) noteResolved(room, key, { path: m.path, kind: 'auto', base, theirs: head, oursBlob: m.oursBlob, how: `merged by Quilt: ${rec.name}'s newer edit kept`, at: started })
+      tellAutoMerge(room, key, { path: m.path, lost: m.lost, deleted: m.deleted || null, session: parties.get(m.path) || null, github: gh(m.path), upstream: rec.name, head, now: started })
+    }
     landed += written
     // The files that are now GitHub's version exactly are marked so (the Files tree, quilt_sync_status), until
     // someone edits them in the session (server.js wireBranch).
@@ -379,7 +366,7 @@ export async function bringInBranch (room, key, { log = () => {}, now = () => Da
     rec.sha = head
     rec.relayHead = head
     if (behind || written) rec.brought = { count: behind, files: written, at: started, head }
-    await keepRefs(dir, room.name, key, { base: head, others: state.held.flatMap((h) => [h.base, h.theirs]) })
+    await keepRefs(dir, room.name, key, { base: head, others: keptObjects(state) })
     if (rewritten) {
       // The session's own work on the new history: pending, so the next batch pushes it on top of the new head.
       for (const rel of changes.keys()) if (!heldPaths.has(rel) && disk(rel) !== undefined && disk(rel) !== (theirs.has(rel) ? theirs.get(rel) : null)) state.pending[rel] = started
@@ -391,27 +378,18 @@ export async function bringInBranch (room, key, { log = () => {}, now = () => Da
       room.activity.push([{ by: RELAY_BY, path: '', kind: 'brought', detail, branch: key, ts: started }])
       if (room.activity.length > 300) room.activity.delete(0, room.activity.length - 300)
     }, RELAY_ORIGIN)
-    log(`[${room.name}] ${key}: ${RELAY_BY} brought in ${detail} (${base.slice(0, 7)}..${head.slice(0, 7)})${state.held.length ? `; held: ${state.held.map((h) => `${h.path} (${h.why})`).join(', ')}` : ''}`)
-    const clashing = state.held.filter((h) => h.why === 'clash')
-    let task = null
-    if (clashing.length) {
-      // §7.3: each newly held file gets its parties, a merger and a reviewer, and a task (relay-clash.js).
-      for (const h of clashing) {
-        if (h.parties) continue
-        try {
-          await openClash(room, key, rec, h, { dir, texts: { base: baseMap.has(h.path) ? baseMap.get(h.path) : null, ours: disk(h.path), theirs: theirs.has(h.path) ? theirs.get(h.path) : null }, now: started })
-          if (suggested.has(h.path)) await suggestCandidate(room, key, h, suggested.get(h.path), { dir, now: started })
-        } catch (err) { log(`[${room.name}] ${key}: could not open the clash on ${h.path}: ${err.message}`) }
-      }
-      task = clashing.find((h) => h.task)?.task || null
-      said(`${plural(clashing.length, 'file')} on ${key} clash with ${rec.name} ${head.slice(0, 7)}: ${clashing.map((h) => h.path).slice(0, 4).join(', ')}${clashing.length > 4 ? ' and more' : ''} ${clashing.length === 1 ? 'is' : 'are'} held while ${clashing.map((h) => h.merger).filter(Boolean)[0] || 'an agent or a person'} merges${task ? ` (task ${task})` : ''}; everything else is in`)
-    } else if (claimed.length) {
+    const combined = landedMerges.filter((m) => m.lost.length || m.deleted)
+    log(`[${room.name}] ${key}: ${RELAY_BY} brought in ${detail} (${base.slice(0, 7)}..${head.slice(0, 7)})${combined.length ? `; combined ${combined.map((m) => `${m.path} (${m.deleted ? 'kept the edit over a deletion' : `the ${m.oursNewer ? 'session\'s' : 'GitHub\'s'} newer lines kept`})`).join(', ')}` : ''}${state.held.length ? `; held: ${state.held.map((h) => `${h.path} (${h.why})`).join(', ')}` : ''}`)
+    const unreadHeld = state.held.filter((h) => h.why === 'unread')
+    if (claimed.length) {
       said(`${claimed[0].by} holds ${claimed[0].rel}: the relay brings ${rec.name}'s change to it in once they let go of it (quilt_release, or quilt_handoff); everything else is in`)
+    } else if (unreadHeld.length) {
+      said(`${unreadHeld.map((h) => h.path).slice(0, 4).join(', ')}${unreadHeld.length > 4 ? ' and more' : ''}: too large for the relay to read, so a member's folder brings ${unreadHeld.length === 1 ? 'it' : 'them'} in; everything else is in`)
     } else {
       said(null)
       closeLanded(room, key, rec, `Brought in at ${head.slice(0, 7)}: ${RELAY_BY} merged ${plural(behind, 'commit')} from ${rec.name} into ${key}${released.length ? `, keeping the merged ${released.join(', ')}` : ''}.`)
     }
-    return done({ state: 'brought', head, count: behind, files: written, held: state.held.map((h) => ({ path: h.path, why: h.why })), task, released, structural })
+    return done({ state: 'brought', head, count: behind, files: written, held: state.held.map((h) => ({ path: h.path, why: h.why })), released, merged: landedMerges.map((m) => ({ path: m.path, lost: m.lost.length ? m.lost[0].side : null, ...(m.deleted ? { deleted: m.deleted } : {}) })) })
   })
 }
 
@@ -490,7 +468,6 @@ async function unionFor (e, dir, head) {
   return unionMatcher(texts)
 }
 
-/** Writes `writes` (path -> key: text, "bin:<sha1>" or null) into the branch document as the relay, in one transaction; how many. */
 /** The newest commit in base..head that touched each of `paths`: path -> { sha, by, at, subject }, in one git log. */
 async function lastCommits (dir, base, head, paths) {
   const want = new Set(paths)
@@ -564,7 +541,8 @@ export function fromGithubOf (e) {
   return out.sort((a, b) => (b.at || 0) - (a.at || 0) || (a.path < b.path ? -1 : 1))
 }
 
-function applyWrites (room, e, writes, { bins, now }) {
+/** Writes `writes` (path -> key: text, "bin:<sha1>" or null) into the branch document as the relay, in one transaction; how many. */
+export function applyWrites (room, e, writes, { bins, now }) {
   if (!writes.size) return 0
   const history = e.historyLog || (e.historyLog = new HistoryLog(e.doc, e.doc.getArray('history'), { origin: RELAY_ORIGIN }))
   let written = 0
@@ -597,73 +575,93 @@ function applyWrites (room, e, writes, { bins, now }) {
   return written
 }
 
+/** The session's bytes of `rel` on the branch document (text or an inline binary), or null. */
+function sessionBuf (e, rel) {
+  const t = e.files.get(rel)
+  if (t) return Buffer.from(t.toString(), 'utf8')
+  const b = e.blobs.get(rel)
+  return b && typeof b.data === 'string' ? Buffer.from(b.data, 'base64') : null
+}
+
+async function readBlob (dir, sha) {
+  const r = await runGit(dir, ['cat-file', 'blob', sha], { buffer: true })
+  return r.ok ? r.out : null
+}
+
 /**
- * The held files, each looked at against its own base and theirs: a claimed file whose claim is
- * gone merges and lands (or becomes a clash); a clashing file lands once the session's copy
- * merges cleanly with its theirs, or its task was settled (moved on by its assignee) without
- * markers left. Returns { landed, released: [paths] }.
+ * The held files, each looked at against its own base and theirs: one whose claim is gone (or that
+ * raced an edit, or an older relay held for a clash) is combined with the session's copy now
+ * (upstream.js combine) and lands, whoever's lines lost told; files an older relay held for failing
+ * checks are let go of. Returns { landed, released: [paths] }.
  */
 async function settleHeld (room, key, { e, state, rec, dir, disk, bins, tooLarge, now, log }) {
   if (!state.held.length) return { landed: 0, released: [] }
   const union = await unionFor(e, dir, null)
   const writes = new Map()
-  const settledBy = [] // clashes (relay-clash.js) a person settled by saving the file without markers
   const released = []
   const keep = []
+  const done = [] // { h, d, r, party, top, theirsName }
   for (const h of state.held) {
     const d = disk(h.path)
     if (d === undefined) { keep.push(h); continue } // a large stored file: a folder brings it in
+    if (h.why === 'checks') { released.push(h.path); closeOldClash(room, key, h, { how: 'let go of: files are no longer held for failing checks', now }); continue }
+    if (h.why === 'claimed' && room.claimFor && room.claimFor(h.path, key)) { keep.push(h); continue }
+    let base, theirs, party, top, theirsName
     if (h.kind === 'offline') {
-      // A person saved it without markers in their own editor (agents can't write a held file): that settles it.
-      if (fingerprint(d) !== h.was && !hasMarkers(d)) { released.push(h.path); settledBy.push(h) } else keep.push(h)
-      continue
-    }
-    if (!h.base || !h.theirs) { keep.push(h); continue }
-    const [b, t] = await Promise.all([filesAt(dir, h.base, [h.path]), filesAt(dir, h.theirs, [h.path])])
-    const base = keyOf(b.get(h.path), h.path, { bins, tooLarge })
-    const theirs = keyOf(t.get(h.path), h.path, { bins, tooLarge })
-    if (h.why === 'claimed' || h.why === 'raced') {
-      const c = h.why === 'claimed' && room.claimFor ? room.claimFor(h.path, key) : null
-      if (c && !(rec.clash && c.clash === rec.clash.task)) { keep.push(h); continue }
-      if (d === base || (d === null && base === null)) { writes.set(h.path, theirs); released.push(h.path); continue } // nobody touched it meanwhile
-      if (isText(base) && isText(d) && isText(theirs)) {
-        const m = mergeSmart(base, d, theirs, { union: union(h.path) })
-        if (!m.conflicts.length) { if (m.text !== d) writes.set(h.path, m.text); released.push(h.path); continue }
-        keep.push({ ...h, why: 'clash', was: fingerprint(d), regions: m.conflicts.map((c) => sha1(Buffer.from(c.ours.join('\n'), 'utf8'))), since: now })
-        continue
-      }
-      if (d === theirs) { released.push(h.path); continue }
-      keep.push({ ...h, why: 'clash', was: fingerprint(d), regions: [], since: now })
-      continue
-    }
-    // A clash.
-    const settled = !!(rec.clash && rec.clash.settled && rec.clash.sha === h.head)
-    if (hasMarkers(d)) { keep.push(h); continue }
-    if (settled) { released.push(h.path); continue } // the assignee says it is merged as it is
-    if (fingerprint(d) === h.was) { keep.push(h); continue } // untouched since
-    if (isText(base) && isText(d) && isText(theirs)) {
-      const m = mergeSmart(base, d, theirs, { union: union(h.path) })
-      if (m.how === 'words' && !m.conflicts.length && fingerprint(d) === h.was) { keep.push(h); continue }
-      const old = h.regions || []
-      const stillClashing = m.conflicts.some((c) => old.includes(sha1(Buffer.from(c.ours.join('\n'), 'utf8'))))
-      if (m.conflicts.length && stillClashing) { keep.push(h); continue }
-      // The clashing lines were rewritten: they are the merge (ours, in m.text), and GitHub's other changes come in around them.
-      if (m.text !== d) writes.set(h.path, m.text)
-      released.push(h.path)
-      if (h.parties) settledBy.push(h)
-      continue
+      // An older relay's clash with a member's offline edits: theirs is what they brought back.
+      base = h.baseBlob ? (await readBlob(dir, h.baseBlob))?.toString('utf8') ?? null : null
+      theirs = h.otherDeleted ? null : h.otherBlob ? (await readBlob(dir, h.otherBlob))?.toString('utf8') : undefined
+      if (theirs === undefined) { released.push(h.path); closeOldClash(room, key, h, { how: 'the session\'s version kept (the other is no longer kept)', now }); continue }
+      const off = (h.parties && h.parties.offline) || {}
+      party = sessionPartyOf(e, h.path)
+      top = { name: off.name || 'a member', member: off.name || null, ts: off.ts || 0 }
+      theirsName = `${off.name || 'a member'}'s offline edits`
+    } else {
+      if (!h.base || !h.theirs) { keep.push(h); continue }
+      const [b, t] = await Promise.all([filesAt(dir, h.base, [h.path]), filesAt(dir, h.theirs, [h.path])])
+      base = keyOf(b.get(h.path), h.path, { bins, tooLarge })
+      theirs = keyOf(t.get(h.path), h.path, { bins, tooLarge })
+      if (base === undefined || theirs === undefined) { keep.push(h); continue }
+      const c = (await upstreamCommits(dir, h.base, h.theirs, h.path))[0] || null
+      top = c ? { name: c.name, email: c.email, ts: c.ts, sha: c.sha, subject: c.subject, member: memberForAuthor(room, c) } : null
+      party = sessionPartyOf(e, h.path)
+      theirsName = rec.name
     }
-    released.push(h.path) // a deletion or a binary: changed since is all there is to go on
-    if (h.parties) settledBy.push(h)
+    const oursNewer = ((party || {}).ts || 0) > ((top || {}).ts || 0) + 999 // a commit's whole second is its own
+    const r = combine(base, d, theirs, { oursNewer, union: union(h.path) })
+    done.push({ h, d, r, party, top, theirsName, both: d !== base && theirs !== base && d !== theirs })
+  }
+  // The session's version of a file whose lines lose is kept in the mirror too.
+  for (const x of done) {
+    if (!x.r.lost.some((l) => l.side === 'ours')) continue
+    const buf = sessionBuf(e, x.h.path)
+    x.blob = buf ? await storeBlob(dir, buf).catch(() => null) : null
+  }
+  // Each was combined against the session's copy as it was then: one edited since (the awaits let edits in) waits for the next look.
+  for (const x of done) {
+    if (disk(x.h.path) !== x.d) { keep.push(x.h); continue }
+    if (x.r.key !== x.d) writes.set(x.h.path, x.r.key)
+    released.push(x.h.path)
+    if (x.blob) noteResolved(room, key, { path: x.h.path, kind: 'auto', base: x.h.base || null, theirs: x.h.theirs || null, oursBlob: x.blob, how: `merged by Quilt: ${x.theirsName}'s newer edit kept`, at: now })
   }
   const landed = applyWrites(room, e, writes, { bins, now })
   state.held = keep
-  for (const h of settledBy) {
-    const last = e.doc.getArray('history').toArray().filter((x) => x && x.path === h.path && !x.pulled && x.by && !isRelay(x.by)).sort((a, b) => (a.ts || 0) - (b.ts || 0)).at(-1)
-    finishClash(room, key, h, { how: 'merged in an editor', by: last ? last.by : 'a person', text: docKey(e, h.path), now, mergeHow: 'agent' })
+  for (const x of done) {
+    if (!released.includes(x.h.path)) continue
+    const { h, r } = x
+    if (h.why === 'clash' || h.kind === 'offline') closeOldClash(room, key, h, { how: 'merged by Quilt on its own', now })
+    if (h.kind === 'offline' && h.upstreamMoved) state.held.push({ path: h.path, why: 'raced', base: h.upstreamMoved.base, theirs: h.upstreamMoved.theirs, head: h.upstreamMoved.theirs, since: now })
+    if (h.kind === 'offline') {
+      // The returning member's lines lost: they are told as the session's side would be.
+      const lostTheirs = r.lost.filter((l) => l.side === 'theirs')
+      if (lostTheirs.length && x.top && x.top.member && room.postChat) room.postChat({ by: RELAY_BY, to: x.top.member, kind: 'nudge', text: `Quilt merged your offline edits to ${h.path} on ${key}: where you and ${(x.party && x.party.name) || 'the session'} both changed the same lines, the newer edit stays. Your lines it replaced:\n${lostLines(lostTheirs)}` })
+      tellAutoMerge(room, key, { path: h.path, lost: r.lost.filter((l) => l.side === 'ours'), deleted: r.deleted === 'ours' ? 'ours' : null, session: x.party, github: x.top, upstream: x.theirsName, now })
+    } else {
+      if (x.both) noteMerged(room, key, h.path, { session: x.party || null, github: x.top }, { now })
+      tellAutoMerge(room, key, { path: h.path, lost: r.lost, deleted: r.deleted || null, session: x.party, github: x.top, upstream: x.theirsName, head: h.theirs, now })
+    }
   }
   if (released.length) log(`[${room.name}] ${key}: ${released.join(', ')} merged and let go of`)
-  if (!keep.some((h) => h.why === 'clash') && rec.clash) { /* closeLanded by the caller once the head is current */ }
   return { landed, released }
 }
 
@@ -687,7 +685,7 @@ export function crashPoint (room, name) {
  * Where branch `key` stands with GitHub, for people and agents (addendum 16.13): { state, why?,
  * revision, pending, held, pr? }. `state`: 'paused' (the owner's switch, a deletion on GitHub, or a
  * sync not set up), 'permission-held' (GitHub refused the relay), 'offline' (GitHub out of reach),
- * 'conflict-held' (files held for a merge), 'pr-pending' (work going through a pull request: a
+ * 'pr-pending' (work going through a pull request: a
  * protected branch, or another session holds it), 'github-pending' (edits not on GitHub yet) or
  * 'synced'. 'github-pending' means files changed in the session since its last commit (nothing goes to GitHub until
  * someone commits). `revision`: the GitHub commit the session's content is acknowledged at.
@@ -712,7 +710,6 @@ export function syncStatus (room, key, { live = true } = {}) {
   if (rec.gone) return { ...out, state: 'paused', why: rec.problem || `${rec.ref} was deleted on GitHub` }
   if (st.paused && st.paused.why === 'unreachable') return { ...out, state: 'offline', why: rec.problem || 'GitHub out of reach', since: st.paused.at }
   if (st.paused) return { ...out, state: 'permission-held', why: rec.problem || 'GitHub refused the relay' }
-  if (out.held) return { ...out, state: 'conflict-held', why: `${out.held} file${out.held === 1 ? '' : 's'} held for a merge` }
   if (st.protected && st.protected.pr) return { ...out, state: 'pr-pending', why: rec.problem || '', pr: st.protected.pr, live: st.protected.head || null }
   if (out.pending || st.op) return { ...out, state: 'github-pending' }
   return { ...out, state: 'synced' }