heyquilt 0.3.90 → 0.3.106

package/src/session.js

@@ -6,7 +6,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import crypto from 'node:crypto'
 import { fileURLToPath } from 'node:url'
-import { execFile } from 'node:child_process'
+import { execFile, execFileSync } from 'node:child_process'
 import { EventEmitter } from 'node:events'
 import * as Y from 'yjs'
 import { watch } from 'chokidar'
@@ -17,7 +17,7 @@ import { MAX_SHARED_FILE_BYTES, FEATURES } from './protocol.js'
 import { formatBytes, pullAdvice } from './status.js'
 import {
   loadIgnore, IGNORE_FILES, isIgnored, isSafeRelPath, resolveInside, looksBinary, sha1, walk,
-  toPosix, globMatcher, MAX_TEXT_BYTES, MAX_BINARY_BYTES, LARGE_FILE_BYTES, MAX_STORED_BINARY_BYTES
+  toPosix, globMatcher, MAX_TEXT_BYTES, MAX_BINARY_BYTES, LARGE_FILE_BYTES, MAX_STORED_BINARY_BYTES, CHAT_FILES, closeWatcher
 } from './fsutil.js'
 import { wrapForRelay, relayKeyId, deriveWrapKey, newFileKey, wrapKey, unwrapKey, encryptBlob, decryptBlob, blobId } from './largefiles.js'
 import { applyTextDiff } from './textdiff.js'
@@ -41,11 +41,11 @@ import { cleanCommitFiles, ownerName, commitRequestMessage, MAX_COMMIT_DESCRIPTI
 import { cleanFiles, uncommitted, lastCommitted, commitFiles, commitMessage, editorsSince, uncommittedByPerson, requestWarning, REQUEST_SETTLE_MS, MAX_REQUEST_FILES, MAX_MESSAGE } from './commit.js'
 import { changeRefusal, TALK_REFUSED } from './session-access.js'
 import { canAdmit } from './admit-policy.js'
-import { merge3, withMarkers, hasMarkers } from './merge3.js'
+import { merge3, mergeAuto, hasMarkers } from './merge3.js'
 import { sameEditClient, asClient } from './same-edit.js'
 import { openMerge, updateMerge, readMerges, pruneMerges, cleanName } from './merges.js'
 import { ensureQuiltIgnored } from './gitignore.js'
-import { urlOrigin, gitDir, headKey, headRef, gitRuns, askTwice, lastCallTimedOut, busy as gitBusy, leftoverLock, STALE_LOCK_MS, indexStamp, classify, filesAt, changesBetween, commitsBetween, treeState, branchTip, watchGit, unmergedPaths, stashStamp, upstreamAdds, pullState, SETTLE_MS, BURST_PATHS, upstreamOf, fetchUpstream, isAncestor, stagedAgainst, fastForward, resetIndex, blobAt, hasFilesUnder, repoBranches, remoteHost, backWithGit, installGitHelpers, setPersonGit, hasCommit, pushLocal, bundleOf, adoptPublished } from './gitstate.js'
+import { urlOrigin, gitDir, headKey, headRef, gitRuns, askTwice, lastCallTimedOut, busy as gitBusy, leftoverLock, STALE_LOCK_MS, indexStamp, classify, filesAt, changesBetween, commitsBetween, treeState, branchTip, watchGit, unmergedPaths, stashStamp, upstreamAdds, pullState, SETTLE_MS, BURST_PATHS, upstreamOf, fetchUpstream, isAncestor, stagedAgainst, fastForward, resetIndex, blobAt, hasFilesUnder, repoBranches, remoteHost, backWithGit, installGitHelpers, setPersonGit, hasCommit, pushLocal, bundleOf, adoptPublished, commitTimes } from './gitstate.js'
 import { planCatchUp, catchUpAdvice, publishedOf, notePublished } from './upstream.js'
 import { agentPrefix, noreply, slug, gitForEveryoneWords } from './github-commit.js'
 import { parseRepo, upstreamRef } from './relay-upstream.js'
@@ -76,9 +76,6 @@ const CLASH_SETTLE_MS = 2000 // a clash task this member wrote is told to its AI
 const CLASH_KEEP_MS = 3 * 24 * 60 * 60 * 1000 // a finished clash record is kept this long
 const CLASH_RECORDS = 100
 const KEEP_DONE_COMMITS = 100 // finished commit requests kept, newest (the board shows which task's work was committed)
-const STILL_MARKED = 'this file has conflict markers in it; finish editing it (or choose Keep mine) first'
-// The note on a claim taken to settle a merge (takeMerge).
-const MERGE_CLAIM_NOTE = 'settling the merge of'
 const COLORS = ['#4f4fa0', '#3b6a9a', '#4a7a45', '#855a9c', '#a8701c', '#2e7a80', '#9c4f6b']
 const RECENT_MS = 2 * 60 * 1000
 const AGENT_FEED_CAP = 300
@@ -241,7 +238,6 @@ export class Session extends EventEmitter {
     // Our boxes: what the session had before the edit that opened each (null: no file). Back to that, the box holds
     // nothing of ours (our edit undone, or taken back) and opens like a committed one.
     this.boxFrom = new Map()
-    this.mergeClaims = new Set() // files taken to settle a merge (takeMerge), let go once it is settled
     this.queueNoticed = new Map() // claim pattern -> when our AI was last told someone waits for it
     this.autoClaimQuietMs = autoClaimQuietMs
     this.handoffGraceMs = handoffGraceMs
@@ -832,14 +828,20 @@ export class Session extends EventEmitter {
     if (this.kind !== 'agent' || !this.git || !this.git.branch || !up || !up.sha) return false
     const url = await this.gitOut(['config', '--get', `remote.${up.remote || 'origin'}.url`])
     if (!url || url !== this.relayGitUrl()) return false
-    const cherry = await this.gitOut(['cherry', up.sha, at])
+    // The commit the relay put the session at, when GitHub has moved past it since (publishLocal says why): the rest comes in as any of GitHub's commits do.
+    const rs = this.relaySha()
+    const to = !this.memberAt(up.sha) && rs && rs !== at && await isAncestor(this.root, rs, up.sha) ? rs : up.sha
+    const cherry = await this.gitOut(['cherry', to, at])
     if (cherry === null || !cherry || cherry.split('\n').some((l) => !l.startsWith('-'))) return false
-    const r = await adoptPublished(this.root, this.git.branch, at, up.sha)
+    if (!(await this.sessionOnDisk(at, to))) { this.askRelayFor(up.sha); this.checkUpstreamSoon({ delay: 500 }); return false }
+    const r = await adoptPublished(this.root, this.git.branch, at, to)
     if (!r.moved) return false
-    this.gitSeen = { key: this.git.branch, branch: this.git.branch, sha: up.sha }
+    this.gitSeen = { key: this.git.branch, branch: this.git.branch, sha: to }
     this.gitIndex = indexStamp(this.root)
-    this.log(`⬆️ the relay put your commits on GitHub's newer ${this.git.branch} (${up.sha.slice(0, 7)}); this folder follows it (yours are kept under refs/quilt/original/${this.git.branch}/)`)
-    this.setUpstream({ ...up, behind: 0, ahead: 0 })
+    this.log(`⬆️ the relay put your commits on GitHub's newer ${this.git.branch} (${to.slice(0, 7)}); this folder follows it (yours are kept under refs/quilt/original/${this.git.branch}/)`)
+    const behind = to === up.sha ? 0 : ((await commitsBetween(this.root, to, up.sha)) ?? 1)
+    this.setUpstream({ ...up, behind, ahead: 0 })
+    if (behind) this.checkUpstreamSoon()
     return true
   }
 
@@ -871,7 +873,7 @@ export class Session extends EventEmitter {
       const wrong = list.filter((r) => !r.remoteRef.startsWith(`refs/heads/${prefix}`))
       if (wrong.length) {
         const name = (r) => r.remoteRef.replace(/^refs\/heads\//, '')
-        return { ok: false, why: `The session owner lets agents push only to branches of their own here: ${prefix}<topic> (not ${wrong.map(name).join(', ')}). Push to one (git push origin HEAD:${prefix}<topic>) and open a pull request to the session's branch (gh pr create, with GH_TOKEN from \`quilt git-token\`), or ask the owner to allow any branch (quilt_agent_commits any).` }
+        return { ok: false, why: `The session owner lets agents push only to branches of their own here: ${prefix}<topic> (not ${wrong.map(name).join(', ')}). Push to one (git push origin HEAD:${prefix}<topic>) and ask a person to open a pull request from it to the session's branch, or ask the owner to allow any branch (quilt_agent_commits any).` }
       }
     }
     // Pushing to GitHub needs credentials this folder gets from the session: when there are none, say why now, instead of git's "could not read Username".
@@ -1632,7 +1634,7 @@ export class Session extends EventEmitter {
     }
     const binary = [base, ours, theirs].some((k) => typeof k === 'string' && k.startsWith('bin:'))
     if (claimedByOther) return this.openConflict({ rel, base, ours, theirs, theirsBy, disk, kind: 'claimed', claimedBy: claim.by, binary, via })
-    if (binary || ours === null || theirs === undefined) return this.openConflict({ rel, base, ours, theirs, theirsBy, disk, kind: 'conflict', binary, via })
+    if (binary || ours === null || theirs === undefined) return this.autoSettle({ rel, base, ours, theirs, theirsBy, disk, binary, via })
     const { text, conflicts } = merge3(base || '', ours, theirs)
     // Ours already has the session's change in it (git combined them here: a stash popped over a pull):
     // only one version is new, so it goes in. Nothing is combined.
@@ -1656,9 +1658,111 @@ export class Session extends EventEmitter {
       release()
       return 'merged'
     }
-    // Otherwise (offline, a pull) both sides changed it, differently: a person settles it, even when
-    // the lines don't overlap (two changes can clash in what they mean). Quilt never combines them itself.
-    return this.openConflict({ rel, base, ours, theirs, theirsBy, disk, kind: 'conflict', binary: false, via })
+    // Otherwise (offline, a pull) both sides changed it: Quilt combines them itself.
+    return this.autoSettle({ rel, base, ours, theirs, theirsBy, disk, binary: false, via })
+  }
+
+  /** When the folder's HEAD commit last changed rel, in ms, or 0 (not a git folder, or git can't say). */
+  committedAt (rel) {
+    try {
+      const out = execFileSync('git', ['--no-optional-locks', 'log', '-1', '--format=%ct', 'HEAD', '--', rel], { cwd: this.root, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] })
+      const s = Number(out.trim())
+      return s > 0 ? s * 1000 + 999 : 0 // whole seconds: the end of its second, so an edit in the same second is older
+    } catch { return 0 }
+  }
+
+  /** When the session last changed rel (its chronology, then the room's activity), or 0. */
+  sessionEditedAt (rel) {
+    const h = this.history.array
+    for (let i = h.length - 1; i >= 0; i--) {
+      const e = h.get(i)
+      if (e && e.path === rel && typeof e.ts === 'number') return e.ts
+    }
+    for (let i = this.activity.length - 1; i >= 0; i--) {
+      const a = this.activity.get(i)
+      if (a && a.path === rel && typeof a.ts === 'number') return a.ts
+    }
+    return 0
+  }
+
+  /**
+   * Both the folder (ours) and the session (theirs) changed rel since base: Quilt combines them
+   * itself, and nobody is asked (docs/superpowers/specs/2026-10-18-automatic-merges.md). Lines only
+   * one side changed are kept; lines both changed go to the newer edit; a binary file is the newer
+   * version; an edit beats a deletion. What lost is kept (the record, .quilt/merges/<id>/, the
+   * file's history) and whoever wrote it is told. Returns 'merged'.
+   */
+  autoSettle ({ rel, base, ours, theirs, theirsBy, disk, binary, via = null }) {
+    const release = () => this.merging.delete(rel)
+    const pulled = via === 'pull'
+    const by = theirsBy ? cleanName(theirsBy) : null
+    // When ours was written: a pull's file is as new as the commit that last changed it (not the
+    // moment git wrote it), anything else as its last save.
+    const oursAt = (pulled && this.committedAt(rel)) || (disk && Number.isFinite(disk.mtime) ? disk.mtime : Date.now())
+    const oursNewer = oursAt >= this.sessionEditedAt(rel)
+    const text = (k) => (typeof k === 'string' && !k.startsWith('bin:') ? k : null)
+    const keep = ({ how, reason, lost = [] }) => {
+      try {
+        const rec = openMerge(this.bdoc, this.merges, {
+          path: rel, by: this.name, byId: this.myKey(), others: by ? [by] : [], kind: 'conflict',
+          ours: binary ? null : text(ours), oursDeleted: ours === null, via,
+          base: binary ? null : text(base), theirsHash: theirs === undefined ? null : sha1(theirs), binary,
+          reason: reason.replace(/[\u0000-\u001f\u007f]+/g, ' ').slice(0, 500)
+        }, LOCAL)
+        this.writeMergeFiles(rec.id, { base, ours, theirs, disk })
+        updateMerge(this.bdoc, this.merges, rec.id, { state: 'done', how, resolvedBy: 'Quilt', reason: rec.reason }, LOCAL)
+      } catch {}
+      this.noteLostLines(rel, { by, lost, oursWon: how === 'mine' })
+    }
+    // An edit beats a deletion: nothing anyone wrote is thrown away.
+    if (ours === null) {
+      release()
+      this.lastKnown.delete(rel)
+      this.tryWrite(rel)
+      keep({ how: 'theirs', reason: `Deleted here, but ${by || 'the session'} changed it: it stays` })
+      this.log(`🧵 ${rel}: you deleted it, but ${by || 'the session'} changed it, so it stays`)
+      return 'merged'
+    }
+    if (theirs === undefined) {
+      release()
+      this.ingest(rel, { pulled })
+      keep({ how: 'mine', reason: `${by || 'The session'} deleted it, but it was changed here: it stays` })
+      this.log(`🧵 ${rel}: ${by || 'the session'} deleted it, but you changed it, so it stays`)
+      return 'merged'
+    }
+    if (binary) {
+      release()
+      if (oursNewer) this.ingest(rel, { pulled }); else { this.lastKnown.set(rel, ours); this.tryWrite(rel) }
+      keep({ how: oursNewer ? 'mine' : 'theirs', reason: `Both changed it: the newer version (${oursNewer ? 'yours' : `${by || 'the session'}'s`}) stays`, lost: [{ side: oursNewer ? 'theirs' : 'ours', lines: [], kept: [], at: 0 }] })
+      this.log(`🧵 ${rel}: both changed it; the newer version (${oursNewer ? 'yours' : `${by || 'the session'}'s`}) stays`)
+      return 'merged'
+    }
+    // No common version (git couldn't read it, or both made the file): nothing lines up to combine,
+    // so the newer version is the file, as for a binary.
+    const r = typeof base === 'string' ? mergeAuto(base, ours, theirs, { oursNewer })
+      : { text: oursNewer ? ours : theirs, lost: [{ side: oursNewer ? 'theirs' : 'ours', lines: (oursNewer ? theirs : ours).split('\n').filter(Boolean), kept: [], at: 0 }] }
+    this.applyMerged(rel, r.text, `with ${by || 'the session'}'s changes${r.lost.length ? ' (the newer edit kept where both changed the same lines)' : ''}`, { pulled })
+    release()
+    if (r.lost.length) keep({ how: oursNewer ? 'mine' : 'theirs', reason: `Merged by Quilt: where both changed the same lines, the newer edit (${oursNewer ? 'yours' : `${by || 'the session'}'s`}) stays`, lost: r.lost })
+    return 'merged'
+  }
+
+  /**
+   * Tells whoever's lines lost an automatic merge (autoSettle): this person in the log and the
+   * catch-up, someone else in a direct message. A notice, never a task.
+   */
+  noteLostLines (rel, { by, lost, oursWon }) {
+    if (!lost.length) return
+    const shown = lost.flatMap((l) => l.lines).slice(0, 12)
+    const lines = shown.length ? `\n${shown.map((l) => `- ${l}`).join('\n')}` : ''
+    if (!oursWon) {
+      this.log(`🧵 ${rel}: Quilt merged your changes with ${by || 'the session'}'s; where you both changed the same lines, their newer edit stays. Your lines are in the file's history and in .quilt/merges/.${lines}`)
+      return
+    }
+    if (!by || by === this.name) return
+    try {
+      this.say(`Quilt merged ${rel}: where we both changed the same lines, my newer edit stays. Your lines it replaced are in the file's history (Changes):${lines}`, { to: by })
+    } catch {}
   }
 
   /** Writes a merged text to the shared doc and the disk as one edit of ours (`pulled`: one a git pull brought). */
@@ -1715,19 +1819,14 @@ export class Session extends EventEmitter {
       reason: reason ? String(reason).replace(/[\u0000-\u001f\u007f]+/g, ' ').trim().slice(0, 500) || null : null
     }, LOCAL)
     this.writeMergeFiles(rec.id, { base, ours, theirs, disk })
-    // Live sync with GitHub: the relay holds the file and has the two parties merge it (relay-clash.js), never markers in the session.
-    if (this.branchLive() && this.conn && this.conn.adminRequest) {
-      this.conn.adminRequest({ op: 'offlineClash', path: rel, mergeId: rec.id, ...(binary ? { binary: true } : {}), ...(text(base) !== null ? { base: text(base) } : {}), ...(ours === null ? { oursDeleted: true } : text(ours) !== null ? { ours: text(ours) } : {}) })
-        .catch((err) => this.log(`could not hand ${rel}'s merge to the session: ${err.message}`))
-    }
     // The session's version goes back on disk (or the file goes, if the session
     // deleted it). lastKnown is set to ours first so writeOut doesn't also copy
     // it to .quilt/conflicts: the merge folder already has it.
     this.merging.delete(rel)
     if (ours === null) this.lastKnown.delete(rel); else this.lastKnown.set(rel, ours)
     this.tryWrite(rel)
-    const who = claimant ? `${claimant} has it claimed` : by ? `${by} changed it too` : 'it changed in the session too'
-    this.log(`⚠️  ${rel} needs merging: ${who}${reason ? ` (${reason})` : ''}. Your version is kept; see Merges in the app.`)
+    // Only a file someone holds comes here now (autoSettle combines the rest): it waits for them.
+    this.log(`⏳ ${rel}: ${claimant || by || 'someone'} has it claimed. Your changes are kept and go in, merged by Quilt, once they let go of it.`)
     this.emit('file-changed', { path: rel, by: by || 'partner' })
     return 'conflict'
   }
@@ -1852,11 +1951,11 @@ export class Session extends EventEmitter {
     if (looksBinary(buf)) {
       if (buf.length > MAX_BINARY_BYTES && this.largeFilesOff) return { tooLarge: true }
       const hash = sha1(buf)
-      return { binary: true, buf, hash, key: `bin:${hash}`, exec }
+      return { binary: true, buf, hash, key: `bin:${hash}`, exec, mtime: st.mtimeMs }
     }
     if (buf.length > MAX_TEXT_BYTES) return { tooLarge: true }
     const text = buf.toString('utf8')
-    return { text, key: text, exec }
+    return { text, key: text, exec, mtime: st.mtimeMs }
   }
 
   // ------------------------------------------------------- local -> shared --
@@ -2385,9 +2484,17 @@ export class Session extends EventEmitter {
     const theirs = inDoc ? this.sharedKey(rel) : head // null: neither this branch nor its commit has it
     if (ours === theirs) { if (ours === null) this.lastKnown.delete(rel); else this.lastKnown.set(rel, ours); return null }
     if (ours === base) { this.putBranchVersion(rel, { inDoc, head, headBuf }); return null } // not edited after all
-    // Edited here and changed on this branch too: never combined on its own (see mergeOne).
-    this.setAsideCarried(rel, { inDoc, head, headBuf, clash: theirs !== null })
-    return null
+    if (theirs === null) { this.setAsideCarried(rel, { inDoc, head, headBuf, clash: false }); return null } // not on this branch
+    // Edited here and changed on this branch too: combined by Quilt, as mergeOne does.
+    const binary = [base, ours, theirs].some((k) => typeof k === 'string' && k.startsWith('bin:'))
+    if (inDoc) return this.autoSettle({ rel, base, ours, theirs, theirsBy: this.lastEditorOf(rel), disk, binary })
+    // This branch's commit has it, its document doesn't yet: the merge goes onto the disk, and is shared from there.
+    if (ours === null) { this.putHeadVersion(rel, head, headBuf); return null }
+    if (binary) return null // ours, edited after the checkout, is the newer version: it stays, and is shared from the disk
+    const r = mergeAuto(base || '', ours, theirs, { oursNewer: true })
+    this.writeFile(rel, resolveInside(this.root, rel), r.text)
+    this.log(`🧵 ${rel}: your edit after switching to ${this.branch} is merged with ${this.branch}'s own change to it`)
+    return 'merged'
   }
 
   /** This branch's version of rel onto the disk: its document's, else HEAD's file, else none. */
@@ -2787,7 +2894,7 @@ export class Session extends EventEmitter {
       const has = () => atHead && changed.every((rel) => this.sharedKey(rel) === (atHead.get(rel) ?? undefined))
       if (atHead && !atHead.failed && (has() || await this.relayHasPull(head.sha, has))) old = atHead
     }
-    if (old.failed) this.log(`⚠️ git could not read ${old.failed} file${old.failed === 1 ? '' : 's'} at the old commit; merged without a base (a merge record at worst)`)
+    if (old.failed) this.log(`⚠️ git could not read ${old.failed} file${old.failed === 1 ? '' : 's'} at the old commit; merged without a base, so where they differ the newer version stays`)
     // A file git made the person resolve (stash pop, rebase) holds their merge of the commits and the
     // session's work: merged against the session's version this disk had, it is taken as resolved.
     const advance = changed.map((rel) => ({ rel, base: this.heldConflicts.has(rel) && this.lastKnown.has(rel) ? this.lastKnown.get(rel) : old.get(rel) ?? undefined, via: 'pull' }))
@@ -3049,6 +3156,11 @@ export class Session extends EventEmitter {
     if (!behind) { this.setUpstream({ ...up, behind, ahead }); if (ahead) await this.publishLocal({ up, at, behind, ahead }); return this.upstream }
     if (ahead) {
       if (await this.followReplayed({ up, at })) return this.upstream
+      // The relay has these commits on GitHub already: the branch follows once GitHub's files are here (followPublished).
+      if (this.adoptLater && this.adoptLater.at === at) {
+        if (await this.followPublished(up)) return this.upstream
+        if (this.adoptLater) { this.setUpstream({ ...up, behind, ahead, diverged: true }); return this.upstream }
+      }
       this.setUpstream({ ...up, behind, ahead, diverged: true }); await this.publishLocal({ up, at, behind, ahead }); return this.upstream
     }
     await this.bringIn(at, up.sha, { moveRef: true, up: { ...up, behind, ahead }, now })
@@ -3093,17 +3205,67 @@ export class Session extends EventEmitter {
     let out
     try { out = (await this.conn.adminRequest({ op: 'bundle', bundle: bundle.toString('base64'), head: at, ref: `refs/heads/${branch}` }, { timeoutMs: PUSH_REQUEST_TIMEOUT_MS })).bundle } catch (err) { this.published = null; this.log(`could not hand your local commits to the relay: ${err.message}`); return }
     if (!out || !['pushed', 'nothing', 'clash'].includes(out.state)) { this.log(`your local commits on ${branch} stay here for now: ${(out && out.why) || 'the relay could not take them'}`); return }
-    if (out.state === 'clash') this.notice(`Your local commit on ${branch} clashes with GitHub: ${out.why}. Your files are in the session as they are; the clash is merged there, and this folder follows GitHub's branch (your commits are kept under refs/quilt/original/${branch}/).`)
     const f = await fetchUpstream(this.root, up.remote, up.url, { token: this.gitTokenNow() })
     if (!f.ok) return
     const now = await upstreamOf(this.root)
-    if (!now || !now.sha || now.sha === at) return
-    const r = await adoptPublished(this.root, branch, at, now.sha)
-    if (!r.moved) { this.log(`your local commits went to GitHub; ${branch} follows it once ${r.why}`); this.published = null; return }
-    this.gitSeen = { key: branch, branch, sha: now.sha }
+    if (!now || !now.sha) return
+    // The folder follows the commit the relay put the session at (its push, or GitHub's head it brought in), never a
+    // newer one of GitHub's the fetch just found: the session has yet to bring that in, and a branch moved there with
+    // git alone would lack its files, so a commit made then would delete them. GitHub's newer commits come in as any do.
+    // (A relay before 0.3.96 says no `head` for 'nothing' and 'clash': GitHub's head then.)
+    const to = out.sha || out.head || now.sha
+    if (to === at) return
+    this.adoptLater = { at, to, count: out.published ? out.published.length : 0 }
+    await this.followPublished(now)
+  }
+
+  /**
+   * The relay put this folder's local commits on GitHub (publishLocal): the branch follows the commit the relay
+   * put the session at (adoptLater.to) once the session's files are on disk (sessionOnDisk), else at a later look.
+   * `now` is the upstream as the folder last fetched it. Resolves whether it moved.
+   */
+  async followPublished (now) {
+    const later = this.adoptLater
+    const branch = this.git && this.git.branch
+    // Not on GitHub's branch any more (rewritten meanwhile): the commits are handed over again (publishLocal).
+    if (!later || !branch || !now || !now.sha || (now.sha !== later.to && !(await isAncestor(this.root, later.to, now.sha)))) { this.adoptLater = null; this.published = null; return false }
+    if (!(await this.sessionOnDisk(later.at, later.to))) {
+      this.askRelayFor(later.to)
+      this.checkUpstreamSoon({ delay: 500 })
+      return false
+    }
+    this.adoptLater = null
+    const r = await adoptPublished(this.root, branch, later.at, later.to)
+    if (!r.moved) { this.log(`your local commits went to GitHub; ${branch} follows it once ${r.why}`); this.published = null; return false }
+    this.gitSeen = { key: branch, branch, sha: later.to }
     this.gitIndex = indexStamp(this.root)
-    this.log(`⬆️ the relay put your local commit${out.published && out.published.length === 1 ? '' : 's'} on ${up.name} (${now.sha.slice(0, 7)}); ${branch} follows it (yours are kept under refs/quilt/original/${branch}/)`)
-    this.setUpstream({ ...now, behind: 0, ahead: 0 })
+    this.log(`⬆️ the relay put your local commit${later.count === 1 ? '' : 's'} on ${now.name} (${later.to.slice(0, 7)}); ${branch} follows it (yours are kept under refs/quilt/original/${branch}/)`)
+    const behind = now.sha === later.to ? 0 : ((await commitsBetween(this.root, later.to, now.sha)) ?? 1)
+    this.setUpstream({ ...now, behind, ahead: 0 })
+    if (behind) this.checkUpstreamSoon()
+    return true
+  }
+
+  /** What the folder holds at rel, as lastKnown keys it: null when nothing is there, undefined for a file never synced (a link, too large). */
+  diskKey (rel) {
+    const d = this.readDisk(rel)
+    if (!d) return null
+    return d.skip || d.tooLarge ? undefined : d.key
+  }
+
+  /**
+   * Whether this folder's branch may move from `from` to `to` with git alone, every file left as it is: the
+   * session is at `to` (the relay brought it in, or a member's folder is there), and each file the commits
+   * between them change is on disk as the session has it. A file of GitHub's still on its way here (one
+   * written only once the folder's hold ends) would be missing under an index that has it, and a
+   * `git commit -a` just after the move would take it for a deletion and undo it on GitHub.
+   */
+  async sessionOnDisk (from, to) {
+    if (!this.memberAt(to) && !(await this.relayPast(to))) return false
+    const changes = await changesBetween(this.root, from, to)
+    if (!changes) return false
+    for (const rel of changes.keys()) if (this.syncable(rel) && (this.diskKey(rel) ?? undefined) !== this.sharedKey(rel)) return false
+    return true
   }
 
   /**
@@ -3173,11 +3335,7 @@ export class Session extends EventEmitter {
     for (const rel of paths) {
       if (this.syncable(rel) && this.writeRefusal(rel)) { state({ waiting: `you may not change ${rel} in this session` }); return }
     }
-    const diskKey = (rel) => {
-      const d = this.readDisk(rel)
-      if (!d) return null
-      return d.skip || d.tooLarge ? undefined : d.key
-    }
+    const diskKey = (rel) => this.diskKey(rel)
     // The session and this folder must agree first: a change still on its way waits for the next look.
     // Following, that is every file the commits changed: the branch moves only once the session's versions are
     // on disk, or a commit made meanwhile (git commit -a) would take a file still on its way for a deletion.
@@ -3202,7 +3360,9 @@ export class Session extends EventEmitter {
       if (emptied.has(dir) || [...this.sharedPaths()].some((p) => (dir ? p.startsWith(dir + '/') : !p.includes('/')))) continue
       if (await hasFilesUnder(this.root, from, dir)) emptied.add(dir)
     }
-    const plan = planCatchUp({ changes: scope, base, theirs, disk: diskKey, moved, emptied, published: publishedOf(this.doc) })
+    // Where the session and the commits changed the same lines, the newer edit stays (upstream.js combine).
+    const times = await commitTimes(this.root, from, to)
+    const plan = planCatchUp({ changes: scope, base, theirs, disk: diskKey, moved, emptied, published: publishedOf(this.doc), oursNewer: (rel) => this.sessionEditedAt(rel) > ((times && times.get(rel)) || 0) + 999 }) // a commit's whole second is its own
     if (this.stopped || !this.quietForUpstream()) return
     if (plan.conflicts.length) {
       const behind = up ? up.behind : await commitsBetween(this.root, from, to)
@@ -3253,6 +3413,14 @@ export class Session extends EventEmitter {
     if (following) this.log(`⬇️ ${branch} follows ${isRelay(following) ? 'the relay' : `${following}'s folder`} to ${to.slice(0, 7)} (${count ?? 'new'} commit${count === 1 ? '' : 's'} from ${upName}); the session already has ${isRelay(following) ? 'the files it brought in' : 'their files'}`)
     const moves = plan.moves.length ? `; followed ${plan.moves.map((m) => `${m.from} → ${m.to}`).join(', ')}` : ''
     if (!following) this.log(`⬇️ brought in ${count ?? 'new'} commit${count === 1 ? '' : 's'} from ${upName} (${written} file${written === 1 ? '' : 's'})${moves}`)
+    // Whoever's lines the commits' newer edit replaced is told once (a notice, nothing to do).
+    for (const m of following ? [] : plan.merged || []) {
+      const lost = (m.lost || []).filter((l) => l.side === 'ours').flatMap((l) => l.lines)
+      if (!lost.length) continue
+      const text = `Quilt brought ${upName}'s commits into ${m.path}: where the session and the commits changed the same lines, the commits' newer edit stays. The replaced lines are in the file's history (Changes):\n${lost.slice(0, 12).map((l) => `- ${l}`).join('\n')}`
+      const who = this.lastEditorOf(m.path)
+      if (who && who !== this.name) { try { this.say(text, { to: who }) } catch {} } else this.log(`🧵 ${text}`)
+    }
     if (written && !following) await this.notePull({ from: { sha: from }, to: { sha: to, branch }, files: written })
     if (plan.strays.length) {
       const list = plan.strays.slice(0, 5).join(', ') + (plan.strays.length > 5 ? ', …' : '')
@@ -4061,7 +4229,6 @@ export class Session extends EventEmitter {
 
     if (!disk) {
       if (!this.files.has(rel) && !this.blobs.has(rel)) { this.lastKnown.delete(rel); return false }
-      this.closeHandMerge(rel, null) // deleting a file being merged by hand settles it too
       this.transact(() => {
         const was = this.files.get(rel)
         const before = was ? was.toString() : undefined
@@ -4088,7 +4255,6 @@ export class Session extends EventEmitter {
       // Storage refused it, but it's small enough to share inside the document.
     }
 
-    if (!disk.binary) this.closeHandMerge(rel, disk.text)
     let detail = ''
     this.transact(() => {
       const existed = this.files.has(rel) || this.blobs.has(rel)
@@ -5988,42 +6154,124 @@ export class Session extends EventEmitter {
     })
     if (!res.ok) throw new Error(`upload failed: ${await res.text()}`)
     const fileId = await res.text()
-    return this.say(text, { to, file: { id: fileId, name: path.basename(abs), size: st.size } })
+    const sent = this.say(text, { to, file: { id: fileId, name: path.basename(abs), size: st.size } })
+    // Ours is in the chat files folder too, like everyone's who can see it.
+    try {
+      const msg = this.chat.toArray().find((m) => m.id === sent.id)
+      const kept = this.chatFilePath(msg, { assign: true })
+      fs.copyFileSync(abs, kept)
+      this.chatFileArrived(msg, kept)
+      return { ...sent, file: this.describeMessage(msg).file }
+    } catch (err) {
+      this.log(`couldn't keep ${path.basename(abs)} in ${CHAT_FILES}/: ${err.message}`)
+      return sent
+    }
   }
 
-  /** Downloads a message's attachment (to .quilt/inbox/ by default). */
+  /** Downloads a message's attachment (to the chat files folder by default). */
   async fetchFile (msgOrId, dest) {
     const msg = typeof msgOrId === 'string' ? this.chat.toArray().find((m) => validMessage(m) && (m.id === msgOrId || (m.file && m.file.id === msgOrId))) : msgOrId
     if (!msg || !msg.file || !this.canSee(msg)) throw new Error('no such file')
-    const target = dest ? path.resolve(dest) : this.inboxPath(msg)
+    const fresh = !dest && !this.chatFileNames()[msg.id]
+    const target = dest ? path.resolve(dest) : this.chatFilePath(msg, { assign: true })
     const finalPath = fs.existsSync(target) && fs.statSync(target).isDirectory() ? path.join(target, safeName(msg.file.name)) : target
     if (!dest) {
-      // Belt and braces: the id and name are sanitised, so this can't escape the inbox; never let it anyway.
-      const inside = path.relative(path.join(this.stateDir, 'inbox'), finalPath)
-      if (!inside || inside.startsWith('..') || path.isAbsolute(inside)) throw new Error('refusing to save a file outside the inbox')
+      // Belt and braces: the name is sanitised, so this can't leave the folder; never let it anyway.
+      const inside = path.relative(path.join(this.root, CHAT_FILES), finalPath)
+      if (!inside || inside.startsWith('..') || path.isAbsolute(inside)) throw new Error('refusing to save a file outside the chat files folder')
+    }
+    try {
+      const res = await fetch(`${this.httpBase()}/files/${encodeURIComponent(this.room)}/${encodeURIComponent(msg.file.id)}`, {
+        headers: await this.relayHeaders()
+      })
+      if (!res.ok) throw new Error(`download failed: ${await res.text()}`)
+      fs.mkdirSync(path.dirname(finalPath), { recursive: true })
+      fs.writeFileSync(finalPath, Buffer.from(await res.arrayBuffer()))
+      if (!dest) this.chatFileArrived(msg, finalPath)
+    } catch (err) {
+      // Not saved: its name is free again, and the next start tries again.
+      if (fresh) this.forgetChatFile(msg.id)
+      throw err
     }
-    const res = await fetch(`${this.httpBase()}/files/${encodeURIComponent(this.room)}/${encodeURIComponent(msg.file.id)}`, {
-      headers: await this.relayHeaders()
-    })
-    if (!res.ok) throw new Error(`download failed: ${await res.text()}`)
-    fs.mkdirSync(path.dirname(finalPath), { recursive: true })
-    fs.writeFileSync(finalPath, Buffer.from(await res.arrayBuffer()))
     return finalPath
   }
 
-  /** Downloads unread files that were sent while we were offline. */
-  fetchMissedFiles () {
-    for (const m of this.messages({ unreadOnly: true, markRead: false, limit: 50 })) {
-      if (!m.file || m.file.localPath) continue
-      this.fetchFile(m.id).then(
-        (dest) => this.log(`📎 received ${m.file.name} from ${m.by} while you were away → ${path.relative(this.root, dest)}`),
-        () => {}
-      )
+  /**
+   * Every file in the chat I can see is in my chat files folder: those sent while I was away
+   * or before I joined are downloaded, one at a time; one an older Quilt kept in .quilt/inbox/ is moved.
+   * One saved before and since deleted from the folder stays deleted (opening it in chat fetches it again).
+   */
+  async fetchMissedFiles () {
+    if (this.fetchingMissed) return
+    this.fetchingMissed = true
+    try {
+      for (const m of this.chat.toArray()) {
+        if (this.stopped) return
+        try {
+          if (!m || !m.file || !this.canSee(m) || this.chatFileNames()[m.id]) continue
+          const old = path.join(this.stateDir, 'inbox', `${m.id.slice(0, 6)}-${safeName(m.file.name)}`)
+          if (fs.existsSync(old)) { const to = this.chatFilePath(m, { assign: true }); fs.renameSync(old, to); this.chatFileArrived(m, to); continue }
+          const dest = await this.fetchFile(m)
+          if (m.by !== this.name) this.log(`📎 received ${m.file.name} from ${m.by} while you were away → ${path.relative(this.root, dest)}`)
+        } catch {} // gone from the relay, or offline: the next start tries again
+      }
+    } finally { this.fetchingMissed = false }
+  }
+
+  /** Names given to chat files in the chat files folder, by message id (kept in .quilt/). */
+  chatFileNames () {
+    if (!this.chatFileIndex) {
+      try { this.chatFileIndex = JSON.parse(fs.readFileSync(path.join(this.stateDir, 'chat-files.json'), 'utf8')) } catch {}
+      if (!this.chatFileIndex || typeof this.chatFileIndex !== 'object') this.chatFileIndex = {}
+    }
+    return this.chatFileIndex
+  }
+
+  /**
+   * Where a message's file is kept: `Chat files/<its name>`, or `<name> (2)` and on when another
+   * file there has that name. With `assign`, a file not given a name yet gets one (and the folder is made).
+   */
+  chatFilePath (msg, { assign = false } = {}) {
+    const dir = path.join(this.root, CHAT_FILES)
+    const names = this.chatFileNames()
+    // Names come from safeName below; one edited by hand to leave the folder is taken for none.
+    let name = typeof names[msg.id] === 'string' && names[msg.id] === path.basename(names[msg.id]) && !names[msg.id].startsWith('.') ? names[msg.id] : null
+    if (!name) {
+      if (!assign) return null
+      const taken = new Set(Object.values(names))
+      const want = safeName(msg.file.name)
+      const ext = path.extname(want)
+      const stem = want.slice(0, want.length - ext.length) || want
+      name = want
+      for (let n = 2; taken.has(name) || fs.existsSync(path.join(dir, name)); n++) name = `${stem} (${n})${ext}`
+      names[msg.id] = name
+      writePrivateJson(path.join(this.stateDir, 'chat-files.json'), names)
+    }
+    if (assign) {
+      fs.mkdirSync(dir, { recursive: true })
+      // Git leaves the folder alone (Quilt never syncs it: pathrules.js), with nothing added to the project's .gitignore.
+      const gi = path.join(dir, '.gitignore')
+      if (!fs.existsSync(gi)) fs.writeFileSync(gi, '# Files sent in the Quilt session\'s chat: only for the people who can see them.\n*\n')
     }
+    return path.join(dir, name)
+  }
+
+  /** The app's file tree shows the chat files folder: a file saved there is a change to it. */
+  chatFileArrived (msg, file) {
+    this.emit('file-changed', { path: `${CHAT_FILES}/${path.basename(file)}`, by: msg.by, chat: true })
+  }
+
+  forgetChatFile (id) {
+    const names = this.chatFileNames()
+    if (!(id in names)) return
+    delete names[id]
+    try { writePrivateJson(path.join(this.stateDir, 'chat-files.json'), names) } catch {}
   }
 
-  inboxPath (msg) {
-    return path.join(this.stateDir, 'inbox', `${msg.id.slice(0, 6)}-${safeName(msg.file.name)}`)
+  /** The message's file in the chat files folder, when it is there. */
+  chatFileSaved (msg) {
+    const p = this.chatFilePath(msg)
+    return p && fs.existsSync(p) ? p : null
   }
 
   /**
@@ -6065,8 +6313,8 @@ export class Session extends EventEmitter {
   describeMessage (msg) {
     const out = { ...msg, unread: msg.by !== this.name && !this.readIds().has(msg.id) }
     if (msg.file && validMessage(msg)) {
-      const local = this.inboxPath(msg)
-      out.file = { ...msg.file, localPath: fs.existsSync(local) ? path.relative(this.root, local) : null }
+      const local = this.chatFileSaved(msg)
+      out.file = { ...msg.file, localPath: local ? path.relative(this.root, local) : null }
     }
     return out
   }
@@ -6647,7 +6895,8 @@ export class Session extends EventEmitter {
   settleReleasedMerges () {
     for (const rec of this.mergeList()) {
       if (rec.kind !== 'claimed' || rec.state !== 'open' || rec.by !== this.name || rec.binary || rec.oursDeleted || rec.theirsHash === null) continue
-      if (this.mergeHeldBy(rec) || this.writeRefusal(rec.path) || this.merging.has(rec.path)) continue
+      // A record anyone can write names any path: never one the session doesn't sync (.env, .git, ignored files).
+      if (!this.syncable(rec.path) || this.mergeHeldBy(rec) || this.writeRefusal(rec.path) || this.merging.has(rec.path)) continue
       const theirs = this.sharedKey(rec.path)
       if (typeof theirs !== 'string' || theirs.startsWith('bin:')) continue
       const tried = `${rec.id}:${sha1(theirs)}`
@@ -6658,10 +6907,13 @@ export class Session extends EventEmitter {
       const { ours, base } = this.mergeTexts(rec)
       if (typeof ours !== 'string') continue
       const holder = rec.claimedBy || rec.others[0] || 'someone'
-      if (theirs !== (base ?? '')) { this.log(`⚠️  ${holder} let go of ${rec.path}, and it changed meanwhile: see Merges`); continue }
       try {
-        this.applyMerged(rec.path, ours, `once ${holder} let go of it`)
-        updateMerge(this.bdoc, this.merges, rec.id, { state: 'done', resolvedBy: this.name, reason: `Went in once ${holder} let go of it: nobody else changed it meanwhile` }, LOCAL)
+        // Changed meanwhile: combined by Quilt (autoSettle's rule), the newer edit kept where both changed the same lines.
+        const oursNewer = rec.ts >= this.sessionEditedAt(rec.path)
+        const r = theirs === (base ?? '') ? { text: ours, lost: [] } : mergeAuto(base ?? '', ours, theirs, { oursNewer })
+        this.applyMerged(rec.path, r.text, `once ${holder} let go of it`)
+        updateMerge(this.bdoc, this.merges, rec.id, { state: 'done', how: r.lost.length && !oursNewer ? 'theirs' : 'mine', resolvedBy: 'Quilt', reason: r.lost.length ? `Went in once ${holder} let go of it, merged by Quilt: the newer edit kept where both changed the same lines` : `Went in once ${holder} let go of it` }, LOCAL)
+        this.noteLostLines(rec.path, { by: holder, lost: r.lost, oursWon: oursNewer })
       } catch (err) {
         this.log(`could not combine ${rec.path}: ${err.message}`)
         continue
@@ -6715,204 +6967,18 @@ export class Session extends EventEmitter {
     return { ours, base, theirs }
   }
 
-  /**
-   * Settles a merge: `mine` writes the returning person's version, `theirs`
-   * keeps the session's, `hand` puts conflict markers in the file for someone
-   * to edit (the record closes when the file next syncs without them),
-   * `agent` and `review` just close it (the file is already as wanted).
-   */
-  resolveMerge (id, { how } = {}) {
-    const rec = this.mergeList().find((m) => m.id === id)
-    if (!rec) throw new Error('no such merge')
-    if (rec.state === 'done') throw new Error('that merge is already settled')
-    if (!['mine', 'theirs', 'hand', 'agent', 'review'].includes(how)) throw new Error('say how: mine, theirs, hand, agent or review')
-    // A record anyone can write names any path: never touch one the session doesn't sync (.env, .git, ignored files).
-    if (!this.syncable(rec.path) && how !== 'agent' && how !== 'review') throw new Error(`${rec.path} is not synced in this session, so Quilt will not write it`)
-    // The doc holds the markers now, so "theirs" would be marker text.
-    if (rec.state === 'editing' && (how === 'theirs' || how === 'hand')) throw new Error(STILL_MARKED)
-    // Settling is an edit of the session: viewers (and agents outside their folders) only see the record.
-    const refusal = this.writeRefusal(rec.path)
-    if (refusal) throw new Error(refusal)
-    if (this.branchLive() && how === 'hand') throw new Error('This branch syncs with GitHub: conflict markers never go in the shared file. Propose the merged file with quilt_clash, or keep one side.')
-    if (this.branchLive() && this.kind === 'agent' && (how === 'mine' || how === 'agent')) throw new Error('This branch syncs with GitHub: the clash is held, and agents merge it with quilt_clash (propose; the reviewer accepts).')
-    // Someone else holds the file (settling it, or their AI is): only keeping the session's version is left, so nobody settles one merge twice.
-    if (how !== 'theirs') this.mergeHeldCheck(rec)
-    const onlyThere = () => new Error(`${rec.by === this.name ? 'your' : `${rec.by}'s`} version of ${rec.path} is only in the merge folder on ${rec.by === this.name ? 'the computer you merged on' : 'their computer'}`)
-    const { ours, base, theirs } = this.mergeTexts(rec)
-    if (how === 'mine') {
-      let data = null // null: deleted while away, so keeping mine deletes it in the session too
-      if (!rec.oursDeleted) {
-        // Binary versions never go in the record: only the opener's machine has ours.
-        data = ours
-        if (rec.binary) {
-          try { data = fs.readFileSync(path.join(this.mergeDir(rec.id), 'ours')) } catch {}
-        }
-        if (data === null) throw onlyThere()
-      }
-      this.keepMine(rec.path, data)
-    } else if (how === 'theirs') {
-      this.tryWrite(rec.path)
-    } else if (how === 'hand') {
-      if (!rec.binary && !rec.oursDeleted && ours === null) throw onlyThere()
-      if (rec.binary || ours === null || theirs === null) throw new Error('markers only work when both sides have a text version: keep mine or keep theirs instead')
-      this.applyMerged(rec.path, withMarkers(base || '', ours, theirs, { mine: rec.by, theirs: rec.others[0] || 'session' }), 'with conflict markers to edit by hand')
-      return updateMerge(this.bdoc, this.merges, id, { state: 'editing', how: 'hand', resolvedBy: this.name }, LOCAL)
-    }
-    const out = updateMerge(this.bdoc, this.merges, id, { state: 'done', how, resolvedBy: this.name }, LOCAL)
-    this.log(`✅ ${rec.path}: merge settled (${how === 'mine' ? `${rec.by}'s version` : how === 'theirs' ? "the session's version" : how === 'agent' ? 'merged by an AI' : 'reviewed'})`)
-    this.scheduleStatusWrite()
-    return out
-  }
-
-  /**
-   * Takes a merge's file for us before settling it or sending it to an AI, so two people
-   * can't settle one merge at once: the relay hands a claim to one of them and refuses the
-   * other, who then sees it claimed and can ask for it. Already ours: nothing to take.
-   * Returns whether a claim was made here, to let go of once the merge is settled.
-   */
-  async takeMerge (rec) {
-    if (!this.conn || this.mergeHeldBy(rec)) return false // offline, or someone else's: the checks after say so
-    const claim = this.claimFor(rec.path)
-    if (claim && this.ownClaim(claim)) return false
-    try {
-      await this.claim(rec.path, `${MERGE_CLAIM_NOTE} ${rec.path}`)
-    } catch (err) {
-      const by = /claimed by (.+)$/.exec(err.message)?.[1] || /overlaps (.+?)'s claim/.exec(err.message)?.[1]
-      throw new Error(by ? `${by} is settling ${rec.path} right now. Ask ${by} for it, or keep ${by}'s version once they're done.` : err.message)
-    }
-    this.mergeClaims.add(rec.path)
-    return true
-  }
-
-  /**
-   * Lets go of the claim a merge took (takeMerge) once it is settled; known by its note too,
-   * so one from before a restart goes as well. Someone waiting for it is handed it by its holder instead.
-   */
-  async releaseMergeClaim (rel) {
-    const took = this.mergeClaims.delete(rel)
-    const c = this.claims.get(rel)
-    if (!c || !this.ownClaim(c) || (c.queue && c.queue.length)) return
-    if (!took && !String(c.note || '').startsWith(MERGE_CLAIM_NOTE)) return
-    await this.release(rel).catch(() => {})
-  }
-
-  /** resolveMerge with the file taken first; the claim stays while markers are in it, and goes once it is settled. */
-  async settleMerge (id, { how } = {}) {
-    const rec = this.mergeList().find((m) => m.id === id)
-    if (!rec) throw new Error('no such merge')
-    const writes = how === 'mine' || how === 'theirs' || how === 'hand'
-    const took = writes && rec.state !== 'done' ? await this.takeMerge(rec) : false
-    let out
-    try {
-      out = this.resolveMerge(id, { how })
-    } catch (err) {
-      if (took) await this.releaseMergeClaim(rec.path)
-      throw err
-    }
-    if (out?.state === 'done') await this.releaseMergeClaim(rec.path)
-    return out
-  }
-
-  /** prepareMergeSend with the file taken first: it stays ours while our AI merges it, until the merge is settled. */
-  async sendMerge (id) {
-    const rec = this.mergeList().find((m) => m.id === id)
-    if (!rec) throw new Error('no such merge')
-    const took = rec.state === 'open' ? await this.takeMerge(rec) : false
-    try {
-      return this.prepareMergeSend(id)
-    } catch (err) {
-      if (took) await this.releaseMergeClaim(rec.path)
-      throw err
-    }
-  }
-
-  /**
-   * Keep mine: the disk first, then the doc, so a failed write never leaves
-   * the session with ours while the record stays open. `data` null deletes.
-   */
-  keepMine (rel, data) {
-    if (this.merging.has(rel) || this.downloading.has(rel)) throw new Error(`${rel} is still syncing; try again in a moment`)
-    const abs = resolveInside(this.root, rel)
-    if (data === null) {
-      fs.rmSync(abs, { force: true })
-      removeEmptyParents(this.root, path.dirname(abs))
-    } else {
-      fs.mkdirSync(path.dirname(abs), { recursive: true })
-      this.writeFile(rel, abs, data)
-    }
-    this.writeFailed.delete(rel) // the disk now holds a version we chose, not a stale one
-    if (this.ingest(rel)) return
-    // Nothing pushed: fine if the session already has it, or a large file is on its way up.
-    const want = data === null ? undefined : Buffer.isBuffer(data) ? `bin:${sha1(data)}` : data
-    if (this.sharedKey(rel) === want || (Buffer.isBuffer(data) && this.uploading.get(rel) === sha1(data))) return
-    throw new Error(`could not share ${rel}; the merge stays open`)
-  }
-
   /** Who else holds a merge's file right now, or null: settling it (or sending it to an AI) writes the file. */
   mergeHeldBy (rec) {
     const claim = this.claimFor(rec.path)
     return claim && !this.ownClaim(claim) ? claim : null
   }
 
-  mergeHeldCheck (rec) {
-    const claim = this.mergeHeldBy(rec)
-    if (claim) throw new Error(`${rec.path} is claimed by ${claim.by}${claim.note ? ` (${claim.note})` : ''}. Ask ${claim.by} for it to merge the two, or keep ${claim.by}'s version.`)
-  }
-
   /** A merge as status shows it: without its texts, with who holds the file and whether we asked for it. */
   mergeStatus ({ ours, base, ...m }) {
     const claim = m.state === 'done' ? null : this.mergeHeldBy(m)
     return claim ? { ...m, heldBy: claim.by, asked: (claim.queue || []).some((r) => r.by === this.name) } : m
   }
 
-  /** A file being edited by hand lost its markers: that merge is settled. */
-  closeHandMerge (rel, text) {
-    const rec = this.mergeList().find((m) => m.path === rel && m.state === 'editing')
-    if (!rec || hasMarkers(text)) return
-    updateMerge(this.bdoc, this.merges, rec.id, { state: 'done', how: 'hand', resolvedBy: this.name }, LOCAL)
-    this.log(`✅ ${rel}: merged by hand`)
-    this.releaseMergeClaim(rel).catch(() => {})
-  }
-
-  /** What a coding tool is asked to do for Send to…: names the three files, the path and the merge id. */
-  mergePromptFor (rec) {
-    const dir = path.relative(this.root, this.mergeDir(rec.id)).split(path.sep).join('/')
-    const other = rec.others[0] || 'someone in the session'
-    return `Merge conflict in \`${rec.path}\` (Quilt merge ${rec.id}).
-
-${rec.by} changed this file while away from the session; meanwhile ${other} changed it in the session. Quilt could not combine the two on its own. Please merge them:
-
-- \`${dir}/base\`: the version both started from
-- \`${dir}/ours\`: ${rec.by}'s version (offline)${rec.oursDeleted ? ' — deleted' : ''}
-- \`${dir}/theirs\`: the session's version (${other})${rec.theirsHash === null ? ' — deleted' : ''}
-- \`${rec.path}\`: currently the session's version
-
-Write the merged result to \`${rec.path}\`, keeping every change from both sides and changing no behaviour. If the two really cannot both be true, say so and ask ${rec.by} and ${other} in the chat (quilt_message) rather than picking one.
-When the file is right, call the \`quilt_resolve_merge\` tool with id \`${rec.id}\` and how \`agent\` (or tell the person to click Resolved in Quilt).
-`
-  }
-
-  /** Writes the three versions and PROMPT.md for a tool to work from; returns the prompt. */
-  prepareMergeSend (id) {
-    const rec = this.mergeList().find((m) => m.id === id)
-    if (!rec) throw new Error('no such merge')
-    if (rec.state === 'editing') throw new Error(STILL_MARKED)
-    // The prompt asks a tool to write rec.path: never one the session doesn't sync.
-    if (!this.syncable(rec.path)) throw new Error(`${rec.path} is not synced in this session, so Quilt will not send it`)
-    this.mergeHeldCheck(rec)
-    const dir = this.mergeDir(id)
-    fs.mkdirSync(dir, { recursive: true })
-    const { ours, base, theirs } = this.mergeTexts(rec)
-    // base and ours never change; theirs is rewritten, as the session may have moved on.
-    const put = (name, text) => { if (text !== null && !fs.existsSync(path.join(dir, name))) fs.writeFileSync(path.join(dir, name), text) }
-    put('base', base)
-    put('ours', ours)
-    if (theirs !== null) fs.writeFileSync(path.join(dir, 'theirs'), theirs)
-    const prompt = this.mergePromptFor(rec)
-    fs.writeFileSync(path.join(dir, 'PROMPT.md'), prompt)
-    return { prompt, dir }
-  }
-
   // ------------------------------------------------------------ AI feed --
 
   /**
@@ -7131,6 +7197,7 @@ When the file is right, call the \`quilt_resolve_merge\` tool with id \`${rec.id
       const blob = this.blobs.get(p)
       out.push({ path: p, binary: !!blob && !this.files.has(p), edited: edited.get(p) || null, claim: claimFor(p), github: fromGithub(p) })
     }
+    out.push(...this.chatFileEntries())
     out.sort((a, b) => a.path.localeCompare(b.path))
     return {
       files: out,
@@ -7139,10 +7206,28 @@ When the file is right, call the \`quilt_resolve_merge\` tool with id \`${rec.id
     }
   }
 
-  /** Contents of one shared file, straight from the shared doc (never from disk). */
+  /** The chat files folder, for the file tree: each file I can see that is saved there, with who sent it. */
+  chatFileEntries () {
+    const out = []
+    for (const m of this.chat.toArray()) {
+      try {
+        const p = m && m.file && this.canSee(m) ? this.chatFileSaved(m) : null
+        if (p) out.push({ path: `${CHAT_FILES}/${path.basename(p)}`, chat: { id: m.id, by: m.by, ts: m.ts, ...(m.to ? { to: m.to } : {}) } })
+      } catch {}
+    }
+    return out
+  }
+
+  /** Contents of one shared file, straight from the shared doc (never from disk); a chat file from the chat files folder. */
   readShared (rel) {
     rel = String(rel || '').replace(/^\.\//, '')
     if (!isSafeRelPath(rel)) return null
+    if (rel.startsWith(`${CHAT_FILES}/`)) {
+      const e = this.chatFileEntries().find((x) => x.path === rel)
+      if (!e) return null
+      const buf = fs.readFileSync(path.join(this.root, rel))
+      return buf.length <= MAX_TEXT_BYTES && !looksBinary(buf) ? { path: rel, text: buf.toString('utf8'), chat: e.chat } : { path: rel, binary: true, size: buf.length, chat: e.chat }
+    }
     const t = this.files.get(rel)
     if (t) return { path: rel, text: t.toString() }
     const b = this.blobs.get(rel)
@@ -7275,7 +7360,7 @@ When the file is right, call the \`quilt_resolve_merge\` tool with id \`${rec.id
     }
     this.stopped = true
     clearInterval(this.retryTimer)
-    if (this.watcher) await this.watcher.close()
+    if (this.watcher) await closeWatcher(this.watcher)
     for (const t of this.rechecks.values()) clearTimeout(t)
     this.rechecks.clear()
     clearInterval(this.reconcileTimer)