@heyquilt/seam 0.141.0 → 0.143.0

package/bin/seam.js

@@ -20,6 +20,7 @@ Docs: https://seam.heyquilt.com/docs
   seam login [--no-browser]          Sign in with your Seam account (seam.heyquilt.com)
   seam logout | seam whoami
   seam computers [list | signout <id or name>]   computers signed in to your account (seam login)
+  seam handle [<new>]                your name in your repos' addresses (<handle>/<repo>); with <new>, change it
   seam account delete --confirm <your email>   delete your Seam account (your patches stay)
   seam agent new <name> | list | key <name> | revoke <name> | relink [agent:<id>]   your agents and their keys
   seam oauth client new <name> --redirect <uri> | list | revoke <client_id>   apps that ask people for access (OAuth 2, PKCE)
@@ -131,6 +132,13 @@ async function main () {
   if (cmd === 'whoami') { const a = readAccount(); if (!a) { process.exitCode = 1; return console.log('Not signed in.') } return console.log(`${a.account.name} (${a.account.email})`) }
   if (cmd === 'agent') return agentCommand(argv[0], argv[1])
   if (cmd === 'computers') return computersCommand(argv[0], argv[1])
+  // Your handle (11.2, 2026-10-29): your repos are <handle>/<repo>, on the site and in every command.
+  if (cmd === 'handle') {
+    const go = signedIn()
+    if (!argv[0]) { const me = await go('GET', '/v1/me'); return console.log(me.account?.handle ? `${me.account.handle}: your repos are ${me.account.handle}/<repo>.` : 'Your account has no handle on this Seam server.') }
+    const r = await go('PUT', '/v1/me/handle', { handle: argv[0] })
+    return console.log(`Your handle is ${r.handle}: your repos are ${r.handle}/<repo> now, and their old addresses stop working.`)
+  }
   if (cmd === 'account') {
     const i = argv.indexOf('--confirm')
     if (argv[0] !== 'delete' || i < 0 || !argv[i + 1]) fail('seam account delete --confirm <your email>')

package/lib/quilts/attest.js

@@ -53,27 +53,40 @@ const keyIdOf = (raw) => 'ed25519:' + crypto.createHash('sha256').update(raw).di
  * The server's attestation key from SEAM_ATTESTATION_KEY (an Ed25519 private key: PKCS8 PEM, or
  * base64 of its PKCS8 DER), or a new one for this process when none is given.
  */
-export function attestationKey (secret) {
+export const attestationKey = (secret) => ed25519Key(secret, 'SEAM_ATTESTATION_KEY')
+
+/**
+ * An Ed25519 signing key from a setting's value (PKCS8 PEM, or base64 of its PKCS8 DER), or a new
+ * one for this process when none is given: { id, public_key, ephemeral, sign(text) → base64 }.
+ */
+export function ed25519Key (secret, setting) {
   let key
   if (secret) {
     const s = String(secret).trim()
-    key = s.includes('BEGIN') ? crypto.createPrivateKey(s) : crypto.createPrivateKey({ key: Buffer.from(s, 'base64'), format: 'der', type: 'pkcs8' })
-    if (key.asymmetricKeyType !== 'ed25519') throw new Error('SEAM_ATTESTATION_KEY is not an Ed25519 private key')
+    try {
+      key = s.includes('BEGIN') ? crypto.createPrivateKey(s) : crypto.createPrivateKey({ key: Buffer.from(s, 'base64'), format: 'der', type: 'pkcs8' })
+    } catch { throw new Error(`${setting} is not an Ed25519 private key (PKCS8 PEM or base64 DER)`) }
+    if (key.asymmetricKeyType !== 'ed25519') throw new Error(`${setting} is not an Ed25519 private key`)
   } else key = crypto.generateKeyPairSync('ed25519').privateKey
   const raw = crypto.createPublicKey(key).export({ format: 'der', type: 'spki' }).subarray(SPKI_PREFIX.length)
   return { id: keyIdOf(raw), public_key: raw.toString('base64'), ephemeral: !secret, sign: (text) => crypto.sign(null, Buffer.from(text), key).toString('base64') }
 }
 
+/** Whether `sig` (bytes) is an Ed25519 signature of `text` by the raw public key `publicKey` (base64). */
+export function ed25519Verify (publicKey, text, sig) {
+  try {
+    const pub = crypto.createPublicKey({ key: Buffer.concat([SPKI_PREFIX, Buffer.from(String(publicKey), 'base64')]), format: 'der', type: 'spki' })
+    return crypto.verify(null, Buffer.from(text), pub, sig)
+  } catch { return false }
+}
+
 /** Whether `a` is a good attestation of `row` under one of `keys` ([{ id, public_key }]). */
 export function verifyAttestation (a, row, keys) {
   if (!a) return 'unsigned'
   if (a.seq !== row.seq || a.kind !== row.kind || a.row_hash !== rowHash(row)) return 'mismatch'
   const k = keys.find((x) => x.id === a.key_id)
   if (!k) return 'unknown_key'
-  try {
-    const pub = crypto.createPublicKey({ key: Buffer.concat([SPKI_PREFIX, Buffer.from(k.public_key, 'base64')]), format: 'der', type: 'spki' })
-    if (!crypto.verify(null, Buffer.from(attestationText(a)), pub, Buffer.from(String(a.sig), 'base64'))) return 'bad_signature'
-  } catch { return 'bad_signature' }
+  if (!ed25519Verify(k.public_key, attestationText(a), Buffer.from(String(a.sig), 'base64'))) return 'bad_signature'
   return a.late ? 'late' : 'ok'
 }
 
@@ -188,7 +201,8 @@ export function attestationOps (svc, attester) {
  * against `keys` (pinned by the caller) or the server's published keys.
  */
 export async function verifyQuilt (client, quilt, { after = 0, keys = null } = {}) {
-  const pinned = keys || (await client.attestationKeys()).keys
+  // The published keys also hold the want-ticket key (tickets.js), which never signs a log row.
+  const pinned = keys || (await client.attestationKeys()).keys.filter((k) => !k.use || k.use === 'attestation')
   const rows = []; const atts = []
   let from = Number(after) || 0
   for (;;) {

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, findMarkers } 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,192 @@ 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). Markers of
+ * any kind left in it (its tag edited away, git's typed by hand) keep it open (07 ruling 2026-10-29).
+ */
+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}`))) || !!findMarkers(bytes)) }
+    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)
+}
+
+/**
+ * As the server refuses it (service.js, 07 ruling 2026-10-29): a conflicted file among `paths` (a
+ * term from the server, or a conflict a move left) that no longer carries its tag but still holds
+ * conflict markers is refused, `markers_left`, naming the file and line. Here too for a sealed
+ * quilt, whose server cannot read the file.
+ */
+function refuseMarkersLeft (dir, block, paths, verb) {
+  for (const p of paths) {
+    const term = block.files[p]?.term
+    const tags = [...(block.conflicts?.[p]?.tags || []), ...(term ? [term.slice(0, 12)] : [])]
+    if (!tags.length) continue
+    let bytes = null
+    try { bytes = fs.readFileSync(absOf(dir, p)) } catch { continue }
+    if (tags.some((t) => bytes.includes(Buffer.from(`quilt-conflict ${t}`)))) continue
+    const m = findMarkers(bytes)
+    if (m) throw Object.assign(new Error(`${p}:${m.line} still holds conflict markers (${m.text}), so it does not settle the conflict: edit every marker block out, or seam resolve ${p} --ours | --theirs, then ${verb}.`), { code: 'markers_left', path: p, line: m.line })
+  }
+}
+
+/** 07 ruling 2026-10-29: markers in a file with no conflict are committed as written, with a warning. */
+function withLocalMarkers (block, changes, r) {
+  const found = changes.filter((c) => c.bytes && !block.files[c.path]?.term).map((c) => ({ c, m: findMarkers(c.bytes) })).filter((x) => x.m)
+  if (!found.length) return r
+  const have = new Set((r.warnings || []).filter((w) => w.kind === 'markers_in_file').map((w) => w.path))
+  const more = found.filter((x) => !have.has(x.c.path)).map((x) => ({ kind: 'markers_in_file', path: x.c.path, line: x.m.line, local: true }))
+  return more.length ? { ...r, warnings: [...(r.warnings || []), ...more] } : r
+}
+
+/** 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 +715,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 +762,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 +811,9 @@ 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 }
+  const open = pullConflicts(dir, block).filter((p) => changes.some((c) => c.path === p))
+  refuseMarkersLeft(dir, block, changes.filter((c) => c.status !== 'deleted').map((c) => c.path), 'commit')
+  refuseConflicted(open, '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)
@@ -622,7 +851,7 @@ export async function commitFolder (client, dir, block, { message, paths = [], a
   block.at = r.square.head
   block.head = r.square.head
   saveBlock(dir, block)
-  const out = withLocalScan(block, changes, allow, r)
+  const out = withLocalMarkers(block, changes, withLocalScan(block, changes, allow, r))
   if (opened) out.opened = opened
   return out
 }
@@ -646,10 +875,14 @@ 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.
+  const open = pullConflicts(dir, block)
+  refuseMarkersLeft(dir, block, open, 'pull again')
+  refuseConflicted(open, '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 +890,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 +917,9 @@ 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 })
+  const open = pullConflicts(dir, block).filter((p) => changes.some((c) => c.path === p))
+  refuseMarkersLeft(dir, block, changes.filter((c) => c.status !== 'deleted').map((c) => c.path), 'amend')
+  refuseConflicted(open, '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' })
@@ -696,7 +932,7 @@ export async function amendFolder (client, dir, block, { message, paths = [], al
   block.at = r.square.head
   block.head = r.square.head
   saveBlock(dir, block)
-  return withLocalScan(block, changes, allow, r)
+  return withLocalMarkers(block, changes, withLocalScan(block, changes, allow, r))
 }
 
 /** The folder's changes as a unified diff against `at` (diff with no revision, in a block). */

package/lib/quilts/claims.js

@@ -2,8 +2,8 @@
 // "this square is working on these paths" so nobody else spends work on them. A write under a
 // claimed pattern from another open square on the same line is refused (412 claim_refused) and the
 // writer is told who holds it and why. A claim lasts while its square is open: merging, abandoning
-// or archiving the square lets go of it. Merges never check claims; overlapping work that was
-// written before a claim existed still meets at the merge (07).
+// or archiving the square lets go of it. Merges never check claims, and a claim never refuses work
+// written before it existed: that work commits, and overlapping work still meets at the merge (07).
 import { QuiltError, squareShort } from './errors.js'
 import { uuidv7 } from './ids.js'
 
@@ -200,20 +200,54 @@ export async function liveClaims (store, q, at = Date.now(), idleMs = 0) {
   return out
 }
 
+/** Whether live entry or tree entry `e` holds the same change as `ch` (a put of the same blob and mode, or a delete). */
+const sameChange = (e, ch) => ch.op === 'delete' ? !!e && e.op === 'delete' : !!e && e.op === ch.op && e.blob === ch.blob && (e.mode ?? null) === (ch.mode ?? null)
+
+/**
+ * 06 "Where a claim is checked" (ruling 2026-10-29): whether square `sq`'s change `ch` was written
+ * before claim `c` was granted, so the claim does not refuse it. It was when the square's live work
+ * already held the same change from before the claim's `at` (each live entry carries the time it was
+ * written, `at`; older rows only the row's), or when the square's head already holds it (`held`:
+ * resending it is not a new write).
+ */
+async function writtenBefore (ch, c, live, held) {
+  if (!ch) return false
+  const e = (live?.changes || []).find((x) => x.path === ch.path)
+  if (sameChange(e, ch) && Number(e.at ?? live.at ?? Infinity) < Number(c.at || 0)) return true
+  if (held) {
+    const h = await held(ch.path)
+    if (ch.op === 'delete' ? !h : (h && h.blob === ch.blob && h.mode === ch.mode)) return true
+  }
+  return false
+}
+
 /**
  * Refuses a write to `paths` from square `sq` when another open square on its line claims one.
  * Given the `writer` (a commit, not live work, which repeats), the refusal is also written to the
- * square's log so the writer hears claim.refused (12) wherever it reads events.
+ * square's log so the writer hears claim.refused (12) wherever it reads events. Given the write's
+ * `changes`, a path whose change was written before the claim existed is not refused (06): the
+ * square's live work held it from before the claim's `at`, or (`held(path)`, the head's entry) the
+ * head already has it. `live` is the square's live row when the caller has read it already.
  */
-export async function guardClaims (store, q, sq, paths, at = Date.now(), idleMs = 0, writer = null) {
+export async function guardClaims (store, q, sq, paths, at = Date.now(), idleMs = 0, writer = null, { changes = null, held = null, live } = {}) {
   if (!paths.length) return
   // A stacked square writes under its parents' claims (06): it builds on their work.
   const mine = new Set([sq.id])
   for (let p = sq; p.parent_square && mine.size <= 10;) { mine.add(p.parent_square); p = await store.getSquare(p.parent_square); if (!p) break }
   const others = (await liveClaims(store, q, at, idleMs)).filter((c) => !mine.has(c.square_id) && c.line === sq.line)
+  const byPath = changes ? new Map(changes.map((ch) => [ch.path, ch])) : null
   for (const c of others) {
     const m = globMatcher(c.pattern)
-    const hit = paths.find((p) => m(p))
+    let hit = null
+    for (const p of paths) {
+      if (!m(p)) continue
+      if (byPath) {
+        if (live === undefined) live = store.getLive ? await store.getLive(q, sq.id) : null
+        if (await writtenBefore(byPath.get(p), c, live, held)) continue
+      }
+      hit = p
+      break
+    }
     if (hit) {
       if (writer) {
         const pos = queueOf(await store.claimRequests(q), c).findIndex((r) => r.by_square === sq.id)

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'
@@ -313,10 +313,10 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         const moved = r.amended.filter((a) => a.paths.length).map((a) => `${a.paths.join(', ')} into ${a.commit_before.slice(0, 12)}`)
         return print(r, `${moved.length ? `Absorbed ${moved.join('; ')} (${r.amended.length} commit(s) rewritten).` : 'Nothing to absorb.'}${r.left_live ? ` Still live: ${r.left_paths.join(', ')}.` : ''}`)
       }
-      // seam square fold [sq] --into sq:<id> | split [sq] <paths,...> <paths,...> | --by claim [--stacked] [--title t]
+      // seam square fold [sq] --into sq:<id> [--no-commit-live] | split [sq] <paths,...> <paths,...> | --by claim [--stacked] [--title t]
       if (sub === 'fold') {
         if (!flags['--into']) throw new Error('Fold into which square? seam square fold [sq:from] --into sq:<id>')
-        const r = await client.fold(needQuilt(), pos[1] || needSquare(), { into: flags['--into'], message })
+        const r = await client.fold(needQuilt(), pos[1] || needSquare(), { into: flags['--into'], message, ...(flags['--no-commit-live'] ? { commit_live: false } : {}) })
         return print(r, describeWrite(r, `Folded ${r.folded.short} into ${r.square.short}:`))
       }
       if (sub === 'split') {
@@ -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/conflict-format.js

@@ -4,9 +4,10 @@
 // side's change laid onto the first side, `ontoFirst`) only the clashing regions are marked and the
 // rest of the file is merged text; a deleted side is an empty side labelled "(deleted by <who>)". Also the `git` format (diff3 markers with the `|||||||` base section, two sides
 // only). Every block's first line carries the term's tag, so a
-// file committed with these markers is still conflicted (service.js, block.js).
+// file committed with these markers is still conflicted (service.js, block.js). findMarkers finds
+// markers of any kind (no tag, an older tag, git's), which never settle a conflict (07 ruling 2026-10-29).
 import { diff3Merge } from 'node-diff3'
-import { hunks, splitLines } from './textdiff.js'
+import { hunks, splitLines, isText } from './textdiff.js'
 
 /** `old` → `now` as `-`/`+`/` ` lines (every line of both, in order). */
 export function lineDiff (old, now) {
@@ -264,3 +265,27 @@ export function resolveMarkers (regions, k) {
   const lines = regions.flatMap((r) => r.ok || r.sides[k].lines)
   return lines.length ? lines.join('\n') + '\n' : ''
 }
+
+// A conflict marker line: exactly seven `<` or `>` (Seam's and git's opening and closing lines), or
+// git's `|||||||` base line, then a space or the line's end. `=======`, `+++++++` and `%%%%%%%`
+// alone are not markers: a markdown underline or a diff's own lines look like them.
+const MARKER = /^(?:<{7}|>{7}|\|{7})(?: |$)/
+const NEEDLES = ['<<<<<<<', '>>>>>>>', '|||||||'].map((s) => Buffer.from(s))
+
+/**
+ * The first conflict marker in a file, as `{ line (1-based), text }`, or null. Markers count only
+ * at the start of a line (a CR before the newline is ignored); a file that is not text (binary,
+ * over 8 MiB) has none. Whatever their tag (the current term's, an older one's, none), markers in
+ * a conflicted file mean it is not settled (07 ruling 2026-10-29; service.js, block.js).
+ */
+export function findMarkers (bytes) {
+  if (!bytes || !bytes.length) return null
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes)
+  if (!NEEDLES.some((n) => buf.includes(n)) || !isText(buf)) return null
+  const lines = buf.toString('utf8').split('\n')
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i].endsWith('\r') ? lines[i].slice(0, -1) : lines[i]
+    if (MARKER.test(l)) return { line: i + 1, text: l.length > 80 ? l.slice(0, 80) + '…' : l }
+  }
+  return null
+}

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 ' }))
@@ -129,7 +140,10 @@ export function describeWrite (r, verb = 'Done') {
   if (r.conflicted) bits.push(`${r.conflicted} conflicted path${r.conflicted === 1 ? '' : 's'}: ${(r.terms || []).map((t) => `${t.path} (${t.kind})`).join(', ')}`)
   const reused = (r.combined || []).filter((c) => c.how === 'reuse')
   if (reused.length) bits.push(`Settled the way it was settled before: ${reused.map((c) => `${c.path} (by ${c.by})`).join(', ')}`)
-  for (const w of r.warnings || []) bits.push(`Warning: ${w.path}${w.line ? `:${w.line}` : ''} looks like a secret (${w.rule}, ${w.id})${w.local ? ', found on this computer' : ''}`)
+  for (const w of r.warnings || []) {
+    if (w.kind === 'markers_in_file') bits.push(`Warning: ${w.path}:${w.line} holds conflict markers; it was committed as written${w.local ? ' (found on this computer)' : ''}`)
+    else bits.push(`Warning: ${w.path}${w.line ? `:${w.line}` : ''} looks like a secret (${w.rule}, ${w.id})${w.local ? ', found on this computer' : ''}`)
+  }
   return bits.join('\n')
 }
 
@@ -613,5 +627,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.',
@@ -138,7 +138,7 @@ export const SEAM_DESCRIPTIONS = {
   seam_events: 'What happened to your work since you last looked: patch.merged (a patch changed files your open square changed, and whether your merge would now conflict), conflict.added (a conflict was kept in your square), square.handoff, square.restacked (your stacked square was moved onto its parent\'s new head or the line, with how many conflicts it now holds), check.requested (you run a check a line names you for: run it on the commit and report with seam_check and its run_key). Pass after (the cursor from the last answer) to get only new ones. Pass wait (seconds, up to 30) to wait for the next one instead of answering at once.',
   seam_events_webhook: 'Has the quilt server POST your events to a URL (signed with HMAC-SHA256 over <timestamp>.<body>, retried 3 times), so you are woken instead of polling: url, events (default all), secret (made for you if left out). url: "off" removes them all. add: true keeps your other webhooks (up to 5); remove: true removes the one at url.',
   seam_absorb: 'Puts your square\'s uncommitted live work into the commit of the square that last changed each file (amending it and rewriting the commits above it), so a fix to commit 2 of 5 needs no manual rebase. Files no commit of the square changed stay live.',
-  seam_fold: 'Folds a square (square) into another square you hold (into): its work becomes one commit there and the square closes. Overlapping changes become conflict markers in the target.',
+  seam_fold: 'Folds a square (square) into another square you hold (into): its work becomes one commit there and the square closes. Live work it shared (seam_live_set) is committed on it first and goes along (commit_live: false refuses with live_work instead). Overlapping changes become conflict markers in the target.',
   seam_split: 'Splits your square: by paths (groups: [[paths], ...]) or by claim (one group per claim on the square that covers a changed path; the claim and its holder go with it). Each group moves to a new square (same base) as one commit; the largest group, and paths no group names, stay in this square. stacked: true chains the new squares on this one in order instead of opening them side by side.',
   seam_log: 'History, newest first: rev (default main, or your square, or a..b), paths to limit it, limit (default 20). follow: true with one path follows the file through its renames; search: "<text>" keeps only commits that changed how many times the text appears (git log -S); match: "<regex>" keeps commits whose added or removed lines match (git log -G). message (with message_regex, ignore_case) filters on the commit message (git log --grep); author (member id or part of a name), on_behalf_of, task, since and until (an ISO date, or 2h, 3d, 1w) filter on who, what for and when. group_by (author, on_behalf_of, task, tool) gives counts with lines added and removed instead of commits; graph: true names the square each merge brought in; include_hidden: true shows a square\'s commits replaced by an amend. When there is more, pass the answer\'s cursor for the next page. Each patch on main is one line\'s merge. With one path on a line, existed says whether it was ever there and, if it is gone now, last_present is the last patch it was there in.',
   seam_describe: 'Names a revision (rev, default main) by the nearest tag behind it: v1.0 on the tag itself, v1.0-3-<commit> three commits past it, the commit alone when no tag is behind it.',
@@ -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.'
 }
@@ -304,7 +304,7 @@ export const SEAM_INPUTS = {
   seam_events: { quilt: QUILT, after: z.number().int().min(0).optional(), wait: z.number().int().min(0).max(30).optional(), kinds: z.array(z.enum(['patch.merged', 'patch.reverted', 'conflict.added', 'square.handoff', 'square.restacked', 'check.requested', 'check.cancelled', 'check.culprit', 'check.verdict', 'watch.triggered', 'policy.needed', 'review.comment', 'review.decision', 'review.requested', 'review.stale', 'claim.granted', 'claim.refused', 'claim.expired', 'claim.handoff', 'export.state'])).optional() },
   seam_events_webhook: { quilt: QUILT, url: z.string().max(2000), events: z.array(z.enum(['patch.merged', 'patch.reverted', 'conflict.added', 'square.handoff', 'square.restacked', 'check.requested', 'check.cancelled', 'check.culprit', 'check.verdict', 'watch.triggered', 'policy.needed', 'review.comment', 'review.decision', 'review.requested', 'review.stale', 'claim.granted', 'claim.refused', 'claim.expired', 'claim.handoff', 'export.state'])).optional(), secret: z.string().min(16).max(200).optional(), add: z.boolean().optional(), remove: z.boolean().optional() },
   seam_absorb: { quilt: QUILT, square: SQUARE },
-  seam_fold: { quilt: QUILT, square: SQUARE, into: z.string().max(100).describe('The square (sq:…) that takes the work'), message: z.string().max(65536).optional() },
+  seam_fold: { quilt: QUILT, square: SQUARE, into: z.string().max(100).describe('The square (sq:…) that takes the work'), message: z.string().max(65536).optional(), commit_live: z.boolean().optional().describe('Default true: the square\'s shared live work is committed on it first and folded with it; false refuses (live_work) while it has any') },
   seam_split: { quilt: QUILT, square: SQUARE, by: z.enum(['paths', 'claim']).optional().describe('paths (the default) or claim'), groups: z.array(z.array(z.string().max(1000)).min(1).max(2000)).min(1).max(20).optional().describe('Paths (files or directories) per new square, for by: paths'), titles: z.array(z.string().max(200)).max(20).optional(), stacked: z.boolean().optional().describe('Chain the new squares on this one in order') },
   seam_merge: { quilt: QUILT, square: SQUARE, from: z.string().max(200).optional().describe('Merge this square (sq:…) or revision into your square instead of merging your square into a line'), into: z.string().max(100).optional().describe('The line, default main'), message: z.string().max(65536).optional(), dry_run: z.boolean().optional(), on_conflict: z.enum(['rebase', 'leave']).optional(), commit_live: z.boolean().optional().describe('Default true: your square\'s shared live work (seam_live_set) is committed first and merged with it; false merges the committed head as it stands') },
   seam_rebase: { quilt: QUILT, square: SQUARE, onto: REV },
@@ -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': {
@@ -503,7 +503,7 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
         return `${moved.length ? `Absorbed ${moved.join('; ')} (${r.amended.length} commit(s) rewritten).` : 'Nothing to absorb.'}${r.left_live ? ` Still live: ${r.left_paths.join(', ')}.` : ''}` + (r.amended.length ? await sync(r.square.head, r.square) : '')
       }
       case 'seam_fold': {
-        const r = await client.fold(needQuilt(), needSquare(), { into: args.into, message: args.message, ...(inFolder ? { expect_head: block.head } : {}) })
+        const r = await client.fold(needQuilt(), needSquare(), { into: args.into, message: args.message, ...(args.commit_live === false ? { commit_live: false } : {}), ...(inFolder ? { expect_head: block.head } : {}) })
         return describeWrite(r, `Folded ${r.folded.short} into ${r.square.short}:`)
       }
       case 'seam_split': {
@@ -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.141.0",
+  "version": "0.143.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",