heyquilt 0.3.90 → 0.3.106

package/src/relay-githttp.js

@@ -9,7 +9,7 @@
 // reaches the agent's machine: git signs in to the relay with the agent's Quilt pass.
 import fs from 'node:fs'
 import path from 'node:path'
-import { spawn } from 'node:child_process'
+import { spawn, spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { runGit, syncStateOf } from './relay-git.js'
 import { upstreamsOf } from './relay-upstream.js'
@@ -61,13 +61,19 @@ export async function ensureView (dataDir, room, mirror) {
 export async function syncViewRefs (room, dir, repo) {
   const recs = upstreamsOf(room)
   const want = new Map()
+  // Several of the session's branches can follow one GitHub branch (branches started from main all
+  // follow main): the view's branch is the one of that name, else the default branch, else the first.
+  const rank = (key, rec) => (key === rec.ref ? 2 : key === room.defaultKey ? 1 : 0)
+  const ranked = new Map()
   for (const [key, rec] of Object.entries(recs)) {
     if (!rec || rec.repo !== repo || !rec.ref || rec.gone) continue
+    if (ranked.has(rec.ref) && ranked.get(rec.ref) >= rank(key, rec)) continue
     const st = room.meta.sync && room.meta.sync[key] ? syncStateOf(room, key) : null
     const sha = (st && st.base) || rec.sha
     if (!/^[0-9a-f]{40}$/.test(sha || '')) continue
     if (!(await runGit(dir, ['cat-file', '-e', `${sha}^{commit}`])).ok) continue
     want.set(rec.ref, sha)
+    ranked.set(rec.ref, rank(key, rec))
   }
   // Branches pushed through the view that the session doesn't follow (an agent's own): where GitHub took them.
   for (const [ref, sha] of Object.entries(room.meta.viewBranches || {})) {
@@ -82,13 +88,24 @@ export async function syncViewRefs (room, dir, repo) {
   return want
 }
 
+/**
+ * Whether `git http-backend` runs here: it is a separate package on some systems (Alpine's git-daemon),
+ * and without it every request to /git/<room>.git would fail. Asked without a request, the CGI answers
+ * one of its own (a 500 with headers); a git without it says it has no such command and writes nothing.
+ */
+export function gitHttpBackendWorks (git = 'git') {
+  const r = spawnSync(git, ['http-backend'], { env: { ...process.env, GIT_PROJECT_ROOT: '', REQUEST_METHOD: '' }, encoding: 'utf8', timeout: 10000 })
+  return !r.error && /^(Status|Content-Type|Expires):/im.test(r.stdout || '')
+}
+
 /**
  * Serves one smart-HTTP request (`pathInfo`: /<room>.git/info/refs, …/git-upload-pack, …/git-receive-pack)
  * with git's own CGI, `git http-backend`, over `root` (the folder of view repositories). `env` reaches
- * the hooks of a push (who pushes, and how to ask the relay). Never throws; answers 500 when git fails.
+ * the hooks of a push (who pushes, and how to ask the relay). Never throws; answers 500 when git fails,
+ * and tells `onError` why (what git said), so the relay's log has it.
  */
-export function serveGit (req, res, { root, pathInfo, query = '', env = {} }) {
-  const cgi = spawn('git', ['http-backend'], {
+export function serveGit (req, res, { root, pathInfo, query = '', env = {}, git = 'git', onError = () => {} }) {
+  const cgi = spawn(git, ['http-backend'], {
     env: {
       ...process.env,
       ...env,
@@ -106,6 +123,7 @@ export function serveGit (req, res, { root, pathInfo, query = '', env = {} }) {
   })
   let head = Buffer.alloc(0)
   let headed = false
+  let said = ''
   cgi.stdout.on('data', (chunk) => {
     if (headed) return res.write(chunk)
     head = Buffer.concat([head, chunk])
@@ -121,12 +139,23 @@ export function serveGit (req, res, { root, pathInfo, query = '', env = {} }) {
       const v = line.slice(i + 1).trim()
       if (k === 'status') status = parseInt(v, 10) || 200; else headers[k] = v
     }
+    if (status >= 500) onError(`git http-backend answered ${status}`)
     res.writeHead(status, headers)
     res.write(head.subarray(at + 4))
   })
-  cgi.stdout.on('end', () => { if (!headed) { res.writeHead(500); } res.end() })
-  cgi.stderr.on('data', () => {})
-  cgi.on('error', () => { if (!res.headersSent) res.writeHead(500); res.end() })
+  let done = false
+  cgi.stdout.on('end', () => { if (headed) res.end() })
+  // With no answer, wait for git to exit, not just for its stdout to end: what it said on stderr
+  // can come after (on a busy machine it did, and the log said "nothing said").
+  cgi.on('close', () => {
+    if (headed || done) return
+    done = true
+    onError(`git http-backend gave no answer: ${said.trim() || 'nothing said'}`)
+    if (!res.headersSent) res.writeHead(500)
+    res.end()
+  })
+  cgi.stderr.on('data', (chunk) => { if (said.length < 2000) said += chunk.toString() })
+  cgi.on('error', (err) => { if (done) return; done = true; onError(`git http-backend did not start: ${err.message}`); if (!res.headersSent) res.writeHead(500); res.end() })
   req.pipe(cgi.stdin)
   cgi.stdin.on('error', () => {})
 }

package/src/relay-mcp.js

@@ -28,7 +28,7 @@ import { commitRequestMessage } from './commit-request.js'
 import { GIT_COMMIT_DESCRIPTION, gitCommitSchema, agentPrefix, slug } from './github-commit.js'
 import { liveSyncOn, agentCommitRefusal, ownFiles } from './relay-outbound.js'
 import { syncStatusText, SYNC_STATUS_DESCRIPTION } from './sync-words.js'
-import { clashAction, heldForClash, CLASH_DESCRIPTION, clashSchema } from './relay-clash.js'
+import { clashAction, CLASH_DESCRIPTION, clashSchema } from './relay-clash.js'
 import { agentCommitsOf, repoRecordFor, POLICY_WORDS, pullRequestsFor, mergeForMember, describePulls, describeMerge, PULLS_DESCRIPTION, MERGE_DESCRIPTION, mergeSchema, agentsCanCommit, unpublishedFor, unpublishedRefusal, finishTaskFor, gitCommitFor, describeGitCommit, gitStatusFor, describeGitStatus, gitLogFor, describeGitLog, gitDiffFor, describeGitDiff, GIT_STATUS_DESCRIPTION, GIT_LOG_DESCRIPTION, GIT_DIFF_DESCRIPTION, GIT_REVERT_DESCRIPTION } from './relay-commit.js'
 import { UpdateCheck } from './update-check.js'
 import { TASK_WORKFLOW, pickupBrief, doneRefusal, verifiedEnough, verifiedLine, qaRefusal, qaNotesEnough, qaNotesLine, pickChecklist, MAX_VERIFIED } from './agent-task-workflow.js'
@@ -42,6 +42,7 @@ import { DEFAULT_KEY, validBranchKey } from './branchdocs.js'
 import { LOAD_FILES } from './relay-upstream.js'
 import { hostedRooms, hostedIn, newHosted } from './hosted-agents.js'
 import { turnSyncStep, ROOM_KEY } from './relay-turn-sync.js'
+import { describeSecretNames, SECRET_NAMES_DESCRIPTION } from './secret-names.js'
 
 const FEED_CAP = 300
 const ACTIVITY_CAP = 300
@@ -90,7 +91,7 @@ export const HOSTED_INSTRUCTIONS =
   'HTTP is only for an agent with no computer. If you can run shell commands anywhere (a computer, a cloud machine, a sandbox), you must use the Quilt CLI there instead (`quilt agent join`, then `quilt join <invite> --agent <your name>`): files sync to disk and you show as live. ' +
   'A session has a branch for each git branch its members work on, each with its own files: quilt_status and quilt_branches list them and who is on each, and your first call on files puts you on the busiest one, where you stay until you pick another with quilt_git_branch (create: true loads a branch that is on GitHub but not yet in the session, at its latest commit; any other new branch starts from a copy of the files you have). ' +
   'Commits pushed or merged on GitHub come into your branch by themselves: through a member\'s folder on it when one is online and can fetch, otherwise the relay brings them in from GitHub about every 10 minutes. quilt_sync_branch asks for that now (at most once a minute per branch), for example after a PR merged. ' +
-  'When those commits clash with the session\'s uncommitted work, nothing is brought in and the relay gives one agent a task ("Bring N commits from origin/main into the session"), with each file and what changed upstream in its comments. If it is yours: for each file, quilt_read_file, fold in the upstream change while keeping the session\'s work, and quilt_write_file the merged file without conflict markers; each such write makes the relay look again at once, and the rest of the commits come in when every file merges. If you kept one side whole, move the task to QA once all files are done: the relay then takes the files as merged. The task closes itself. ' +
+  'When those commits and the session\'s uncommitted work changed the same files, Quilt merges them on its own (where both changed the same lines, the newer edit stays, and whoever wrote the other lines is told): there is never a merge for you to do. ' +
   'A private repository needs a read-only GitHub token on the relay: when quilt_status says the relay can\'t read it, ask the session owner (quilt_github_token sets it, owner only). You have no folder here, so git is the quilt_git_* tools: taking a task (quilt_move_task to doing) puts you on a branch of your own, quilt/<you>/<task>; quilt_git_commit commits your changed files there and opens the pull request tied to the task; quilt_git_status says where you stand, quilt_git_diff what differs from GitHub, quilt_git_log what was committed, quilt_git_revert puts GitHub\'s version of a file back. The session\'s branch itself is open to agents only when the owner lets agents push to any branch. Work only in the session has not shipped: commit before you move a task to QA. Done merges the task\'s pull request once its checks pass: a person moves it to Done, or you when the owner lets agents commit to any branch. quilt_git_pull_requests lists open pull requests with their checks; quilt_git_merge merges one (agents: when the owner lets agents commit to any branch). When agents may not commit, ask a person with quilt_request_commit. Pushes and merges on GitHub reach the session within seconds. ' +
   'When a branch syncs with GitHub (quilt_git_status and quilt_branches say so), pushes and merges on GitHub come into the session by themselves, and nothing goes to GitHub until someone commits: quilt_git_commit commits your own changes (with_others: true takes others\' changes in the same files too, as co-authors). A file GitHub and the session both changed is held, and its merger proposes the merge with quilt_clash (the reviewer accepts). Releasing a file only lets go of your claim: it doesn\'t publish anything by itself. ' +
   TASK_WORKFLOW
@@ -824,7 +825,6 @@ function sessionTools (server, ctx) {
       description: CLASH_DESCRIPTION,
       inputSchema: clashSchema(z)
     }, async (args, { room, branch }) => {
-      if (!room.mirrors || !room.cfg || !room.cfg.gitSync) return fail('This session doesn\'t sync live with GitHub, so there are no held clashes here.')
       try {
         const r = await clashAction(room, { who: { name: me, kind: ctx.kind === 'agent' ? 'agent' : 'human', access: ctx.access(room) }, key: keyOf(branch), action: args.action, path: args.path || '', content: args.content ?? null, checks: args.checks || null, force: args.force === true })
         return r.ok ? text(r.text) : fail(r.text)
@@ -1005,7 +1005,6 @@ function sessionTools (server, ctx) {
     if (a && a.role === 'viewer') return fail('You can only view this session; file changes are refused.')
     const refusal = a && changeRefusal(a, rel)
     if (refusal) return fail(`${refusal[0].toUpperCase()}${refusal.slice(1)}.`)
-    if (ctx.kind === 'agent' && room.meta.sync && heldForClash(room, branch ? branch.key : DEFAULT_KEY, rel)) return fail(`${rel} is held while a clash with GitHub is merged (quilt_clash status): propose the merged file with quilt_clash propose instead of writing it, so nothing half-merged reaches anyone.`)
     const claim = claimsOf(room).find((c) => c.by !== me && globMatcher(c.pattern)(rel))
     if (claim) return fail(heldRefusal(rel, claim))
     if (blobs.get(rel)?.stored) return fail(`${rel} is a large file kept in storage; it can't be changed here.`)
@@ -1158,7 +1157,7 @@ function sessionTools (server, ctx) {
         step: z.enum(['plan', 'push', 'pull', 'done']).describe('plan, then push, pull and done'),
         slot: z.string().min(8).max(64).describe('The slot in your QUILT_AGENT_KEY'),
         branch: z.string().max(200).optional().describe('plan: the folder\'s git branch; used when the session has it'),
-        files: z.record(z.string(), z.union([z.string(), z.object({ text: z.string().optional(), base64: z.string().optional(), deleted: z.boolean().optional() })])).optional().describe('plan and done: { path: sha1 }; push: { path: { text } | { base64 } | { deleted: true } }'),
+        files: z.record(z.string(), z.union([z.string(), z.object({ text: z.string().optional(), base64: z.string().optional(), deleted: z.boolean().optional(), mtime: z.number().optional() })])).optional().describe('plan and done: { path: sha1 }; push: { path: { text, mtime } | { base64, mtime } | { deleted: true } } (mtime: when the folder last changed it, ms)'),
         paths: z.array(z.string().max(1024)).max(10000).optional().describe('pull: the paths to fetch')
       }
     }, (args, parts) => {
@@ -1192,7 +1191,6 @@ function sessionTools (server, ctx) {
             if (a && a.role === 'viewer') return { kind: 'aside', why: 'you can only view this session' }
             const scope = a && changeRefusal(a, rel)
             if (scope) return { kind: 'aside', why: scope }
-            if (ctx.kind === 'agent' && room.meta.sync && heldForClash(room, key, rel)) return { kind: 'keep', why: `${rel} is held while a clash with GitHub is merged` }
             const claim = claimsOf(room).find((c) => c.by !== me && globMatcher(c.pattern)(rel))
             return claim ? { kind: 'claimed', why: heldRefusal(rel, claim), by: claim.by } : null
           },
@@ -1335,7 +1333,7 @@ async function serve (mcp, req, res, body) {
  * saveHosted, log, endedMessage }. `workspaces`, given only while the API has them on and
  * the holder is an agent, is { apiUrl, pass (as sent), fetch }: the library tools are added.
  */
-export async function handleHostedMcp ({ req, res, pass, relay, workspaces = null, body = undefined }) {
+export async function handleHostedMcp ({ req, res, pass, relay, workspaces = null, secrets = null, body = undefined }) {
   const image = String(req.headers['x-quilt-image'] || '').trim()
   // The library's guide is part of the instructions only when its tools are offered.
   const mcp = new McpServer({ name: 'quilt', version: '0.2.0' }, { instructions: workspaces ? `${HOSTED_INSTRUCTIONS}\n\n${WORKSPACE_GUIDE_HOSTED}` : HOSTED_INSTRUCTIONS })
@@ -1636,6 +1634,20 @@ export async function handleHostedMcp ({ req, res, pass, relay, workspaces = nul
     } catch (e) { return fail(e.message) }
   })
 
+  // Secrets: names only. A hosted agent runs no commands, so it uses none (the answer says so).
+  mcp.registerTool('quilt_secret_names', {
+    description: `${SECRET_NAMES_DESCRIPTION} You are a hosted agent: you run no commands, so you can't use secrets yourself; this tells you which exist.`,
+    inputSchema: { session: SESSION_ARG }
+  }, async ({ session }) => {
+    const c = current(session)
+    if (c.error) return fail(c.error)
+    if (!secrets) return text(describeSecretNames({ hosted: true }))
+    try {
+      const r = await hostedWorkspaceAccess(secrets).call('GET', `/v1/sessions/${encodeURIComponent(c.room.name)}/secret-names`)
+      return text(describeSecretNames({ names: r.names, hosted: true }))
+    } catch (e) { return fail(e.status === 503 ? 'Secrets are not switched on on this server yet.' : e.message) }
+  })
+
   sessionTools(mcp, ctx)
   // The library works whether or not the agent is in a session (it never touches relay.hosted).
   if (workspaces) registerWorkspaceTools(mcp, { ...hostedWorkspaceAccess(workspaces), webhook: false })

package/src/relay-metrics.js

@@ -1,9 +1,12 @@
 // How busy and how big each room is, for placement (relay-cluster.js) and the relay's /stats:
 // WebSocket messages and bytes in and out, counted per minute; and the room's bytes in memory
 // and on disk. The accounts API reads them every minute and gives a heavy room a machine of its
-// own (src/api/relay-cluster.js), with heavyReasons deciding what heavy is.
+// own (src/api/relay-cluster.js), with heavyReasons deciding what heavy is. The machine's own
+// load (memory, event-loop lag, CPU) is MachineMeter's, for scaling the cluster on load.
 import fs from 'node:fs'
+import os from 'node:os'
 import path from 'node:path'
+import { monitorEventLoopDelay } from 'node:perf_hooks'
 
 export const METER_WINDOW_MS = 60 * 1000
 const zero = () => ({ msgsIn: 0, msgsOut: 0, bytesIn: 0, bytesOut: 0 })
@@ -73,3 +76,65 @@ export function heavyReasons (s, limits = HEAVY, busyMinutes = 0) {
   if (busyMinute(s, limits) && busyMinutes >= limits.ioMinutes) out.push('io')
   return out
 }
+
+// How often the event loop is sampled for lag; every sample includes this much on its own.
+export const LAG_RESOLUTION_MS = 20
+
+/** The memory this machine (or its container's limit, when lower) has. */
+export function machineMemory () {
+  const total = os.totalmem()
+  const limit = typeof process.constrainedMemory === 'function' ? Number(process.constrainedMemory()) || 0 : 0
+  return limit > 0 && limit < total ? limit : total
+}
+
+/**
+ * The machine's own load, a minute at a time: event-loop lag (the minute's 99th percentile and
+ * mean, in ms, beyond the sampling interval) and CPU (share of one core). `roll()` closes the
+ * minute (the report does, every minute); `last` is the last closed one.
+ */
+export class MachineMeter {
+  constructor ({ now = Date.now, cpuUsage = (prev) => process.cpuUsage(prev), delay = null, resolutionMs = LAG_RESOLUTION_MS } = {}) {
+    this.now = now
+    this.cpuUsage = cpuUsage
+    this.resolutionMs = resolutionMs
+    this.delay = delay || monitorEventLoopDelay({ resolution: resolutionMs })
+    if (this.delay.enable) this.delay.enable()
+    this.at = now()
+    this.cpu0 = cpuUsage()
+    this.last = { lagMs: 0, lagMeanMs: 0, cpu: 0 }
+  }
+
+  roll () {
+    const t = this.now()
+    const used = this.cpuUsage(this.cpu0)
+    const wallUs = Math.max(1, t - this.at) * 1000
+    const ms = (ns) => Math.max(0, Math.round((Number(ns) || 0) / 1e6 - this.resolutionMs))
+    const sampled = (this.delay.count ?? 1) > 0
+    this.last = {
+      lagMs: sampled ? ms(this.delay.percentile(99)) : 0,
+      lagMeanMs: sampled ? ms(this.delay.mean) : 0,
+      cpu: Math.round(((used.user + used.system) / wallUs) * 1000) / 1000
+    }
+    this.delay.reset()
+    this.at = t
+    this.cpu0 = this.cpuUsage()
+    return this.last
+  }
+
+  stop () { if (this.delay.disable) this.delay.disable() }
+}
+
+/**
+ * A machine's load for the accounts API: memory used (the relay's resident memory) against the
+ * machine's, the last minute's event-loop lag and CPU, and every loaded room's traffic together.
+ */
+export function machineLoad ({ meter, rooms = [], memTotal = machineMemory(), mem = process.memoryUsage() }) {
+  let bytesPerMin = 0
+  let msgsPerMin = 0
+  for (const r of rooms) {
+    bytesPerMin += (r.bytesIn || 0) + (r.bytesOut || 0)
+    msgsPerMin += (r.msgsIn || 0) + (r.msgsOut || 0)
+  }
+  const last = meter ? meter.last : { lagMs: 0, lagMeanMs: 0, cpu: 0 }
+  return { memUsed: mem.rss, memTotal, lagMs: last.lagMs, lagMeanMs: last.lagMeanMs, cpu: last.cpu, bytesPerMin, msgsPerMin }
+}

package/src/relay-outbound.js

@@ -3,8 +3,8 @@
 // files that differ from the branch's base commit become one commit on the base, built with git
 // plumbing in the mirror (the tree is the base's tree with the pending files applied, as git add
 // would store them), authored by whoever changed the most lines, co-authored by the rest, and
-// pushed forward only. Files a member holds, files in a clash, files with conflict markers and
-// paths git ignores never go in. Never a force-push: when the remote moved, inbound runs first
+// pushed forward only. Files a member holds and paths git ignores never go in; conflict markers a
+// git merge left in a file are settled by Quilt first (settleMarkers: both sides' lines kept). Never a force-push: when the remote moved, inbound runs first
 // (relay-sync.js) and the commit is rebuilt on the new head.
 import fs from 'node:fs'
 import os from 'node:os'
@@ -12,12 +12,14 @@ import path from 'node:path'
 import crypto from 'node:crypto'
 import { syncStateOf, runGit, GitFailed, gcMirror, deleteRemoteBranch } from './relay-git.js'
 import { githubWriter } from './github-commit.js'
-import { bringInBranch, keepRefs, keptObjects, crashPoint, remoteHead } from './relay-sync.js'
-import { upstreamsOf, parseRepo, ignoreOf, hasMarkers, RELAY_ORIGIN } from './relay-upstream.js'
+import { bringInBranch, keepRefs, keptObjects, crashPoint, remoteHead, filesAt, applyWrites } from './relay-sync.js'
+import { upstreamsOf, parseRepo, ignoreOf, hasMarkers, docKey, RELAY_ORIGIN } from './relay-upstream.js'
 import { gitBlobSha, slug, noreply, agentPrefix, othersInChange, othersEditing } from './github-commit.js'
 import { openPullOnPush, noteTaskRevision, agentCommitsOf } from './relay-commit.js'
-import { everyone, notePushedMerges } from './relay-clash.js'
-import { notePublished } from './upstream.js'
+import { everyone, notePushedMerges, upstreamCommits, memberForAuthor, tellAutoMerge } from './relay-clash.js'
+import { notePublished, combine } from './upstream.js'
+import { looksBinary } from './fsutil.js'
+import { mergeAuto } from './merge3.js'
 import { unwrapAsRelay, decryptBlob } from './largefiles.js'
 import { lfsUpload } from './relay-lfs.js'
 import { isSafeRelPath, isIgnored, MAX_TEXT_BYTES, MAX_BINARY_BYTES } from './pathrules.js'
@@ -240,6 +242,38 @@ export async function storedBytes (room, e, rel) {
   return plain
 }
 
+/**
+ * A text with git's conflict markers, settled the way Quilt merges: each <<<<<<< … ======= … >>>>>>>
+ * block becomes both sides' lines (shared leading and trailing lines once); with the base recorded
+ * (||||||| in diff3 style), lines only one side changed are kept and lines both changed are the first
+ * side's. Returns the text, or null when the markers aren't whole blocks.
+ */
+export function settleMarkers (text) {
+  const lines = text.split('\n')
+  const out = []
+  const mark = (l, c) => l === c.repeat(7) || l.startsWith(`${c.repeat(7)} `)
+  for (let i = 0; i < lines.length; i++) {
+    if (!mark(lines[i], '<')) { if (mark(lines[i], '>')) return null; out.push(lines[i]); continue }
+    const a = []; let o = null; const b = []
+    let part = a
+    let j = i + 1
+    for (; j < lines.length; j++) {
+      const l = lines[j]
+      if (mark(l, '<')) return null
+      if (mark(l, '|') && part === a) { o = []; part = o; continue }
+      if (l === '=======' && part !== b) { part = b; continue }
+      if (mark(l, '>')) break
+      part.push(l)
+    }
+    if (j >= lines.length || part !== b) return null
+    const nl = (ls) => ls.length ? `${ls.join('\n')}\n` : ''
+    const both = !a.length ? b : !b.length ? a : mergeAuto(o ? nl(o) : '', nl(a), nl(b), { oursNewer: true }).text.split('\n').slice(0, -1)
+    out.push(...both)
+    i = j
+  }
+  return out.join('\n')
+}
+
 /**
  * Builds the commit for branch `key` on `base`: the base's tree with every session file that
  * differs applied, and the deletions the session made since the base. Resolves
@@ -313,7 +347,15 @@ export async function buildCommit (room, key, { dir, base, message = '', by = ''
     // Stored large files (read by the relay) go up to GitHub's own limit; past it, or through filter=lfs, Git LFS.
     const limit = viaLfs ? Infinity : stored.has(rel) ? GITHUB_MAX_BYTES : (buf && buf.includes(0) ? MAX_BINARY_BYTES : MAX_TEXT_BYTES)
     if (buf && buf.length > limit) { (stored.has(rel) ? skipped.lfs : skipped.large).push(rel); continue }
-    if (buf && !buf.includes(0) && hasMarkers(buf.toString('utf8'))) { skipped.markers.push(rel); continue }
+    if (buf && !buf.includes(0) && hasMarkers(buf.toString('utf8'))) {
+      // Conflict markers a git merge left: Quilt settles them in the session (both sides' lines kept) and commits that.
+      const settled = settleMarkers(buf.toString('utf8'))
+      if (settled === null) { skipped.markers.push(rel); continue }
+      applyWrites(room, e, new Map([[rel, settled]]), { bins: new Map(), now })
+      ;(skipped.settled = skipped.settled || []).push(rel)
+      changes.set(rel, Buffer.from(settled, 'utf8'))
+      continue
+    }
     if (viaLfs) {
       // Through Git LFS: the bytes to GitHub's LFS store, the pointer in the commit.
       if (!lfs || !lfs.url) { skipped.lfs.push(rel); continue }
@@ -859,8 +901,16 @@ export function outboundFor (room) {
         if (to && room.postChat) room.postChat({ by: RELAY_BY, to, kind: 'nudge', text: `${rel} isn't pushed to GitHub: ${why}.` })
       }
     }
+    // Said each time (it is news each time), and the file goes in the commit: it stays pending until pushed.
+    const tell = (rels, what) => {
+      for (const rel of rels) {
+        const to = lastBy(rel)
+        if (to && room.postChat) room.postChat({ by: RELAY_BY, to, kind: 'nudge', text: `${rel}: ${what}.` })
+      }
+    }
     say(skipped.ignored, 'git ignores it (the repository\'s .gitignore, .quiltignore or Quilt\'s own list)')
-    say(skipped.markers, 'it holds conflict markers; resolve them and it goes with the next commit')
+    say(skipped.markers, 'it holds conflict markers that aren\'t a whole merge (a <<<<<<< without its ======= and >>>>>>>), so Quilt can\'t settle them; it goes with the next commit once they are gone')
+    tell(skipped.settled || [], 'it held conflict markers from a git merge, so Quilt settled them: both sides\' lines are kept (where git recorded the base, the lines both sides changed are the first side\'s). It goes to GitHub as it is now')
     say(skipped.special, 'it is a symlink, a submodule or a Git LFS file on GitHub, which the relay never rewrites; change it from a folder with git')
     say(skipped.large, 'it is larger than Quilt syncs')
     say(skipped.filtered || [], 'the repository\'s .gitattributes put it through a filter, and the relay never runs a repository\'s filters (only text and line-ending rules); commit it from a folder with git')
@@ -885,10 +935,11 @@ export const MAX_BUNDLE_BYTES = 50 * 1024 * 1024
  * diverged): `bundle` is `git bundle create` of them. Each commit goes onto the branch's head on
  * GitHub with its own message and author: as it is when it already sits on the head (same commit,
  * same id), else replayed (git merge-tree, the same change on the new head). A commit whose change
- * GitHub already has (the relay pushed the session's copy of it) is skipped. Refused when a
- * commit's change clashes with GitHub's: the session merges that (relay-clash.js) and syncs it.
- * Resolves { state: 'pushed', sha, published: [{ original, published }], skipped: [shas] } or
- * { state: 'nothing' | 'clash' | 'refused', ... }.
+ * GitHub already has (the relay pushed the session's copy of it) is skipped. A commit that changed
+ * the same lines as GitHub is combined by Quilt (replayMerge: the newer edit keeps those lines).
+ * Resolves { state: 'pushed', sha, published: [{ original, published }], skipped: [shas], merged } or
+ * { state: 'nothing' | 'refused', ... }; 'nothing' says the `head` of GitHub's the session is at
+ * (the folder follows that commit, never a newer one the session has yet to bring in: session.js publishLocal).
  */
 export async function replayBundle (room, key, { who, bundle, head, ref = '' }, { log = room.log || (() => {}) } = {}) {
   if (!liveSyncOn(room, key)) return { state: 'refused', why: 'this branch doesn\'t sync live with GitHub' }
@@ -929,8 +980,9 @@ export async function replayBundle (room, key, { who, bundle, head, ref = '' },
  * A folder's commits, in the mirror at ref `incoming` (ending at `head`), onto GitHub's head
  * `remoteHead` of the session branch `key`: each one on the head already goes as it is; one whose
  * change GitHub has already is skipped; any other is replayed with git merge-tree, keeping its author
- * and message. Then one fast-forward push. Resolves { state: 'pushed', sha, published, skipped },
- * 'nothing', 'clash' (with `at`), 'refused', 'protected' or 'moved'. Runs in the branch's queue.
+ * and message; lines both it and GitHub changed are combined (replayMerge). Then one fast-forward
+ * push. Resolves { state: 'pushed', sha, published, skipped, merged }, 'nothing', 'refused',
+ * 'protected' or 'moved'. Runs in the branch's queue.
  */
 async function replayIncoming (room, key, { who, dir, incoming, head, remoteHead, token, log }) {
   const rec = upstreamsOf(room)[key]
@@ -939,22 +991,28 @@ async function replayIncoming (room, key, { who, dir, incoming, head, remoteHead
     {
       const list = (await runGit(dir, ['rev-list', '--reverse', '--topo-order', `${remoteHead}..${incoming}`])).out.split('\n').filter(Boolean)
       await runGit(dir, ['update-ref', '-d', incoming])
-      if (!list.length) return { state: 'nothing', why: 'GitHub already has those commits' }
+      if (!list.length) return { state: 'nothing', head: remoteHead, why: 'GitHub already has those commits' }
       // On GitHub's head already (merge commits and all): they go as they are, a fast-forward.
       const ff = (await runGit(dir, ['merge-base', '--is-ancestor', remoteHead, head])).ok
       if (!ff && (await runGit(dir, ['rev-list', '--merges', `${remoteHead}..${head}`])).out.trim()) return { state: 'refused', why: 'merge commits aren\'t replayed onto a newer head: merge GitHub\'s branch into yours and push again, or let the session sync the files' }
       let tip = remoteHead
       const published = []
       const skipped = []
+      const merged = [] // files Quilt combined on the way: { path, lost, deleted, at: the local commit, github }
       if (ff) { tip = head; for (const c of list) published.push({ original: c, published: c }) }
       for (const c of ff ? [] : list) {
         const parent = (await runGit(dir, ['rev-parse', `${c}^`])).out.trim()
         if (parent === tip) { tip = c; published.push({ original: c, published: c }); continue } // already on the head: the commit itself
-        const mt = await runGit(dir, ['merge-tree', '--write-tree', '--messages', `--merge-base=${parent}`, tip, c])
-        const tree = mt.out.split('\n')[0].trim()
-        if (!mt.ok || !/^[0-9a-f]{40}$/.test(tree)) {
-          const files = mt.out.split('\n').filter((l) => /^CONFLICT/.test(l)).map((l) => l.replace(/^CONFLICT \([^)]*\): /, '')).slice(0, 5)
-          return { state: 'clash', why: `your local commit ${c.slice(0, 7)} changes the same lines as GitHub${files.length ? ` (${files.join('; ')})` : ''}: the session holds and merges that file (quilt_clash), then it syncs`, at: c }
+        const mt = await runGit(dir, ['merge-tree', '--write-tree', '--name-only', '--no-messages', `--merge-base=${parent}`, tip, c])
+        let tree = mt.out.split('\n')[0].trim()
+        if (!/^[0-9a-f]{40}$/.test(tree)) return { state: 'refused', why: `git couldn't replay ${c.slice(0, 7)} onto GitHub's head` }
+        if (!mt.ok) {
+          // Lines this commit and GitHub both changed: Quilt combines them (the newer edit keeps those lines), nobody is asked.
+          const files = [...new Set(mt.out.split('\n').slice(1).map((l) => l.trim()).filter(Boolean))]
+          const r = await replayMerge(room, dir, { parent, tip, commit: c, tree, files })
+          if (!r) return { state: 'refused', why: `could not combine ${c.slice(0, 7)} with GitHub's changes` }
+          tree = r.tree
+          merged.push(...r.merged)
         }
         const tipTree = (await runGit(dir, ['rev-parse', `${tip}^{tree}`])).out.trim()
         if (tree === tipTree) { skipped.push(c); continue } // GitHub has this change already (the relay pushed the session's copy)
@@ -966,7 +1024,7 @@ async function replayIncoming (room, key, { who, dir, incoming, head, remoteHead
         tip = made.out.trim()
         published.push({ original: c, published: tip })
       }
-      if (tip === remoteHead) return { state: 'nothing', skipped, why: 'GitHub already has every change in those commits' }
+      if (tip === remoteHead) return { state: 'nothing', head: remoteHead, skipped, why: 'GitHub already has every change in those commits' }
       crashPoint(room, 'replay') // tests: the relay dies with the commits replayed, before pushing them
       const r = await room.mirrors.push(dir, { branch: rec.ref, sha: tip, expected: remoteHead, token })
       if (r.state !== 'accepted') return { state: r.state === 'protected' ? 'protected' : 'moved', why: r.why || 'GitHub moved meanwhile: try again' }
@@ -978,12 +1036,83 @@ async function replayIncoming (room, key, { who, dir, incoming, head, remoteHead
       state.replays.push({ by: who.name, at: Date.now(), published, skipped })
       state.replays = state.replays.slice(-50)
       room.saveMeta(); room.broadcastBranches()
+      if (merged.length) sessionTakesMerges(room, key, { who, rec, tip, remoteHead, merged })
       if (room.tellPushed) room.tellPushed(key, tip)
-      log(`[${room.name}] ${key}: pushed ${published.length} local commit${published.length === 1 ? '' : 's'} of ${who.name} (${tip.slice(0, 7)})${skipped.length ? `, ${skipped.length} already on GitHub` : ''}`)
+      log(`[${room.name}] ${key}: pushed ${published.length} local commit${published.length === 1 ? '' : 's'} of ${who.name} (${tip.slice(0, 7)})${skipped.length ? `, ${skipped.length} already on GitHub` : ''}${merged.length ? `; combined ${merged.map((m) => m.path).join(', ')} with GitHub's changes` : ''}`)
       if (room.postChat && !who.quiet) room.postChat({ by: RELAY_BY, text: `${who.name}'s ${published.length} local commit${published.length === 1 ? '' : 's'} went to ${rec.repo.replace(/^github\.com\//, '')} ${rec.ref} (${tip.slice(0, 7)}).`, kind: 'commit' })
-      return { state: 'pushed', sha: tip, published, skipped }
+      return { state: 'pushed', sha: tip, published, skipped, ...(merged.length ? { merged: merged.map((m) => ({ path: m.path, lost: m.lost.length ? m.lost[0].side : null })) } : {}) }
+    }
+  }
+}
+
+/** A blob's key as planCatchUp keys files: text, "bin:<sha1>", or null when absent. */
+const keyOfBuf = (buf) => buf === null || buf === undefined ? null : looksBinary(buf) ? `bin:${crypto.createHash('sha1').update(buf).digest('hex')}` : buf.toString('utf8')
+
+/**
+ * The files git merge-tree couldn't merge while replaying `commit` onto `tip`, combined by Quilt
+ * (upstream.js combine) against `parent`: lines only one side changed are kept, lines both changed
+ * go to the newer edit (the local commit's time against GitHub's newest commit to the file), an
+ * edit beats a deletion, a binary is the newer version. Returns { tree, merged: [{ path, lost,
+ * deleted, at, key, github }] } with `tree` merge-tree's with those files replaced, or null.
+ */
+async function replayMerge (room, dir, { parent, tip, commit, tree, files }) {
+  const [atBase, atTip, atMine] = await Promise.all([filesAt(dir, parent, files), filesAt(dir, tip, files), filesAt(dir, commit, files)])
+  const mineAt = Number((await runGit(dir, ['log', '-1', '--format=%ct', commit])).out.trim()) * 1000 || 0
+  const modes = new Map()
+  for (const at of [tip, commit]) {
+    const r = await runGit(dir, ['ls-tree', '-z', at, '--', ...files])
+    for (const entry of r.out.split('\0')) { const tab = entry.indexOf('\t'); if (tab > 0 && !modes.has(entry.slice(tab + 1))) modes.set(entry.slice(tab + 1), entry.slice(0, tab).split(' ')[0]) }
+  }
+  const scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'quilt-replay-'))
+  const env = { GIT_DIR: dir, GIT_INDEX_FILE: path.join(scratch, 'index') }
+  const merged = []
+  try {
+    if (!(await runGit(scratch, ['read-tree', tree], { env })).ok) return null
+    for (const rel of files) {
+      const bufs = { base: atBase.get(rel), tip: atTip.get(rel), mine: atMine.get(rel) }
+      if ([bufs.base, bufs.tip, bufs.mine].some((b) => b === undefined)) return null
+      const top = (await upstreamCommits(dir, parent, tip, rel))[0] || null
+      const mineNewer = mineAt >= ((top || {}).ts || 0)
+      // The local commit is "ours": its lines lost are told to whoever handed it over.
+      const r = combine(keyOfBuf(bufs.base), keyOfBuf(bufs.mine), keyOfBuf(bufs.tip), { oursNewer: mineNewer })
+      let out = null
+      if (r.key !== null) out = r.key === keyOfBuf(bufs.mine) ? bufs.mine : r.key === keyOfBuf(bufs.tip) ? bufs.tip : Buffer.from(r.key, 'utf8')
+      if (out === null) {
+        if (!(await runGit(scratch, ['update-index', '--force-remove', '--', rel], { env })).ok) return null
+      } else {
+        const blob = await runGit(scratch, ['hash-object', '-w', '--stdin'], { input: out, env })
+        if (!blob.ok) return null
+        if (!(await runGit(scratch, ['update-index', '--add', '--cacheinfo', `${modes.get(rel) || '100644'},${blob.out.trim()},${rel}`], { env })).ok) return null
+      }
+      merged.push({ path: rel, lost: r.lost, deleted: r.deleted || null, at: commit, key: r.key, mine: keyOfBuf(bufs.mine), bins: out && r.key && r.key.startsWith('bin:') ? out : null, github: top ? { name: top.name, email: top.email, ts: top.ts, sha: top.sha, member: memberForAuthor(room, top) } : null })
     }
+    // A conflict merge-tree records at more than one stage (rename and delete, say) is gone once each path is set above.
+    const w = await runGit(scratch, ['write-tree'], { env })
+    if (!w.ok) return null
+    return { tree: w.out.trim(), merged }
+  } finally { fs.rmSync(scratch, { recursive: true, force: true }) }
+}
+
+/**
+ * After a replay that combined files (replayMerge): the session takes the combined version of each
+ * one it still has as the local commit had it (else it would push that back over GitHub's lines),
+ * and whoever's lines lost is told: the person who handed the commits over, or the activity log.
+ */
+function sessionTakesMerges (room, key, { who, rec, tip, remoteHead, merged }) {
+  const e = room.branchDoc ? room.branchDoc(key) : null
+  if (!e) return
+  const writes = new Map()
+  const bins = new Map()
+  for (const m of merged) {
+    const now = docKey(e, m.path)
+    if (now === undefined || now === m.key) continue
+    if (now === m.mine) { writes.set(m.path, m.key); if (m.bins) bins.set(m.key, m.bins); continue }
+    // Edited in the session since: that edit and the combined file, the session's edit kept where they overlap.
+    const r = combine(m.mine, now, m.key, { oursNewer: true })
+    if (r.key !== now) { writes.set(m.path, r.key); if (m.bins && r.key === m.key) bins.set(m.key, m.bins) }
   }
+  if (writes.size) applyWrites(room, e, writes, { bins, now: Date.now() })
+  for (const m of merged) tellAutoMerge(room, key, { path: m.path, lost: m.lost, deleted: m.deleted, session: { name: who.name }, github: m.github, upstream: rec.name, head: remoteHead, keptIn: `your commit ${m.at.slice(0, 7)}` })
 }
 
 /**
@@ -1047,9 +1176,9 @@ export async function receiveAgentPush (room, { who, name, updates, env }, { log
           return replayIncoming(room, key, { who: { name, quiet: true }, dir, incoming, head: u.new, remoteHead, token, log })
         })
         if (r.state === 'nothing') { published.set(u.ref, (await runGit(dir, ['rev-parse', `refs/remotes/origin/${rec.ref}`])).out.trim()); lines.push(`${branch}: GitHub already has these changes`); continue }
-        if (r.state !== 'pushed') return say(r.state === 'clash' ? `${r.why}. Fetch, merge GitHub's ${branch} into yours, and push again` : r.state === 'protected' ? `${branch} is protected on GitHub: push to a branch of your own and open a pull request` : r.why || `GitHub didn't take it (${r.state}): fetch and push again`)
+        if (r.state !== 'pushed') return say(r.state === 'protected' ? `${branch} is protected on GitHub: push to a branch of your own and open a pull request` : r.why || `GitHub didn't take it (${r.state}): fetch and push again`)
         published.set(u.ref, r.sha)
-        lines.push(r.sha === u.new ? `${branch} on GitHub is at ${r.sha.slice(0, 7)}` : `${branch}: GitHub had moved, so your commits went on its head as ${r.sha.slice(0, 7)}; your folder follows it`)
+        lines.push(r.sha === u.new ? `${branch} on GitHub is at ${r.sha.slice(0, 7)}` : `${branch}: GitHub had moved, so your commits went on its head as ${r.sha.slice(0, 7)}${r.merged ? ` (Quilt combined ${r.merged.map((m) => m.path).join(', ')} with GitHub's changes: where both changed the same lines, the newer edit is kept)` : ''}; your folder follows it`)
         continue
       }
       // Any other branch (an agent's own, new or not yet in the session): straight to GitHub, fast-forward only.