@heyquilt/seam 0.140.0 → 0.142.0

package/lib/quilts/block.js

@@ -17,6 +17,8 @@ import { CDC_THRESHOLD } from './fastcdc.js'
 import { TreeReader, decodeNode, EMPTY_TREE } from './tree.js'
 import { globMatcher } from './claims.js'
 import { theCas } from './cas.js'
+import { fastMerge } from './fastmerge.js'
+import { diffMarkers, gitMarkers } from './conflict-format.js'
 
 /** How much of a large file is read at a time (10, streaming the cut). */
 export const READ_PIECE = 1024 * 1024
@@ -174,8 +176,10 @@ function readFileEntry (abs, stat, pointer) {
  */
 export function livePatch (dir, block, paths) {
   const only = paths.map((p) => cleanPrefix(path.relative(dir, path.resolve(p)).split(path.sep).join('/')))
-  const changed = localChanges(dir, block, { paths })
-  const seen = new Set(changed.map((c) => c.path))
+  // A file a move left conflicted is not shared until it is settled (its markers would go out as work).
+  const held = new Set(pullConflicts(dir, block))
+  const changed = localChanges(dir, block, { paths }).filter((c) => !held.has(c.path))
+  const seen = new Set([...changed.map((c) => c.path), ...held])
   const changes = changed.map((c) => c.status === 'deleted' ? { path: c.path, op: 'delete' } : { path: c.path, op: 'put', content: bytesOf(c).toString('base64'), mode: c.mode })
   // A named path that is not a change and not tracked is `clean` only when it is gone from disk (it
   // may have been shared as added); one still there is ignored or a folder, and is not sent.
@@ -436,7 +440,9 @@ export async function checkout (client, { quilt, square = null, squareRow = null
 
 /**
  * Moves the folder from `block.at` to commit `to`, file by file: paths changed on the server
- * are rewritten; a path changed both here and there is left as it is here and reported.
+ * are rewritten; a path changed both here and there is merged three ways (planMerges): merged
+ * cleanly, or left with conflict markers (or, when it can't be merged line by line, as it is
+ * here) and reported, to be settled before it is committed.
  */
 export async function syncTo (client, dir, block, to, { square, afterWrite } = {}) {
   const local = new Map(localChanges(dir, block).map((c) => [c.path, c]))
@@ -444,23 +450,29 @@ export async function syncTo (client, dir, block, to, { square, afterWrite } = {
   const t = d.files.length ? await listTree(client, block.quilt, to ? `c:${to}` : 'main', block.paths, dir) : { entries: [] }
   const byPath = new Map(t.entries.filter((e) => !e.unreadable).map((e) => [e.path, e]))
   const get = await contentsFor(client, block.quilt, to ? `c:${to}` : 'main', d.files.map((f) => byPath.get(f.path)).filter(Boolean), block._codec, t.ticket)
-  const kept = []
   let written = 0
+  // Paths changed on both sides are merged before anything is written, so the journal's plan
+  // holds each merge's outcome (05 "Projection model"; rebuild finishes them).
+  const both = d.files.filter((f) => local.has(f.path)).map((f) => ({ path: f.path, old: block.files[f.path] || null, theirs: byPath.get(f.path) || null }))
+  const plans = await planMerges(client, block, both, { from: block.at, get, to, oursOf: (p) => oursOfChange(local.get(p)) })
   // The plan goes to the journal first (05 "Rebuilt, never repaired"), so a move that dies part
   // way is finished by rebuild instead of leaving the server's files looking like the holder's edits.
   const journal = openJournal(dir, {
     op: 'move', from: block.at || null, to, rev: to ? `c:${to}` : 'main',
     ...(square ? { square: { id: square.id, short: square.short, head: square.head, line: square.line } } : {}),
     writes: d.files.filter((f) => !local.has(f.path) && byPath.get(f.path)).map((f) => { const e = byPath.get(f.path); return { path: e.path, blob: e.blob, mode: e.mode, size: e.size, ...(e.term ? { term: e.term } : {}), ...(e.read_only ? { read_only: true } : {}), old: block.files[f.path] || null } }),
-    removes: d.files.filter((f) => !local.has(f.path) && !byPath.get(f.path)).map((f) => ({ path: f.path, old: block.files[f.path] || null }))
+    removes: d.files.filter((f) => !local.has(f.path) && !byPath.get(f.path)).map((f) => ({ path: f.path, old: block.files[f.path] || null })),
+    merges: plans.map(({ write: _, ours: __, ...m }) => m)
   })
+  const byMerge = new Map(plans.map((m) => [m.path, m]))
   for (const f of d.files) {
-    if (local.has(f.path)) { kept.push(f.path); continue }
-    const e = byPath.get(f.path)
-    if (!e) {
+    const m = byMerge.get(f.path)
+    if (m) applyMerge(dir, block, m)
+    else if (!byPath.get(f.path)) {
       removeEntry(dir, f.path, block.files[f.path]?.mode)
       delete block.files[f.path]; written++
     } else {
+      const e = byPath.get(f.path)
       block.files[f.path] = await writeEntry(dir, e, await get(e))
       written++
     }
@@ -476,7 +488,163 @@ export async function syncTo (client, dir, block, to, { square, afterWrite } = {
   setStack(block, await stackOf(client, block.quilt, to))
   saveBlock(dir, block)
   journal.close()
-  return { written, kept }
+  return { written, ...mergeReport(plans) }
+}
+
+const mergeReport = (plans) => ({ merged: plans.filter((m) => m.how === 'merged').map((m) => m.path), conflicted: plans.filter((m) => m.how === 'conflict').map((m) => m.path) })
+
+// The ladder steps that merge by themselves (07's auto_combine at its default, as merge.js's AUTO).
+const MERGES_ITSELF = new Set(['lines', 'additive', 'whitespace'])
+const textMode = (m) => m === 'file' || m === 'exec'
+const conflictErr = (msg) => Object.assign(new Error(msg), { code: 'conflicted' })
+/** Where a move keeps the folder's own version of a file it left conflicted (for seam resolve --ours). */
+const savedOurs = (dir, tag) => path.join(dir, BLOCK_DIR, 'conflicts', tag)
+/** The folder's side of a merge from a localChanges entry: { bytes (null: deleted, undefined: not read whole), mode, blob }. */
+const oursOfChange = (c) => c.status === 'deleted' ? { bytes: null } : { bytes: c.bytes, mode: c.mode, blob: c.blob }
+/** A tree entry as the folder's record of it (mtime 0: the file on disk is read again). */
+const recordOf = (e) => e ? { blob: e.mode === 'conflict' ? null : e.blob, mode: e.mode, size: e.size, mtimeMs: 0, ...(e.term ? { term: e.term } : {}) } : null
+
+/**
+ * Plans the three-way merge of each path changed both in the folder and in a move, as the server
+ * merges (07): base = the folder's record (`old`, read at `from`), ours = the disk (`oursOf`),
+ * theirs = the move's entry (`theirs`, read with `get`; null when the move deletes it). Writes
+ * nothing. Each plan says what the file becomes and that the record moves to theirs, so the
+ * file is an edit against the new commit and the next commit drops nothing the move brought
+ * (05 "Projection model"). `how`:
+ * - 'same': both sides made the same change;
+ * - 'merged': merged cleanly; `write` is the merged text, the folder's edit;
+ * - 'conflict': the clash with conflict markers in `write` (the folder's own version in `ours`, for
+ *   seam resolve --ours), or, for a file that can't be merged line by line, no write: the folder's
+ *   version stays. `conflict` is its block.conflicts entry, kept until it is settled.
+ */
+async function planMerges (client, block, both, { from, get, to, oursOf }) {
+  if (!both.length) return []
+  const bases = both.filter((b) => b.old && b.old.blob && textMode(b.old.mode)).map((b) => ({ path: b.path, blob: b.old.blob, mode: b.old.mode, size: b.old.size }))
+  const getBase = bases.length && from ? await contentsFor(client, block.quilt, `c:${from}`, bases, block._codec) : null
+  const baseOf = new Map(bases.map((e) => [e.path, e]))
+  const idOf = idsOf(block)
+  const out = []
+  for (const { path: p, old, theirs } of both) {
+    const ours = oursOf(p)
+    const base = baseOf.has(p) && getBase ? await getBase(baseOf.get(p)) : undefined
+    const theirsBytes = theirs && theirs.mode !== 'conflict' ? await get(theirs) : null
+    const m = { path: p, old, record: recordOf(theirs) }
+    // Both deleted it, or both made it the same.
+    if ((!theirs && ours.bytes === null) || (theirs && ours.bytes && ours.blob === theirs.blob && ours.mode === theirs.mode)) { out.push({ ...m, how: 'same' }); continue }
+    const prior = block.conflicts?.[p]
+    const isBuf = (b) => b == null || Buffer.isBuffer(b)
+    const mergeable = (ours.bytes === null || (textMode(ours.mode) && ours.bytes)) && (!theirs || (textMode(theirs.mode) && theirsBytes)) &&
+      (!old || (textMode(old.mode) && base !== undefined)) && isBuf(ours.bytes) && isBuf(theirsBytes) && isBuf(base) &&
+      isText(ours.bytes) && isText(theirsBytes) && isText(base) && !!(ours.bytes || theirsBytes)
+    if (!mergeable) {
+      // A file that can't be merged line by line (binary, large, a link, a conflict already):
+      // the folder's version stays as it is until seam resolve --ours or --theirs settles it.
+      out.push({ ...m, how: 'conflict', conflict: { kind: 'whole', ...(prior?.tags ? { tags: prior.tags } : {}) } })
+      continue
+    }
+    const [o, a, b] = [base, ours.bytes, theirsBytes].map((x) => (x || Buffer.alloc(0)).toString('utf8'))
+    const exec = (theirs && old && old.mode === ours.mode ? theirs.mode : ours.mode || theirs?.mode) === 'exec'
+    if (ours.bytes && theirsBytes) {
+      const r = fastMerge(o, a, b, { allow: 'whitespace' })
+      if (!r.conflicts.length && MERGES_ITSELF.has(r.how)) {
+        const write = Buffer.from(r.text, 'utf8')
+        out.push({ ...m, how: 'merged', write, exec, out: idOf(write) })
+        continue
+      }
+    }
+    // A clash, or one side deleted what the other changed: the file with both sides in markers.
+    const hex = blobId(Buffer.from(['pull', p, old?.blob || '', ours.blob || '', theirs?.blob || ''].join('\n'))).slice(0, 12)
+    const tag = `quilt-conflict ${hex}`
+    const kind = ours.bytes && theirsBytes ? 'content' : 'edit_vs_delete'
+    const at = `upstream ${String(to || '').slice(0, 12)}`.trim()
+    const text = conflictStyle() === 'git' && ours.bytes && theirsBytes
+      ? gitMarkers({ ours: { text: a, label: 'yours' }, base: o, theirs: { text: b, label: at }, tag })
+      : diffMarkers({ sides: [{ text: ours.bytes ? a : null, label: 'yours', by: 'you' }, { text: theirsBytes ? b : null, label: at, by: 'upstream' }], bases: [o], tag, kind })
+    const write = Buffer.from(text, 'utf8')
+    out.push({ ...m, how: 'conflict', write, exec, out: idOf(write), ...(ours.bytes ? { ours: ours.bytes } : {}), conflict: { kind, tags: [...(prior?.tags || []), hex], ours: ours.bytes ? hex : null } })
+  }
+  return out
+}
+
+/** Carries out one planMerges plan: the folder's own version saved, the file written, the record and conflict set. */
+function applyMerge (dir, block, m) {
+  if (m.ours && m.conflict?.ours) { fs.mkdirSync(path.dirname(savedOurs(dir, m.conflict.ours)), { recursive: true }); fs.writeFileSync(savedOurs(dir, m.conflict.ours), m.ours) }
+  if (m.write) {
+    const abs = absOf(dir, m.path)
+    fs.mkdirSync(path.dirname(abs), { recursive: true })
+    const tmpDir = path.join(dir, BLOCK_DIR, 'tmp')
+    fs.mkdirSync(tmpDir, { recursive: true })
+    const tmp = path.join(tmpDir, `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+    fs.writeFileSync(tmp, m.write, { mode: m.exec ? 0o755 : 0o644 })
+    fs.renameSync(tmp, abs)
+  }
+  settleRecord(block, m)
+}
+
+function settleRecord (block, m) {
+  if (m.record) block.files[m.path] = m.record
+  else delete block.files[m.path]
+  if (m.conflict) block.conflicts = { ...block.conflicts, [m.path]: m.conflict }
+}
+
+/**
+ * The files a move left conflicted (planMerges) that are not settled yet, sorted. A file is settled
+ * once its markers are gone (edited, deleted, restored), or, for one kept whole, once it matches
+ * the folder's record; a settled one leaves block.conflicts (and block.json is saved).
+ */
+export function pullConflicts (dir, block) {
+  const c = block.conflicts
+  if (!c) return []
+  const open = []
+  let changed = null
+  let dropped = false
+  for (const [p, x] of Object.entries(c)) {
+    let still = false
+    if (x.tags?.length) { let bytes = null; try { bytes = fs.readFileSync(absOf(dir, p)) } catch {} still = !!bytes && x.tags.some((t) => bytes.includes(Buffer.from(`quilt-conflict ${t}`))) }
+    if (!still && x.kind === 'whole') { changed ??= new Set(localChanges(dir, block).map((ch) => ch.path)); still = changed.has(p) }
+    if (still) { open.push(p); continue }
+    for (const t of x.tags || []) fs.rmSync(savedOurs(dir, t), { force: true })
+    delete c[p]
+    dropped = true
+  }
+  if (!Object.keys(c).length) delete block.conflicts
+  if (dropped) saveBlock(dir, block)
+  return open.sort(cmpPath)
+}
+
+/** Refuses to commit (or move) while `paths` hold a conflict a move left. */
+function refuseConflicted (open, verb) {
+  if (!open.length) return
+  throw conflictErr(`${open.join(', ')} still ${open.length === 1 ? 'has' : 'have'} the conflict seam pull left: edit ${open.length === 1 ? 'it' : 'each'} to the version you want (no markers), or seam resolve <path> --ours | --theirs, then ${verb}.`)
+}
+
+/**
+ * seam resolve --ours | --theirs for files a move left conflicted, in the folder: ours puts back
+ * the folder's own version from before the move (one kept whole stays as it is), theirs the
+ * version the folder moved to. Answers { settled: [paths], took }.
+ */
+export async function resolvePulled (client, dir, block, { paths, choose }) {
+  const open = new Set(pullConflicts(dir, block))
+  const rels = paths.map((p) => cleanPrefix(path.relative(dir, path.resolve(p)).split(path.sep).join('/')))
+  const not = rels.filter((p) => !open.has(p))
+  if (not.length) throw new Error(`${not.join(', ')}: no conflict seam pull left there (seam status lists them)`)
+  if (choose === 'theirs') {
+    const entries = rels.filter((p) => block.files[p]).map((p) => ({ path: p, ...block.files[p] }))
+    const get = await contentsFor(client, block.quilt, `c:${block.at}`, entries, block._codec)
+    for (const e of entries) block.files[e.path] = { ...await writeEntry(dir, e, await get(e)), ...(e.term ? { term: e.term } : {}) }
+    for (const p of rels) if (!block.files[p]) { removeEntry(dir, p, 'file'); pruneEmpty(dir, p) }
+  } else {
+    for (const p of rels) {
+      const x = block.conflicts[p]
+      if (x.kind === 'whole') continue
+      if (x.ours) fs.writeFileSync(absOf(dir, p), fs.readFileSync(savedOurs(dir, x.ours)))
+      else { removeEntry(dir, p, 'file'); pruneEmpty(dir, p) }
+    }
+  }
+  for (const p of rels) { for (const t of block.conflicts[p].tags || []) fs.rmSync(savedOurs(dir, t), { force: true }); delete block.conflicts[p] }
+  if (!Object.keys(block.conflicts).length) delete block.conflicts
+  saveBlock(dir, block)
+  return { settled: rels, took: choose }
 }
 
 /** The write journal of a block folder: one plan line, then one `{ done }` line per path. */
@@ -518,30 +686,44 @@ function onDisk (dir, block, p) {
   return { id: idsOf(block)(bytes), mode, stat }
 }
 
+/** The folder's side of a merge read from disk (oursOfChange's shape). */
+function oursOnDisk (dir, block, p) {
+  const cur = onDisk(dir, block, p)
+  if (!cur) return { bytes: null }
+  if (!cur.stat.isFile() && !cur.stat.isSymbolicLink()) return { bytes: undefined, mode: cur.mode, blob: cur.id }
+  if (cur.stat.isFile() && cur.stat.size > CDC_THRESHOLD && !block.sealed) return { bytes: undefined, mode: cur.mode, blob: cur.id }
+  return { bytes: readFileEntry(absOf(dir, p), cur.stat, false).bytes, mode: cur.mode, blob: cur.id }
+}
+
 /**
  * block.rebuild (05): finishes a move the journal shows unfinished. A planned path whose file is
- * the plan's is recorded; one still as before (or gone) is written now; one that is neither is
- * the holder's edit and is kept. Then block.json takes the move's commit and the journal goes.
- * On a healthy block it writes nothing. Answers { finished, written, removed, kept, changes }.
+ * the plan's is recorded; one still as before (or gone) is written now; one the holder edited
+ * before it was written is merged with the move's change (planMerges), as are the planned merges
+ * the move did not reach. Then block.json takes the move's commit and the journal goes. On a
+ * healthy block it writes nothing. Answers { finished, written, removed, kept (the holder's edits,
+ * merged ones too), conflicted, changes }.
  */
 export async function rebuild (client, dir, block) {
   const j = readJournal(dir)
-  if (!j) return { finished: false, written: [], removed: [], kept: [], changes: localChanges(dir, block).length }
+  if (!j) return { finished: false, written: [], removed: [], kept: [], conflicted: [], changes: localChanges(dir, block).length }
   const { plan, done } = j
   const same = (cur, rec) => !!(cur && rec && rec.blob && cur.id === rec.blob && cur.mode === rec.mode)
   const written = []
   const removed = []
   const kept = []
+  const conflicted = []
   const toWrite = []
+  // Paths the holder changed and the move changes too, still to merge: { path, old, theirs }.
+  const redo = []
   for (const w of plan.writes || []) {
     const cur = onDisk(dir, block, w.path)
     if (same(cur, w)) { block.files[w.path] = { blob: w.blob, mode: w.mode, size: cur.stat.size, mtimeMs: cur.stat.mtimeMs, ...(w.term ? { term: w.term } : {}) }; continue }
     if (done.has(w.path) && w.mode === 'conflict' && cur) { const st = cur.stat; block.files[w.path] = { blob: null, mode: 'conflict', size: st.size, mtimeMs: st.mtimeMs, term: w.term }; continue }
     if (!done.has(w.path) && (!cur || same(cur, w.old))) { toWrite.push(w); continue }
-    // Written and edited since, or edited before it was written: the holder's. Its record is the
-    // one the folder now stands on, so the edit shows against the new commit.
-    kept.push(w.path)
-    if (done.has(w.path)) block.files[w.path] = { blob: w.blob, mode: w.mode, size: w.size, mtimeMs: 0 }
+    // Written and edited since: the holder's edit, against the new commit.
+    if (done.has(w.path)) { kept.push(w.path); block.files[w.path] = { blob: w.blob, mode: w.mode, size: w.size, mtimeMs: 0 }; continue }
+    // Edited before it was written: the holder's edit and the move's change are merged.
+    redo.push({ path: w.path, old: w.old, theirs: w })
   }
   if (toWrite.length) {
     const get = await contentsFor(client, block.quilt, plan.rev, toWrite, block._codec)
@@ -551,20 +733,35 @@ export async function rebuild (client, dir, block) {
     const cur = onDisk(dir, block, r.path)
     if (!cur) { delete block.files[r.path]; if (!done.has(r.path)) removed.push(r.path); continue }
     if (!done.has(r.path) && same(cur, r.old)) { removeEntry(dir, r.path, r.old?.mode); pruneEmpty(dir, r.path); delete block.files[r.path]; removed.push(r.path); continue }
-    kept.push(r.path)
+    // Removed and made again since: a new file of the holder's. Edited before the remove: merged.
+    if (done.has(r.path)) { kept.push(r.path); delete block.files[r.path] } else redo.push({ path: r.path, old: r.old, theirs: null })
+  }
+  for (const m of plan.merges || []) {
+    // A planned merge carried out (its file is the plan's) needs only its record.
+    const cur = onDisk(dir, block, m.path)
+    if (done.has(m.path) || (m.out && cur && cur.id === m.out)) { settleRecord(block, m); if (m.how === 'merged') kept.push(m.path); else if (m.how === 'conflict') conflicted.push(m.path); continue }
+    redo.push({ path: m.path, old: m.old, theirs: m.record ? { path: m.path, ...m.record } : null })
+  }
+  if (redo.length) {
+    const theirs = redo.map((r) => r.theirs).filter((e) => e && e.mode !== 'conflict')
+    const get = await contentsFor(client, block.quilt, plan.rev, theirs, block._codec)
+    for (const m of await planMerges(client, block, redo, { from: plan.from, get, to: plan.to, oursOf: (p) => oursOnDisk(dir, block, p) })) {
+      applyMerge(dir, block, m)
+      if (m.how === 'merged') kept.push(m.path); else if (m.how === 'conflict') conflicted.push(m.path)
+    }
   }
   block.at = plan.to
   if (plan.square) { block.square = plan.square.id; block.square_short = plan.square.short; block.head = plan.square.head; block.line = plan.square.line }
   saveBlock(dir, block)
   fs.rmSync(path.join(dir, JOURNAL_FILE), { force: true })
-  return { finished: true, to: plan.to, written, removed, kept: kept.sort(cmpPath), changes: localChanges(dir, block).length }
+  return { finished: true, to: plan.to, written, removed, kept: kept.sort(cmpPath), conflicted: conflicted.sort(cmpPath), changes: localChanges(dir, block).length }
 }
 
 /** status: the folder's changes, and the square as the server sees it. */
 export async function status (client, dir, block) {
   const changes = localChanges(dir, block).map(({ bytes, open, abs, ...c }) => c)
   const square = block.square ? await client.square(block.quilt, block.square) : null
-  const conflicted = Object.entries(block.files).filter(([, f]) => f.term).map(([p]) => p)
+  const conflicted = [...new Set([...Object.entries(block.files).filter(([, f]) => f.term).map(([p]) => p), ...pullConflicts(dir, block)])].sort(cmpPath)
   return { dir, quilt: block.quilt, square, line: block.line, on_line: isLineCheckout(block), paths: block.paths, at: block.at, changes, conflicted, stale: !!(square && square.state === 'open' && square.head !== block.head), ...(square && square.state && square.state !== 'open' ? { square_closed: square.state } : {}) }
 }
 
@@ -585,6 +782,7 @@ export async function commitFolder (client, dir, block, { message, paths = [], a
   if (!block.square && !isLineCheckout(block)) throw new Error('This folder holds one revision, not a line; open a square (seam square open) to commit.')
   const changes = localChanges(dir, block, { paths })
   if (!changes.length) return { nothing: true }
+  refuseConflicted(pullConflicts(dir, block).filter((p) => changes.some((c) => c.path === p)), 'commit')
   // A clone (a checkout of a line): the first commit opens a square by itself, titled by the
   // message and based on the commit the folder holds, so it undoes nothing main gained since.
   const opened = block.square ? null : await openForCommit(client, dir, block, message)
@@ -646,10 +844,12 @@ async function openForCommit (client, dir, block, message) {
 
 /**
  * seam pull: a line checkout moves to the line's tip (uncommitted edits stay; a path changed both
- * here and there keeps this folder's version and is reported); a square folder rebases the square
- * onto its line and moves there.
+ * here and there is merged, or left conflicted and reported: syncTo); a square folder rebases the
+ * square onto its line and moves there. Refused while the last pull's conflicts are unsettled.
  */
 export async function pull (client, dir, block) {
+  // As git refuses to pull over unmerged files: the last pull's conflicts are settled first.
+  refuseConflicted(pullConflicts(dir, block), 'pull again')
   if (block.square) {
     // The square was merged (or abandoned) from elsewhere: the folder goes to its line's tip.
     const sq = await client.square(block.quilt, block.square)
@@ -657,19 +857,19 @@ export async function pull (client, dir, block) {
       const short = block.square_short || block.square
       const tip = (await client.show(block.quilt, sq.line, { format: 'none' })).commit.id
       const s = await toLineTip(client, dir, block, sq.line, tip)
-      return { left: { square: short, state: sq.state }, line: sq.line, at: tip, written: s.written, kept: s.kept }
+      return { left: { square: short, state: sq.state }, line: sq.line, at: tip, written: s.written, merged: s.merged, conflicted: s.conflicted }
     }
     const r = await client.rebase(block.quilt, block.square, { expect_head: block.head })
     if (r.noop) return { rebased: false, noop: true, square: r.square }
     const s = await syncTo(client, dir, block, r.square.head || r.square.base, { square: r.square })
-    return { rebased: true, square: r.square, result: r, written: s.written, kept: s.kept }
+    return { rebased: true, square: r.square, result: r, written: s.written, merged: s.merged, conflicted: s.conflicted }
   }
   if (!isLineCheckout(block)) throw new Error('This folder holds one revision, not a line: seam checkout <line or square> moves it.')
   const to = (await client.show(block.quilt, block.line, { format: 'none' })).commit.id
   const from = block.at
   if (to === from) return { noop: true, line: block.line, at: to }
   const s = await syncTo(client, dir, block, to)
-  return { line: block.line, from, at: to, written: s.written, kept: s.kept }
+  return { line: block.line, from, at: to, written: s.written, merged: s.merged, conflicted: s.conflicted }
 }
 
 /** After a merge: the folder leaves the merged square and stands on the line's new tip. */
@@ -684,6 +884,7 @@ export async function toLineTip (client, dir, block, line, tip) {
 export async function amendFolder (client, dir, block, { message, paths = [], allow = [] }) {
   if (!block.square) throw new Error('This folder is a read-only checkout of a line; there is no commit of yours to amend.')
   const changes = localChanges(dir, block, { paths })
+  refuseConflicted(pullConflicts(dir, block).filter((p) => changes.some((c) => c.path === p)), 'amend')
   const blobs = changes.filter((c) => c.bytes || c.open).map((c) => c.open ? { kind: 'blob', id: c.blob, size: c.size, open: c.open } : { kind: 'blob', id: c.blob, bytes: block.sealed ? block._codec.seal(c.bytes) : c.bytes })
   if (blobs.length) await client.upload(block.quilt, blobs)
   const list = changes.map((c) => c.status === 'deleted' ? { path: c.path, op: 'delete' } : { path: c.path, op: 'put', blob: c.blob, mode: c.mode || 'file' })

package/lib/quilts/cli.js

@@ -9,8 +9,8 @@ import { quiltClient } from './client.js'
 import { runChecks, readRunnerConfig, listenForWork } from './runner.js'
 import { startDaemon, askDaemon } from './daemon.js'
 import { rebuild as rebuildBlock, conflictStyle } from './block.js'
-import { describeRebuild, describeOpened } from './describe.js'
-import { findBlock, checkout, status as blockStatus, commitFolder, amendFolder, syncTo, localDiff, saveBlock, pull, toLineTip, restore, reset, clean, localChanges, bytesOf, livePatch } from './block.js'
+import { describeRebuild, describeOpened, describeBoth } from './describe.js'
+import { findBlock, checkout, status as blockStatus, commitFolder, amendFolder, syncTo, localDiff, saveBlock, pull, toLineTip, restore, reset, clean, localChanges, bytesOf, livePatch, resolvePulled } from './block.js'
 import { describeLog, describeShow, describeDiff, describeBlame, describeStatus, describeMerge, describeWrite, describeSquare, describeSquareStatus, describeEvents, describeTag, describeRelease, describeImport, describeImportRecord, describeRestore, describeReset, describeClean, describeLive, describeClaims, describeHandoff, describeFinished, describeResolutions, describeLiveSet, describeLiveJoin, describeMergeBase, describeStack, describeStackDiff, describeGrep, describeBisect, describeCheck, describeReviews, describeInterdiff, describeReviewed, describeSquareCheck, describePolicy, describeKeys, describeTokens, describeNewToken, describeBlock, describeBlocks, describeProtections, describeTeams, describeAccess, describeRedacted, describeRedactions, describeMetrics, describeSquarePolicy, describePolicyVersions, describeOrg, describeOrgs, describeOrgLog, describeOrgDomain, describeApp, describeApps, describeAppKey, describeInstall, describeInstalls, describeRequest, describeRequests, describeOrgTeams, describeCheckRuns, describeRerun, describeAncestor, describeContains, describePipeline, describeWatches, describeSearch, describePublicReads } from './describe.js'
 import { verifyQuilt, describeVerify } from './attest.js'
 import { confirmWithLocalKey } from './linepolicy.js'
@@ -326,7 +326,7 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         if (by === 'paths' && !groups.length) throw new Error('Split by which paths? seam square split [sq] docs,README.md src (one group per new square), or --by claim')
         const r = await client.split(needQuilt(), own ? pos[1] : needSquare(), { by, ...(by === 'paths' ? { groups } : {}), ...(flags['--stacked'] ? { stacked: true } : {}), ...(flags['--title'] ? { titles: [flags['--title']] } : {}) })
         const text = [`Kept in ${r.square.short}: ${r.kept.join(', ') || '(nothing)'}`, ...r.squares.map((q) => `New ${describeSquare(q)}: ${q.paths.join(', ')}`)].join('\n')
-        if (found && block.square === r.square.id) { const st = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); return print(r, `${text}\n${st.written} file(s) updated in the folder.`) }
+        if (found && block.square === r.square.id) { const st = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); return print(r, `${text}\n${st.written} file(s) updated in the folder.` + describeBoth(st)) }
         return print(r, text)
       }
       if (sub === 'show') { const sq = await client.square(needQuilt(), pos[1] || needSquare()); return print(sq, describeSquareStatus(sq)) }
@@ -346,7 +346,7 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
     case 'pull': {
       if (!found) throw new Error('seam pull works in a block folder: run it in a folder made by seam clone or seam checkout.')
       const r = await pull(client, found.dir, block)
-      const kept = r.kept?.length ? `\nKept your own version of ${r.kept.join(', ')} (changed on both sides): compare with seam diff.` : ''
+      const kept = describeBoth(r)
       if (r.noop) return print(r, block.square ? `Already up to date: ${block.square_short || block.square} sits on ${block.line}'s tip.` : `Already up to date with ${block.line}.`)
       if (r.left) return print(r, `${r.left.square} was ${r.left.state}; the folder is now on ${r.line} (${r.at.slice(0, 12)}, ${r.written} file(s) updated).` + kept)
       if (r.rebased) return print(r, describeWrite(r.result, 'Rebased') + `\n${r.written} file(s) updated in the folder.` + kept)
@@ -943,7 +943,7 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         const mine = found && (target === block.square_short || target === block.square)
         const r = await client.mergeSquare(needQuilt(), target, { from, ...(mine ? { expect_head: block.head } : {}), message })
         let text = r.noop ? `Already up to date: ${from} is in ${target}.` : describeWrite(r, `Merged ${from} into ${target}:`)
-        if (mine && !r.noop) { const st = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${st.written} file(s) updated in the folder.` }
+        if (mine && !r.noop) { const st = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${st.written} file(s) updated in the folder.` + describeBoth(st) }
         return print(r, text)
       }
       const sqId = pos[0] && pos[0].startsWith('sq:') ? pos[0] : needSquare()
@@ -952,26 +952,26 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       // Merged from its own folder: the folder moves to the line's new tip, ready for the next change.
       if (found && sqId === block.square && r.ok && r.merged?.commit && !flags['--dry-run']) {
         const s = await toLineTip(client, found.dir, block, r.merged.line || into, r.merged.commit)
-        text += `\nThe folder is now on ${r.merged.line || into} (${s.written} file(s) updated); your next commit opens a new square.`
+        text += `\nThe folder is now on ${r.merged.line || into} (${s.written} file(s) updated); your next commit opens a new square.` + describeBoth(s)
       }
       // The refused merge left the square rebased onto the tip with its conflicts: bring the folder there.
       if (found && sqId === block.square && !r.ok && r.head && r.head !== block.head) {
         const s = await syncTo(client, found.dir, block, r.head, { square: r.square })
-        text += `\nThe folder now holds the rebased files (${s.written} written)${s.kept.length ? `; kept your own version of ${s.kept.join(', ')}` : ''}.`
+        text += `\nThe folder now holds the rebased files (${s.written} written).` + describeBoth(s)
       }
       return print(r, text)
     }
     case 'rebase': {
       const r = await client.rebase(needQuilt(), needSquare(), { ...(found ? { expect_head: block.head } : {}), onto: flags['--onto'] })
       let text = r.noop ? 'Already on the tip.' : describeWrite(r, 'Rebased')
-      if (found && !r.noop) { const s = await syncTo(client, found.dir, block, r.square.head || r.square.base, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` }
+      if (found && !r.noop) { const s = await syncTo(client, found.dir, block, r.square.head || r.square.base, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` + describeBoth(s) }
       return print(r, text)
     }
     case 'cherry-pick': {
       if (!pos[0]) throw new Error('seam cherry-pick <revision>')
       const r = await client.cherryPick(needQuilt(), needSquare(), { from: pos[0], ...(found ? { expect_head: block.head } : {}) })
       let text = describeWrite(r, 'Picked')
-      if (found) { const s = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` }
+      if (found) { const s = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` + describeBoth(s) }
       return print(r, text)
     }
     case 'revert': {
@@ -988,15 +988,20 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         const rel = (p) => found ? path.relative(found.dir, path.resolve(cwd, p)).split(path.sep).join('/') : p
         const r = await client.resolve(needQuilt(), needSquare(), { ...(found ? { expect_head: block.head } : {}), entries: pos.map((p) => ({ path: rel(p), rule })), ...(flags['--no-remember'] ? { remember: false } : {}) })
         let text = describeWrite(r, 'Resolved')
-        if (found) { const s = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` }
+        if (found) { const s = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` + describeBoth(s) }
         return print(r, text)
       }
       const choose = flags['--ours'] ? 'ours' : flags['--theirs'] ? 'theirs' : flags['--base'] ? 'base' : flags['--delete'] ? 'delete' : flags['--suggestion'] ? 'suggestion' : flags['--keep-both'] ? 'keep_both' : flags['--side'] != null ? Number(flags['--side']) : null
+      // A conflict seam pull left in this folder is settled here, not on the server.
+      if (found && block.conflicts && pos.length && (choose === 'ours' || choose === 'theirs')) {
+        const r = await resolvePulled(client, found.dir, block, { paths: pos.map((p) => path.resolve(cwd, p)), choose })
+        return print(r, `Settled ${r.settled.join(', ')}: ${choose === 'theirs' ? 'took upstream\'s version' : 'kept your version'}. Commit when ready.`)
+      }
       if (choose === null || !pos.length) throw new Error('seam resolve <path>... --ours | --theirs | --base | --suggestion | --side n | --delete | --keep-both | --rule <step> [--no-remember] (or edit the file and commit it without the markers)')
       const rel = (p) => found ? path.relative(found.dir, path.resolve(cwd, p)).split(path.sep).join('/') : p
       const r = await client.resolve(needQuilt(), needSquare(), { ...(found ? { expect_head: block.head } : {}), entries: pos.map((p) => ({ path: rel(p), choose })), ...(flags['--no-remember'] ? { remember: false } : {}) })
       let text = describeWrite(r, 'Resolved')
-      if (found) { const s = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` }
+      if (found) { const s = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` + describeBoth(s) }
       return print(r, text)
     }
     case 'resolutions': {

package/lib/quilts/describe.js

@@ -103,6 +103,17 @@ export function describeWarnings (warnings = []) {
   return said.length ? ['Changed under your code (a warning, not a refusal: check it still fits):', ...said] : []
 }
 
+/**
+ * What a move of a folder (seam pull, a rebase) did with files changed on both sides: merged into
+ * the folder's edits, or left conflicted to settle. `diff` and `resolve` name the commands to use.
+ */
+export function describeBoth (r, { diff = 'seam diff', resolve = 'seam resolve <path> --ours | --theirs' } = {}) {
+  const out = []
+  if (r.merged?.length) out.push(`Merged upstream's changes into your edits to ${r.merged.join(', ')}: compare with ${diff}.`)
+  if (r.conflicted?.length) out.push(`Conflict in ${r.conflicted.join(', ')} (changed on both sides): settle each by editing out the conflict markers, or with ${resolve}, then commit.`)
+  return out.map((l) => '\n' + l).join('')
+}
+
 export function describeStatus (st) {
   const lines = []
   if (st.square) lines.push(describeSquareStatus(st.square, { prefix: 'On square ' }))
@@ -613,5 +624,5 @@ export function describePublicReads (r) {
 /** What block.rebuild did (05 "Rebuilt, never repaired"). */
 export function describeRebuild (r) {
   if (!r.finished) return `Nothing to rebuild: the folder is whole${r.changes ? ` (${r.changes} uncommitted change(s), all yours)` : ''}.`
-  return `Finished a move that stopped part way: ${r.written.length} file(s) written, ${r.removed.length} removed${r.kept.length ? `; kept your edits to ${r.kept.join(', ')}` : ''}. The folder is on ${String(r.to).slice(0, 12)}.`
+  return `Finished a move that stopped part way: ${r.written.length} file(s) written, ${r.removed.length} removed${r.kept.length ? `; kept your edits to ${r.kept.join(', ')}` : ''}. The folder is on ${String(r.to).slice(0, 12)}.` + describeBoth({ conflicted: r.conflicted })
 }

package/lib/quilts/fastmerge.js

@@ -0,0 +1,43 @@
+// A fast front for merge-smart.js's mergeSmart (whose node-diff3 LCS is quadratic: seconds on a
+// 7,000-line file). A clean line merge comes from the Myers hunks in textdiff.js (`nway`, the
+// same N-way merge the conflict format uses); only a clash goes to mergeSmart's ladder, and then
+// with the lines all three versions share at the start and end cut off, so it reads only the
+// region that differs. Same answer, same `how`, as mergeSmart for a clean merge; a clash is
+// mergeSmart's own answer on the middle, put back between the shared lines.
+import { mergeSmart as mergeSmartWith, STEPS } from './merge-smart.js'
+import { nway } from './conflict-format.js'
+
+/** `opts.allow`: the highest ladder step that may settle a clash (07's auto_combine); none: every step. */
+export function fastMerge (base, ours, theirs, opts = {}) {
+  const [o, a, b] = [base.split('\n'), ours.split('\n'), theirs.split('\n')]
+  const regions = nway(o, [a, b])
+  if (regions.every((r) => r.ok)) return { text: regions.flatMap((r) => r.ok).join('\n'), conflicts: [], how: 'lines' }
+  const mergeSmart = (x, y, z) => mergeSmartWith(x, y, z, opts)
+  // Every clash is two inserts at one place the base had nothing (07's `additive` step): ours
+  // then theirs, shared leading lines once. Shared trailing lines are kept on both sides, not
+  // once as 07 says: two added functions share their closing `}`, and taking it once dropped
+  // one function's closing brace (found by real agents adding functions side by side).
+  if ((opts.allow == null || STEPS[opts.allow] >= STEPS.additive) && regions.every((r) => r.ok || (!r.base.length && r.sides.length === 2))) {
+    return { text: regions.flatMap((r) => r.ok || additive(r.sides[0], r.sides[1])).join('\n'), conflicts: [], how: 'additive' }
+  }
+  // Shared lines at both ends, leaving at least one line in each middle.
+  const min = Math.min(o.length, a.length, b.length) - 1
+  let p = 0
+  while (p < min && o[p] === a[p] && o[p] === b[p]) p++
+  let s = 0
+  while (s < min - p && o[o.length - 1 - s] === a[a.length - 1 - s] && o[o.length - 1 - s] === b[b.length - 1 - s]) s++
+  if (!p && !s) return mergeSmart(base, ours, theirs)
+  const mid = (x) => x.slice(p, x.length - s).join('\n')
+  const m = mergeSmart(mid(o), mid(a), mid(b))
+  if (m.text === '') return mergeSmart(base, ours, theirs) // zero lines or one empty line: ambiguous
+  return { ...m, text: [...o.slice(0, p), m.text, ...o.slice(o.length - s)].join('\n') }
+}
+
+/** Two inserts at one place: ours, then what theirs adds after the leading lines both share. */
+function additive (a, b) {
+  let pre = 0
+  while (pre < a.length && pre < b.length && a[pre] === b[pre]) pre++
+  if (pre === b.length) return a
+  if (pre === a.length) return b
+  return [...a, ...b.slice(pre)]
+}

package/lib/quilts/merge-smart.js

@@ -0,0 +1,125 @@
+// The merge ladder seam settles a clash with (plans/quilt-source-control/07, steps 1 and 2): line
+// by line as git does, then two inserts at one place, a one-line import both sides changed,
+// whitespace-only changes, and word by word within the clashing lines. Seam's own copy, so the
+// Quilt app's merges can change without changing how a quilt merges.
+import { diff3Merge } from 'node-diff3'
+
+const lines = (s) => s.split('\n')
+
+/**
+ * A text's line endings: 'crlf' (every line ends \r\n), 'lf' (none does), 'mixed', or null (one line:
+ * nothing to tell).
+ */
+function eolOf (s) {
+  if (typeof s !== 'string' || !s.includes('\n')) return null
+  if (!s.includes('\r\n')) return 'lf'
+  return s.replace(/\r\n/g, '').includes('\n') ? 'mixed' : 'crlf'
+}
+
+/**
+ * The merges compare lines, so a side saved with Windows line endings (\r\n) against a base and other
+ * side with \n differs on every line: diff3 then reads it as "ours deleted the whole file and inserted
+ * it again", the delete loses to theirs' edits and the insert stays, and the file comes out as both
+ * versions one after the other (task 7b480c8b07c4fa02: web/lib/docs.js, CRLF old + LF new, every
+ * export twice). When the sides' line endings differ, all three are merged with \n and the result is
+ * written in the line endings of the side that changed them from the base (ours when both did, or
+ * when there is no base to tell), as any other edit to the file would be kept.
+ */
+function eolAware (merge) {
+  return function (base, ours, theirs, ...rest) {
+    const eols = [base, ours, theirs].map(eolOf)
+    const seen = new Set(eols.filter(Boolean))
+    if (!seen.has('crlf') || seen.size < 2) return merge(base, ours, theirs, ...rest)
+    const [eb, eo, et] = eols
+    const target = (eo && eo !== eb) ? eo : (et && et !== eb) ? et : (eo || et || eb)
+    const lf = (s) => typeof s === 'string' ? s.replace(/\r\n/g, '\n') : s
+    const back = (t) => target === 'crlf' && typeof t === 'string' ? t.replace(/\n/g, '\r\n') : t
+    const r = merge(lf(base), lf(ours), lf(theirs), ...rest)
+    return typeof r === 'string' ? back(r) : { ...r, text: back(r.text) }
+  }
+}
+
+/** Two blocks inserted at one place, as one: shared leading and trailing lines once, the middles in order. */
+function addedBoth (a, b) {
+  let pre = 0
+  while (pre < a.length && pre < b.length && a[pre] === b[pre]) pre++
+  let post = 0
+  while (post < a.length - pre && post < b.length - pre && a[a.length - 1 - post] === b[b.length - 1 - post]) post++
+  return [...a.slice(0, pre), ...a.slice(pre, a.length - post), ...b.slice(pre, b.length - post), ...a.slice(a.length - post)]
+}
+
+const IMPORT = /^(\s*import\s*\{)([^}]*)(\}\s*from\s*(['"][^'"]+['"]).*)$/
+
+/** Both sides changed the same one-line import of the same module: the union of its names, or null. */
+function sameImport (o, a, b) {
+  if (o.length !== 1 || a.length !== 1 || b.length !== 1) return null
+  const [mo, ma, mb] = [IMPORT.exec(o[0]), IMPORT.exec(a[0]), IMPORT.exec(b[0])]
+  if (!mo || !ma || !mb || mo[4] !== ma[4] || ma[4] !== mb[4]) return null
+  const names = (m) => m[2].split(',').map((s) => s.trim()).filter(Boolean)
+  const [no, na, nb] = [names(mo), names(ma), names(mb)]
+  const gone = new Set(no.filter((n) => !na.includes(n) || !nb.includes(n)))
+  const all = [...na, ...nb.filter((n) => !na.includes(n))].filter((n) => !gone.has(n))
+  return [`${ma[1]} ${all.join(', ')} ${ma[3]}`]
+}
+
+const normWs = (l) => l.replace(/\s+/g, ' ').trim()
+const sameIgnoringWs = (a, b) => a.length === b.length && a.every((l, i) => normWs(l) === normWs(b[i]))
+const TOKEN = /\s+|\w+|[^\w\s]/g
+
+/** Two blocks of lines merged word by word against their base, or null when the same words changed on both sides. */
+function mergeWords (o, a, b) {
+  const tok = (ls) => ls.join('\n').match(TOKEN) || []
+  const regions = diff3Merge(tok(a), tok(o), tok(b), { excludeFalseConflicts: true })
+  if (regions.some((r) => !r.ok)) return null
+  return regions.map((r) => r.ok.join('')).join('').split('\n')
+}
+
+/**
+ * The clash ladder's mechanical and structural steps (plan §7.3, steps 1 and 2): mergeAdditive, then
+ * each region still clashing is tried again ignoring whitespace (a side that only reindented loses
+ * to the side that changed something), then word by word within the clashing lines (two edits to
+ * different words of one line both land); a file marked merge=union takes both sides, ours first.
+ * Returns { text, conflicts, how } with `how` the step that settled it: 'lines', 'whitespace',
+ * 'words' or 'union'; `conflicts` lists what no step could settle (text then holds ours there).
+ */
+export const mergeSmart = eolAware(function mergeSmart (base, ours, theirs, { union = false, allow = null } = {}) {
+  const regions = diff3Merge(lines(ours), lines(base), lines(theirs), { excludeFalseConflicts: true })
+  const out = []
+  const conflicts = []
+  let how = 'lines'
+  const rank = { lines: 0, additive: 0.5, whitespace: 1, words: 2, union: 3 }
+  const step = (h) => { if (rank[h] > rank[how]) how = h }
+  for (const r of regions) {
+    if (r.ok) { out.push(...r.ok); continue }
+    const c = r.conflict
+    const settled = ladder(c, { union, allow })
+    if (settled) { out.push(...settled.lines); step(settled.how); continue }
+    conflicts.push({ base: c.o, ours: c.a, theirs: c.b })
+    out.push(...c.a)
+  }
+  return { text: out.join('\n'), conflicts, how }
+})
+
+// The ladder's steps in order (07's auto_combine): `allow` names the highest that may settle a
+// region (words always runs; a word merge is only ever a suggestion to the caller).
+export const STEPS = { lines: 0, additive: 1, whitespace: 2, words: 3 }
+
+/**
+ * mergeSmart's steps for one region both sides changed ({ o, a, b }): { lines, how }, or null when
+ * none settles it. Without `allow` every step runs and two inserts are reported as 'lines', as the
+ * Quilt app's ladder does; with it, steps above it are skipped and they are reported as 'additive'.
+ */
+function ladder (c, { union = false, allow = null } = {}) {
+  if (union) return { lines: [...c.a, ...c.b], how: 'union' }
+  const may = (s) => allow == null || STEPS[s] <= STEPS[allow]
+  const both = may('additive') ? (c.o.length === 0 ? addedBoth(c.a, c.b) : sameImport(c.o, c.a, c.b)) : null
+  if (both) return { lines: both, how: allow == null ? 'lines' : 'additive' }
+  if (may('whitespace')) {
+    if (sameIgnoringWs(c.a, c.b)) return { lines: c.a, how: 'whitespace' } // the same change, spaced differently
+    if (sameIgnoringWs(c.a, c.o)) return { lines: c.b, how: 'whitespace' } // ours only reindented
+    if (sameIgnoringWs(c.b, c.o)) return { lines: c.a, how: 'whitespace' } // theirs only reindented
+  }
+  const words = mergeWords(c.o, c.a, c.b)
+  if (words) return { lines: words, how: 'words' }
+  return null
+}

package/lib/quilts/tools.js

@@ -16,8 +16,8 @@ import { eventLine, describeLog, describeShow, describeDiff, describeBlame, desc
 import { signWithLocalKey, localKey, makeLocalKey, signingKeyFile } from './signing.js'
 import { startDaemon, askDaemon } from './daemon.js'
 import { rebuild as rebuildBlock, conflictStyle } from './block.js'
-import { describeRebuild, describeOpened } from './describe.js'
-import { status as blockStatus, commitFolder, amendFolder, syncTo, pull, toLineTip, checkout, restore, reset, clean, localChanges, bytesOf, livePatch } from './block.js'
+import { describeRebuild, describeOpened, describeBoth } from './describe.js'
+import { status as blockStatus, commitFolder, amendFolder, syncTo, pull, toLineTip, checkout, restore, reset, clean, localChanges, bytesOf, livePatch, resolvePulled } from './block.js'
 
 export const SEAM_TOOLS = ['seam_quilts', 'seam_open_square', 'seam_squares', 'seam_log', 'seam_show', 'seam_diff', 'seam_blame', 'seam_cat', 'seam_ls', 'seam_commit', 'seam_merge', 'seam_rebase', 'seam_revert', 'seam_cherry_pick', 'seam_resolve', 'seam_square_status', 'seam_square_handoff', 'seam_abandon', 'seam_square_merged', 'seam_reopen', 'seam_fold', 'seam_split', 'seam_events', 'seam_events_webhook', 'seam_line_list', 'seam_line_new', 'seam_line_freeze', 'seam_line_unfreeze', 'seam_line_require', 'seam_reviews', 'seam_review', 'seam_tag_list', 'seam_tag', 'seam_release_list', 'seam_release', 'seam_import_git', 'seam_import_remote', 'seam_github', 'seam_github_import', 'seam_import_status', 'seam_import_authors', 'seam_import_poke', 'seam_import_cutover', 'seam_export_remote', 'seam_export_status', 'seam_restore', 'seam_reset', 'seam_clean', 'seam_live', 'seam_live_join', 'seam_live_set', 'seam_bisect', 'seam_grep', 'seam_search', 'seam_describe', 'seam_merge_base', 'seam_stack', 'seam_migrations_dir', 'seam_claims', 'seam_claim', 'seam_unclaim', 'seam_check', 'seam_resolutions', 'seam_forget_resolution', 'seam_sign', 'seam_keys', 'seam_key_add', 'seam_key_remove', 'seam_token_list', 'seam_token_new', 'seam_token_revoke', 'seam_protections', 'seam_protections_set', 'seam_team_set', 'seam_verify', 'seam_redact', 'seam_redactions', 'seam_seal', 'seam_secret_scanning', 'seam_public', 'seam_sealed', 'seam_policy', 'seam_line_policy_versions', 'seam_orgs', 'seam_org_log', 'seam_org_domain', 'seam_apps', 'seam_app', 'seam_app_key', 'seam_app_manager', 'seam_app_install', 'seam_app_request', 'seam_org_member', 'seam_org_team', 'seam_agent_token_new', 'seam_agent_token_list', 'seam_agent_token_revoke', 'seam_agents_make_lines', 'seam_checks', 'seam_check_rerun', 'seam_reparent', 'seam_archive', 'seam_unarchive', 'seam_hide', 'seam_unhide', 'seam_square_edit', 'seam_share', 'seam_unshare', 'seam_export_tarball', 'seam_claim_request', 'seam_claim_withdraw', 'seam_claim_handoff', 'seam_claim_finish', 'seam_blocks', 'seam_block_open', 'seam_block_touch', 'seam_block_close', 'seam_ancestor', 'seam_contains', 'seam_pipeline', 'seam_watch', 'seam_unwatch', 'seam_absorb', 'seam_interdiff', 'seam_apply_suggestion', 'seam_infra_paths', 'seam_owner_idle_hours', 'seam_public_reads', 'seam_export_archive', 'seam_metrics', 'seam_daemon', 'seam_block_rebuild', 'seam_clone', 'seam_pull', 'seam_member_add']
 
@@ -84,7 +84,7 @@ export const SEAM_DESCRIPTIONS = {
   seam_block_touch: 'The heartbeat of an open block: keeps it open (blocks untouched for seven days are closed) and moves a live block to the square\'s current head; add and remove change its folders.',
   seam_clone: 'Checks out a line of a quilt (main by default) into a new folder on this computer, ready to work: the first commit there opens a square by itself. The folder is named after the quilt unless dir is given.',
   seam_member_add: 'Adds a member to the quilt or changes their level (an admin): email (a person; one with no Seam account yet is invited, and is in the quilt from their first sign-in) or member_id (person:… or agent:…), level read, write or admin (default write; remove takes them out).',
-  seam_pull: 'In a block folder: brings the line\'s new patches in (uncommitted edits stay); on a square, rebases it onto its line\'s tip; on a square merged from elsewhere, moves the folder to the line\'s tip.',
+  seam_pull: 'In a block folder: brings the line\'s new patches in (uncommitted edits stay; a file changed on both sides is merged, or given conflict markers to settle before it is committed); on a square, rebases it onto its line\'s tip; on a square merged from elsewhere, moves the folder to the line\'s tip.',
   seam_block_rebuild: 'In a block folder: finishes a move of the folder (rebase, checkout of its square) that stopped part way, from the journal in .seam; edits made meanwhile are kept as yours. On a whole folder it writes nothing.',
   seam_block_close: 'Closes a block (its row on the server). The square, its work and any files on disk are untouched.',
   seam_token_list: 'The quilt\'s tokens (keys for one quilt, for CI and scripts): id, name, read or write, and whether revoked. Admins only.',
@@ -165,7 +165,7 @@ export const SEAM_DESCRIPTIONS = {
   seam_rebase: 'Moves your square onto the tip of its line (or onto a revision). Conflicts become conflict markers in the square, never a stop.',
   seam_revert: 'Undoes a patch (or commit): a new square from the tip whose one commit inverts it. Merge that square with seam_merge.',
   seam_cherry_pick: 'Applies one commit\'s change (from) to your square as a new commit.',
-  seam_resolve: 'Settles conflicted files in your square by choosing a side: entries [{ path, choose: ours | theirs | base | suggestion | delete | keep_both }]; suggestion takes the word-level merge a conflict offers (its suggestion, shown when the merge is refused); when both sides renamed one file, ours or theirs keeps that side\'s path and keep_both keeps both. Or rule: additive (both inserts, in order), whitespace (the side that changed more than spacing), words (word by word) or union (both sides, ours first). (Or edit the file and commit it without the markers.) The answer is remembered: the same conflict met again in a rebase or merge is settled the same way, unless remember: false.',
+  seam_resolve: 'Settles conflicted files in your square by choosing a side: entries [{ path, choose: ours | theirs | base | suggestion | delete | keep_both }]; suggestion takes the word-level merge a conflict offers (its suggestion, shown when the merge is refused); when both sides renamed one file, ours or theirs keeps that side\'s path and keep_both keeps both. Or rule: additive (both inserts, in order), whitespace (the side that changed more than spacing), words (word by word) or union (both sides, ours first). (Or edit the file and commit it without the markers.) In a block folder, choose ours or theirs also settles a conflict seam_pull left there. The answer is remembered: the same conflict met again in a rebase or merge is settled the same way, unless remember: false.',
   seam_resolutions: 'The remembered resolutions: conflicts settled once that seam settles the same way when they come back, per file, and per clashing region within the same squares (path: only that file\'s; hunks: true lists the regions too). One unused for 90 days is dropped.',
   seam_forget_resolution: 'Forgets a remembered resolution (key: its key or first 8+ characters), so that conflict is asked about again next time.'
 }
@@ -327,7 +327,7 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
   const needQuilt = () => { if (!quilt) throw new Error('Name the quilt (quilt: its slug or id); seam_quilts lists yours.'); return quilt }
   const needSquare = () => { if (!square) throw new Error('Name the square (square: sq:…); seam_open_square opens one, seam_squares lists them.'); return square }
   const inFolder = found && block && square === block.square && quilt === block.quilt
-  const sync = async (head, sq) => { if (inFolder && head && head !== block.head) { const s = await syncTo(client, found.dir, block, head, { square: sq }); return `\nThe folder now holds the square's files (${s.written} updated).` } return '' }
+  const sync = async (head, sq) => { if (inFolder && head && head !== block.head) { const s = await syncTo(client, found.dir, block, head, { square: sq }); return `\nThe folder now holds the square's files (${s.written} updated).` + describeBoth(s, { diff: 'seam_diff', resolve: 'seam_resolve (choose ours or theirs)' }) } return '' }
   try {
     switch (name) {
       case 'seam_line_require': {
@@ -592,7 +592,7 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
       case 'seam_pull': {
         if (!found) throw new Error('seam_pull works on a block folder: run seam mcp in a folder made by seam clone or seam checkout.')
         const r = await pull(client, found.dir, block)
-        const kept = r.kept?.length ? `\nKept your own version of ${r.kept.join(', ')} (changed on both sides): compare with seam_diff.` : ''
+        const kept = describeBoth(r, { diff: 'seam_diff', resolve: 'seam_resolve (choose ours or theirs)' })
         if (r.noop) return block.square ? `Already up to date: ${block.square_short || block.square} sits on ${block.line}'s tip.` : `Already up to date with ${block.line}.`
         if (r.left) return `${r.left.square} was ${r.left.state}; the folder is now on ${r.line} (${r.at.slice(0, 12)}, ${r.written} file(s) updated).` + kept
         if (r.rebased) return describeWrite(r.result, 'Rebased') + `\n${r.written} file(s) updated in the folder.` + kept
@@ -695,7 +695,7 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
         const r = await client.merge(needQuilt(), args.into || block?.line || 'main', { square: needSquare(), ...(inFolder ? { expect_head: block.head } : {}), message: args.message, dry_run: !!args.dry_run, on_conflict: args.on_conflict, ...(args.commit_live === false ? { commit_live: false } : {}) })
         if (r.ok && inFolder && !args.dry_run && r.merged?.commit) {
           const st = await toLineTip(client, found.dir, block, r.merged.line, r.merged.commit)
-          return describeMerge(r) + `\nThe folder is now on ${r.merged.line} (${st.written} file(s) updated); the next commit opens a new square.`
+          return describeMerge(r) + `\nThe folder is now on ${r.merged.line} (${st.written} file(s) updated); the next commit opens a new square.` + describeBoth(st, { diff: 'seam_diff', resolve: 'seam_resolve (choose ours or theirs)' })
         }
         return describeMerge(r) + (!r.ok && r.head ? await sync(r.head, r.square) : '')
       }
@@ -716,6 +716,13 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
         return describeWrite(r, 'Picked') + await sync(r.square.head, r.square)
       }
       case 'seam_resolve': {
+        // A conflict seam pull left in this folder is settled there, not on the server.
+        const choices = new Set(args.entries.map((e) => e.choose))
+        if (found && block?.conflicts && choices.size === 1 && (choices.has('ours') || choices.has('theirs')) && args.entries.every((e) => block.conflicts[e.path])) {
+          const choose = [...choices][0]
+          const r = await resolvePulled(client, found.dir, block, { paths: args.entries.map((e) => path.join(found.dir, e.path)), choose })
+          return `Settled ${r.settled.join(', ')}: ${choose === 'theirs' ? 'took upstream\'s version' : 'kept your version'}. Commit when ready.`
+        }
         const r = await client.resolve(needQuilt(), needSquare(), { ...(inFolder ? { expect_head: block.head } : {}), entries: args.entries, ...(args.remember === false ? { remember: false } : {}) })
         return describeWrite(r, 'Resolved') + await sync(r.square.head, r.square)
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyquilt/seam",
-  "version": "0.140.0",
+  "version": "0.142.0",
   "description": "seam: Seam's command. Git's verbs for source control that runs on the server, built for many agents and people at once.",
   "license": "UNLICENSED",
   "type": "module",