heyquilt 0.3.138 → 0.3.141

package/src/session.js

@@ -19,7 +19,7 @@ import { Connection, PUSH_REQUEST_TIMEOUT_MS, QUILT_MOVE_TIMEOUT_MS } from './co
 import { loadIdentity } from './identity.js'
 import { writePrivateJson } from './private-file.js'
 import { MAX_SHARED_FILE_BYTES, FEATURES } from './protocol.js'
-import { formatBytes, pullAdvice } from './status.js'
+import { formatBytes } 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, CHAT_FILES, closeWatcher
@@ -48,21 +48,12 @@ import { chatAbout, waitingOn, queuedFor, renderQueueNotice, askForIt, heldRefus
 import { makeSubscription, deliverEvents, deliverWebhook, parseWebhookUrl, webhookPayload } from './webhooks.js'
 import { MentionRunner, parseOnMention, readOnMention, writeOnMention } from './on-mention.js'
 import { pickChecklist } from './agent-task-workflow.js'
-import { cleanCommitFiles, ownerName, commitRequestMessage, MAX_COMMIT_DESCRIPTION } from './commit-request.js'
-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, 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, committedAs, hasFilesUnder, repoBranches, remoteHost, backWithGit, installGitHelpers, setPersonGit, hasCommit, pushLocal, bundleOf, adoptPublished, fetchSignedIn, movedRemoteUrl, commitTimes, pushedBase, changedSince, ownSinceFork, linksAt } 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'
-import { noCredentialsText } from './relay-github.js'
-import { clashTaskId, readClash, clashCandidates, clashOrder, holderOf, ownerLabel, clashTitle, clashFiles, clashBrief, leaveItNotice, clashFacts } from './clash.js'
-import { cleanGit, branchBoard, RELAY_BY, isRelay } from './branches.js'
+import { RELAY_NAME as RELAY_BY, isRelay } from './ui/chat.js'
 import { cleanTyping, TYPING_MS, AGENT_TYPING_MS } from './ui/chat.js'
 import { DEFAULT_KEY } from './branchdocs.js'
 import { boxEntry } from './boxes.js'
@@ -73,6 +64,30 @@ import { squareShort } from '@heyquilt/seam/lib/quilts/errors.js'
 export { applyTextDiff }
 
 const LOCAL = Symbol('local')
+
+/** A short name for a branch, a task or a session: lower case, dashes, at most `max` characters. */
+function slug (s, max = 40) {
+  return String(s || '').toLowerCase().normalize('NFKD').replace(/[^\w\s-]/g, '').trim().replace(/[\s_]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, max).replace(/-$/, '') || 'work'
+}
+
+/** Whether `root` is a git checkout (a .git folder, or a worktree's pointer file). */
+function hasGitDir (root) {
+  try { fs.statSync(path.join(root, '.git')); return true } catch { return false }
+}
+
+/** The branch a git checkout in `root` is on, read from .git/HEAD (no git run); null when none or detached. */
+function headBranch (root) {
+  try {
+    let dir = path.join(root, '.git')
+    if (fs.statSync(dir).isFile()) {
+      const m = /^gitdir:\s*(.+)$/m.exec(fs.readFileSync(dir, 'utf8'))
+      if (!m) return null
+      dir = path.resolve(root, m[1].trim())
+    }
+    const m = /^ref:\s*refs\/heads\/(.+)$/m.exec(fs.readFileSync(path.join(dir, 'HEAD'), 'utf8'))
+    return m ? m[1].trim() : null
+  } catch { return null }
+}
 const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904' // git's empty tree, the base of a branch pushed from nothing
 
 /**
@@ -258,10 +273,8 @@ export class Session extends EventEmitter {
     this.chat = this.doc.getArray('chat') // { by, text, ts }
     this.activity = this.doc.getArray('activity') // { by, path, kind, detail, ts }
     this.agentFeed = this.doc.getArray('agentFeed') // { id, by, tool, conv, kind, text, ts, summary?, title? }
-    this.commitRequests = this.doc.getMap('commitRequests') // id -> { id, by, message, ts, state: 'open'|'done', doneBy, hash }
     this.tasks = this.doc.getMap('tasks') // id -> { id, title, column, by, assignee, forAi, tool, files, conv, verified, qaNotes, recurring, cron, order, ts }
     this.taskComments = this.doc.getMap('taskComments') // task id -> [{ id, by, text, ts }] (task-comments.js)
-    this.clashes = this.doc.getMap('clashes') // git branch -> { task, sha, upstream }: the open clash task for that branch (clash.js)
     // Mentions, direct messages and tasks handed to this member (or their AI), for agents to wake on.
     this.inboxTracker = new Inbox()
     // Shared by every AI session working as this member (each runs its own `quilt mcp`): messages
@@ -457,32 +470,6 @@ export class Session extends EventEmitter {
     this.emit('identity', { name, kind, aiOf })
   }
 
-  /**
-   * A git folder's .gitignore ignores .quilt/ (gitignore.js), so git leaves this
-   * session's state alone. Before the watcher starts: the line is shared like any
-   * edit of .gitignore, and partners' git ignores it too.
-   */
-  ignoreQuiltState ({ share = false } = {}) {
-    // An edit we may not make (a viewer, or an editor kept to other folders)
-    // would only be refused (and kept aside) at every start.
-    if (this.access && this.access.state === 'approved' ? this.writeRefusal('.gitignore') : this.savedRole === 'viewer') return
-    const r = ensureQuiltIgnored(this.root)
-    if (r.added) {
-      this.ig = loadIgnore(this.root)
-      if (share) {
-        // Shared like any edit of .gitignore, but it is Quilt's, not this person's or their AI's: never claimed for them.
-        const d = this.readDisk('.gitignore')
-        this.quiltOwnWrite = '.gitignore'; this.quiltOwnKey = d ? d.key : null
-        this.queue('.gitignore') // the watcher's first scan takes the folder as it is
-      }
-      if (!this.quiltIgnoreSaid) this.log('Added .quilt/ to .gitignore so git leaves Quilt\'s state alone.')
-      this.quiltIgnoreSaid = true
-    } else if (r.error && !this.quiltIgnoreSaid) {
-      this.quiltIgnoreSaid = true
-      this.log(`⚠️ couldn't add .quilt/ to .gitignore (${r.error.message}); git stash -u or git clean could take Quilt's state away`)
-    }
-  }
-
   log (msg) { this.logs.push(msg); if (this.logs.length > 200) this.logs.shift(); this.emit('log', msg) }
 
   /**
@@ -540,79 +527,12 @@ export class Session extends EventEmitter {
   /** The folder's commit, for an entry's first version in a diff branch: while seeding, the branch's start; else HEAD. */
   entryBase () { return (this.seeding && this.seedBase) || (this.git && this.git.sha) || null }
 
-  /** For a first join of a diff branch: what the folder has that differs from HEAD, or null. */
-  async gitNowForJoin () {
-    return this.diffForm && this.git && this.git.sha ? await changedSince(this.root, this.git.sha).catch(() => null) : null
-  }
-
-  /** What the join of a branch asks for: a diff document measured from the newest commit a remote has (a new branch only). */
-  async diffJoinFields () {
-    if (!this.git || !this.git.sha || (this.features && !this.features.split(',').includes('branch-diffs'))) return {}
-    const base = await pushedBase(this.root).catch(() => null)
-    if (!base) return {}
-    // Which GitHub repository the folder is a clone of: a session new to it learns it from here.
-    const up = await upstreamOf(this.root).catch(() => null)
-    const url = (up && up.url) || await this.gitOut(['remote', 'get-url', 'origin'])
-    const m = /github\.com[:/]([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?\/?$/i.exec(String(url || ''))
-    return { form: 'diff', diffBase: base, ...(m ? { repo: `github.com/${m[1]}/${m[2]}` } : {}) }
-  }
-
-  /**
-   * The repository this folder's origin names was renamed or moved to another owner on GitHub (the relay
-   * says so: its record's `was`, from GitHub's webhook or another member's folder): origin is pointed at
-   * the new name, so fetches and pushes go there without GitHub's redirect, and the relay never hears the
-   * old name from here again.
-   */
-  async followRepoMove () {
-    const mine = (this.branchList || []).find((b) => b.key === this.branch)
-    const r = mine && mine.relay
-    if (!this.git || !r || !r.repo || !Array.isArray(r.was) || !r.was.length) return
-    const seen = `${r.repo}\0${r.was.join(',')}`
-    if (this.repoMoveSeen === seen) return
-    this.repoMoveSeen = seen
-    const up = await upstreamOf(this.root)
-    if (!up || !up.remote || up.remote === '.' || !up.url) return
-    const next = movedRemoteUrl(up.url, r.was, r.repo)
-    if (!next || next === up.url) return
-    const ok = await this.gitOut(['remote', 'set-url', up.remote, next])
-    if (ok === null) { this.repoMoveSeen = null; return }
-    this.log(`🔀 GitHub says the repository moved to ${r.repo.replace(/^github\.com\//, '')}: ${up.remote} points there now`)
-    this.checkUpstreamSoon({ fetch: true })
-  }
-
   /** The relay's list of the session's branches. */
   setBranches (list) {
-    const rs = this.relaySha()
     this.branchList = (Array.isArray(list) ? list : []).filter((b) => b && typeof b.key === 'string')
-    // GitHub renamed or moved the repository: this folder's origin follows it.
-    this.followRepoMove().catch((err) => this.emit('debug', `following a moved repository: ${err.message}`))
-    // The relay's record for this branch moved: what this folder says about it (upstreamFactsFor) is looked at again.
-    if (this.relaySha() !== rs) {
-      this.relayShaAt = Date.now()
-      if (this.upstreamFacts) { this.shareGit(); this.checkUpstreamSoon() }
-    }
-    // An agent's folder without git, now that the relay says which repository and commit its branch is at;
-    // a person's too, once git is on for everyone here (git for everyone).
-    if (this.ready && this.gitBacking && (this.kind === 'agent' || this.personGitOn()) && !this.git && !this.backing && this.relayEntryFor(this.branch)) {
-      this.maybeBackWithGit({ late: true }).catch((err) => this.emit('debug', `git backing: ${err.message}`))
-    }
-    // Whether the session's GitHub connection covers this person's repository may have changed: their git helper follows.
-    this.syncPersonGitSoon()
-    // Large files on a branch that syncs with GitHub, once the owner agreed: the relay gets its wrap of each key (plan §10).
     if (this.relayKeys && this.relayEntryFor(this.branch)?.fileKey) this.shareKeysWithRelay()
-    // An agent's folder that is a GitHub checkout already: its origin becomes the relay's git once the relay says it serves it (plan §9).
-    if (this.kind === 'agent' && this.git && !this.movedOrigin && !this.stopped && this.relayEntryFor(this.branch)?.git) {
-      this.movedOrigin = true
-      this.moveOriginToRelay().catch((err) => this.emit('debug', `git origin: ${err.message}`))
-    }
     // This folder's branch went over the size limit for one branch: said once, here and to its AI.
     const mine = this.branchList.find((b) => b.key === this.branch)
-    // An agent's folder on a branch that was merged goes back to the branch it merged into, so the finished branch
-    // can leave the session (relay-prune.js) and the next task starts from there. People choose for themselves.
-    if (this.kind === 'agent' && this.ready && mine && mine.merged && !mine.default && this.git && this.git.branch === mine.key && this.leftMerged !== mine.key && !this.stopped) {
-      this.leftMerged = mine.key
-      this.leaveMergedBranch(mine).catch((err) => this.emit('debug', `leaving the merged ${mine.key}: ${err.message}`))
-    }
     if (mine && mine.full && this.fullSaid !== mine.key) {
       this.fullSaid = mine.key
       const msg = `${mine.key} is over the session's size limit for one branch, so the relay takes no new changes on it; they stay in this folder. Other branches, chat and tasks carry on as usual. To keep syncing, start a fresh copy with \`git checkout -b <new name>\`: your changes since are kept in this folder.`
@@ -660,7 +580,7 @@ export class Session extends EventEmitter {
     // As at a first join: what differs is backed up once, by reconcileFirstJoin, not again as a live clash.
     const ready = this.ready
     this.ready = false
-    try { this.noteFirstJoin(this.reconcileFirstJoin(await this.gitNowForJoin())) } finally { this.ready = ready }
+    try { this.noteFirstJoin(this.reconcileFirstJoin(null)) } finally { this.ready = ready }
     this.log(`⚠️ ${msg}`)
     this.notice(msg)
     this.saveStateNow()
@@ -672,26 +592,18 @@ export class Session extends EventEmitter {
     this.loadWebhook()
     this.loadOnMention()
     const hadState = this.loadState()
-    // Back in a folder we synced before: the line is an offline edit, merged once synced. A first
-    // join adds it after taking the room's files (reconcileFirstJoin), which may replace .gitignore.
-    if (hadState) this.ignoreQuiltState()
+    // A folder never synced and empty as the session starts: in a session that is a layout-3 quilt already,
+    // whatever it gets before its block opens is the read-only branch document's older copy, never its
+    // member's edits (session-follow.js openHere; 2026-11-01). Cleared by a first word of the quilt that is
+    // not layout 3, and once the block opens.
+    this.joinedEmpty = !hadState && !walk(this.root, this.ig).some((rel) => this.syncable(rel))
     // Restarted while the folder follows its square: its .git is set aside (session-follow.js) and stays so; its branch is the note's.
-    this.gitAside = gitDir(this.root) ? null : gitAsideOf(this.root)
-    this.git = await headKey(this.root)
-    this.gitSeen = this.git
-    // A repo whose git can't be run (not on the PATH of an app started from the Dock, say) or
-    // didn't answer in time, as against a branch with no commits yet, which git reads fine.
-    const headTimedOut = !this.git && lastCallTimedOut(this.root)
-    const gitUnreadable = !this.git && !!gitDir(this.root) && (headTimedOut || !(headRef(this.root) && await gitRuns(this.root)))
+    this.gitAside = hasGitDir(this.root) ? null : gitAsideOf(this.root)
     if (hadState) this.loadClaims()
-    // Restarted on another branch, or mid-hold: nothing in this tree is the session's offline work (see resumeHold).
-    const resumed = hadState && this.resumeHold()
-    // The branch document this folder syncs: the branch it syncs in git (still the one it was paused off, until
-    // the folder follows git), ∅ (the room's default) without git.
-    this.branch = this.git ? this.git.key : (gitDir(this.root) && headRef(this.root)) || (this.gitAside && this.gitAside.branch) || DEFAULT_KEY
+    // The branch whose square this folder follows: the checkout's branch name, the set-aside note's, else the room's default.
+    this.branch = headBranch(this.root) || (this.gitAside && this.gitAside.branch) || DEFAULT_KEY
     // The form saved is the saved branch's; another branch's is the relay's to say when it is joined.
     if (this.savedBranch !== this.branch) { this.branchForm = null; this.diffBase = null }
-    const diffJoin = await this.diffJoinFields()
 
     this.conn = new Connection({
       server: this.server,
@@ -708,7 +620,7 @@ export class Session extends EventEmitter {
       doc: this.doc,
       // An app's saved document from before branch documents is the room's old one: the relay kept it as that branch's.
       // base: the commit a branch new to the session starts from (a partner without it locally creates it there).
-      branch: { key: this.branch, doc: this.bdoc, ...diffJoin, ...(this.git && this.git.sha ? { base: this.git.sha } : {}), ...(this.legacyState && this.savedGit ? { adopt: this.savedGit.key } : {}), ...(this.branchEpoch && this.savedBranch === this.branch ? { epoch: this.branchEpoch } : {}) },
+      branch: { key: this.branch, doc: this.bdoc, ...(this.branchEpoch && this.savedBranch === this.branch ? { epoch: this.branchEpoch } : {}) },
       // state.bin is a copy of an older document of this branch (it was removed and started again): never merged.
       onStaleBranch: (reply) => this.staleBranch(reply),
       beforeRemote: () => { if (this.ready) this.flushPending() }
@@ -731,6 +643,7 @@ export class Session extends EventEmitter {
     // Seam (Seam's plans/quilt-source-control/16): the relay says when the session is a quilt, and which.
     this.conn.on('quilt', (q) => {
       this.quilt = q
+      if (!(q && q.layout === 3)) this.joinedEmpty = false
       this.emit('quilt', q)
       // At layout 3 this folder follows its branch's square by itself (session-follow.js).
       if (!this.squareFollower) this.squareFollower = new SquareFollower(this)
@@ -751,22 +664,13 @@ export class Session extends EventEmitter {
       else if (!m && was) this.log(`🧵 the move of the session's code ${was.kind === 'back' ? 'back to its git branches' : 'into Seam'} is over.`)
       this.scheduleStatusWrite()
     })
-    // GitHub moved this folder's branch: fetch and bring it in now, not at the next minute's look.
-    this.conn.on('pushed', (p) => {
-      if (!this.git || !this.git.branch || p.branch !== this.branchKey() || this.stopped) return
-      if (p.sha && this.upstream && this.upstream.sha === p.sha && !this.upstream.behind) return
-      // A look with a fetch, as soon as the folder is quiet (it asks again by itself while files are still changing).
-      this.checkUpstreamSoon({ fetch: true, delay: 250 })
-    })
-    // A move's own join is the move's to finish (finishMove): this.branch changes only once the folder is there.
     this.conn.on('branch-joined', (r) => {
-      if (typeof r.branch !== 'string' || !r.branch || (this.hold && this.hold.kind === 'switching')) return
+      if (typeof r.branch !== 'string' || !r.branch) return
       if (typeof r.epoch === 'string' && r.epoch && !this.staleRejoin) this.branchEpoch = r.epoch
       // An older relay says no form: its documents are all full ones.
       this.branchForm = r.form === 'diff' ? 'diff' : 'full'
       if (r.form === 'diff' && typeof r.diffBase === 'string') this.diffBase = r.diffBase
       this.branch = r.branch
-      this.announceBranch()
       this.scheduleStatusWrite()
     })
     this.conn.on('branch-refused', (why) => this.log(`⚠️ the relay refused this folder's branch: ${why}`))
@@ -778,20 +682,13 @@ export class Session extends EventEmitter {
       // We've synced this folder before: hold what was edited while we were
       // away, let the relay tell us what the others did, then merge the two.
       const marks = historyMarks(this.history.entries()) // what we had seen: the catch-up is the rest
-      if (gitUnreadable) this.saysGitUnreadable(resumed)
-      const gitNow = this.diffForm && !resumed && this.git && this.git.sha ? await changedSince(this.root, this.git.sha).catch(() => null) : null
-      const offline = resumed ? { entries: [], take: [], downloads: [] } : this.captureOffline(gitNow)
+      const offline = this.captureOffline(null)
       this.goLive()
       // A folder that follows its square (its .git set aside) is compared with the branch document it last synced, which the
       // square's work has moved past: its block's first look says what went in, so nothing is said here.
       if (offline.entries.length && !gitAsideOf(this.root)) this.log(`${offline.entries.length} file(s) changed while you were away; merging once the relay has synced…`)
       const synced = this.conn.waitForSync()
-      // An agent's folder synced before folders were git-backed: once the relay has synced, with its
-      // branch's repository known, it is made a checkout, and git is watched from then on.
-      synced.then(() => this.maybeBackWithGit({ late: true })).catch(() => {})
       synced.then(() => this.mergeOffline(offline)).then((mine) => {
-        // A diff branch: files git had that were deleted while away are deleted for everyone.
-        for (const rel of offline.gone || []) if (this.followsGit(rel) && !this.onDisk(rel)) { this.lastKnown.set(rel, ''); this.ingest(rel) }
         if (mine) this.noteCatchUp({ ...awayChanges(this.history.entries(), marks, this.name), since: this.savedSeenAt, mine })
       }).catch((err) => {
         // Never synced (the relay refused us): nothing can be merged, so nothing stays held.
@@ -799,21 +696,7 @@ export class Session extends EventEmitter {
         this.awayBackups = null
         this.emit('debug', `offline merge did not run: ${err && err.message}`)
       })
-      if (resumed) {
-        // The doc loaded from disk is the room as it was at the last stop: the hold settles
-        // against the room as it is now. Never synced: the hold stays on and nothing is shared.
-        this.holdAwaitsSync = true
-        synced.then(() => {
-          this.holdAwaitsSync = false
-          // Restarted on another branch: the folder follows git there, now that it has the room's work on the old one.
-          const away = this.resumeAway
-          this.resumeAway = null
-          if (away) this.followHead(away)
-          else this.settleSoon()
-        }, () => {})
-      }
     } else {
-      if (gitUnreadable) this.saysGitUnreadable(false)
       this.log('waiting for relay…')
       const sync = this.conn.waitForSync()
       // In a session with an owner we may have to wait for them to let us in.
@@ -829,10 +712,8 @@ export class Session extends EventEmitter {
         if (first === 'pending') {
           // Finish joining in the background once let in.
           this.admitted = sync.then(async () => {
-            this.noteFirstJoin(this.reconcileFirstJoin(await this.gitNowForJoin()))
+            this.noteFirstJoin(this.reconcileFirstJoin(null))
             this.goLive()
-            this.ignoreQuiltState({ share: true })
-            await this.maybeBackWithGit()
             await this.startWatcher()
             this.log('✅ you were let in')
             this.emit('status-changed')
@@ -843,10 +724,8 @@ export class Session extends EventEmitter {
         clearTimeout(timer)
         this.conn.off('access', onAccess)
       }
-      this.noteFirstJoin(this.reconcileFirstJoin(await this.gitNowForJoin()))
+      this.noteFirstJoin(this.reconcileFirstJoin(null))
       this.goLive()
-      this.ignoreQuiltState({ share: true })
-      await this.maybeBackWithGit()
     }
     await this.startWatcher()
     // git was set aside while following a square, and the session is not one at layout 3 now (or Seam is off here): it comes back.
@@ -854,62 +733,6 @@ export class Session extends EventEmitter {
     return this
   }
 
-  /**
-   * An agent's folder that Quilt syncs but git doesn't know (no .git) is made a checkout of the
-   * session branch's repository, at the commit the session's files are measured from, with every
-   * file left as it is: git log and blame work, the folder follows the branch like any clone, and
-   * git signs in through Quilt (installGitHelpers): fetches always, pushes within the owner's policy
-   * (quilt_agent_commits), so the agent commits and pushes like anyone, or with quilt_commit.
-   * Returns whether it was done.
-   */
-  async maybeBackWithGit ({ late = false } = {}) {
-    // A person's folder too, while git is on for everyone here and a connection covers the repository (git for everyone): with GitHub as origin.
-    if (!this.gitBacking || (this.kind !== 'agent' && !this.personGitOn()) || this.git || gitDir(this.root) || this.gitAside || this.inSquare || this.stopped || this.backing) return false
-    // The relay's record of the branch (its repository and the commit the session is at) comes with its
-    // branch list; when it isn't here yet, setBranches tries again as it arrives (no wait at start).
-    const relay = this.relayEntryFor(this.branch)
-    if (!relay) return false
-    const repo = parseRepo(`https://${relay.repo}`)
-    const ref = upstreamRef(relay.upstream)
-    const key = this.branch === DEFAULT_KEY ? (this.branchList.find((b) => b.default) || {}).key : this.branch
-    if (!repo || !repo.github || !ref || !key) return false
-    this.backing = true // claimed before anything waits: a second call meanwhile (a late branch list) does nothing
-    try {
-      if (!(await gitRuns(this.root))) return false
-      // The relay's git (plan §9) when it serves the session's branches: no GitHub token on this machine, pushes checked and published by the relay.
-      const viaRelay = this.kind === 'agent' && !!relay.git && !!this.relayGitUrl()
-      const url = viaRelay ? this.relayGitUrl() : this.gitRemote ? this.gitRemote(relay.repo) : `https://${relay.repo}.git`
-      this.log(`🌱 making this folder a git checkout of ${relay.repo} at ${relay.sha.slice(0, 7)} (${key})${viaRelay ? ', through the relay' : ''}…`)
-      let r = viaRelay
-        ? await backWithGit(this.root, { url, ref, branch: key, sha: relay.sha, token: await this.passString(), user: 'quilt', helpers: this.gitHelpers() })
-        : await backWithGit(this.root, { url, ref, branch: key, sha: relay.sha, helpers: this.gitHelpers() })
-      if (!r.ok && !viaRelay) {
-        const token = await this.gitAuth()
-        if (token) r = await backWithGit(this.root, { url, ref, branch: key, sha: relay.sha, token, helpers: this.gitHelpers() })
-      }
-      if (!r.ok) { this.log(`⚠️ could not make this folder a git checkout (${r.error}); it syncs without git, and this is tried again at the next start`); return false }
-      if (this.stopped) return false
-      this.git = await headKey(this.root)
-      this.gitSeen = this.git
-      this.gitIndex = indexStamp(this.root)
-      if (this.branch === DEFAULT_KEY) this.branch = key // the folder is on the branch by name now
-      this.log(`✅ this folder is a git checkout of ${relay.repo} on ${key}: git log, blame, commit and push work (git signs in through Quilt, within the session's git setting), and quilt_commit works too`)
-      if (this.kind !== 'agent') { this.personGitSig = null; this.syncPersonGitSoon() }
-      if (late && this.watcher) this.startGitWatch()
-      this.announceBranch()
-      this.scheduleStatusWrite()
-      this.saveStateNow()
-      return true
-    } finally { this.backing = false }
-  }
-
-  /** Whether agents can commit on this branch themselves: the owner lets them, and a member's GitHub connection covers the repository (from the relay's branch list). */
-  canCommitHere () {
-    const policy = (this.access && this.access.agentCommits) || 'branches'
-    // The relay says (access.agentsCanCommit: the room's GitHub connection or token, whatever branch this folder is on); older relays only through the branch list.
-    return policy !== 'off' && !!(this.access && (this.access.agentsCanCommit === true || (this.access.agentsCanCommit === undefined && this.branchList.some((b) => b && b.relay && b.relay.github && b.relay.github.state === 'ok'))))
-  }
-
   /** This folder's branch as the relay names it (the room's default branch's own name, for a folder on ∅). */
   branchKey () { return this.branch === DEFAULT_KEY ? (this.branchList.find((b) => b.default) || {}).key || this.branch : this.branch }
 
@@ -921,384 +744,11 @@ export class Session extends EventEmitter {
     return r && r.sha && r.repo && r.upstream ? r : null
   }
 
-  /**
-   * A token for this branch's repository from the session's GitHub connection, or null; kept until
-   * near its expiry. `access` 'read' fetches; 'write' (an agent's folder pushing) is given by the relay
-   * within the owner's policy, and a read token already here is exchanged for it.
-   */
-  async gitAuth ({ access = 'read', repo = null } = {}) {
-    const t = this.gitToken
-    // Kept: a token that can write, or one that answered the same ask (the relay gave read for a write ask: no point asking again until something changes).
-    if (t && t.token && t.expiresAt - Date.now() > 60 * 1000 && (access === 'read' || t.access === 'write' || t.asked === access)) return t.token
-    if (t && !t.token && Date.now() - t.at < 10 * 60 * 1000 && (t.asked || 'read') === access) return null
-    try {
-      if (!this.conn || !this.conn.adminRequest) return null
-      const r = await this.conn.adminRequest({ op: 'gitToken', access, ...(repo ? { repo } : {}) })
-      if (r && r.git && r.git.token) { this.gitToken = { token: r.git.token, expiresAt: Number(r.git.expiresAt) || Date.now() + 30 * 60 * 1000, access: r.git.access === 'write' ? 'write' : 'read', asked: access }; return r.git.token }
-      this.gitToken = { no: (r && r.git && r.git.state) || 'error', at: Date.now(), asked: access }
-    } catch { this.gitToken = { no: 'error', at: Date.now(), asked: access } }
-    return null
-  }
-
-  /** The token already here and good for a minute more, or null (gitAuth asks for one). */
-  gitTokenNow () { const t = this.gitToken; return t && t.token && t.expiresAt - Date.now() > 60 * 1000 ? t.token : null }
-
-  /**
-   * What git in this folder signs in to `host` with (the credential helper, `quilt git-credential`):
-   * { username, password } from the session's GitHub connection, write access while git is on for
-   * everyone here, or {} (git then fails as it would without Quilt; a person's helper asks their own
-   * helpers then). A person's folder: only for the session's repository, where Quilt put its helper
-   * (syncPersonGit), with a token of their own.
-   */
-  async gitCredential ({ host = '' } = {}) {
-    if (!this.git) return {}
-    const want = String(host || '').toLowerCase()
-    if (this.kind !== 'agent') {
-      const pg = this.personGit
-      if (!pg || !pg.helper || !pg.repo) return {}
-      let urlHost = ''
-      try { urlHost = new URL(pg.url).host.toLowerCase() } catch {}
-      if (want !== 'github.com' && want !== urlHost) return {}
-      if (!this.personGitOn()) return {}
-      const token = await this.gitAuth({ access: 'write', repo: pg.repo })
-      return token ? { username: 'x-access-token', password: token } : {}
-    }
-    // The relay's git (plan §9): signed in with this agent's Quilt pass; no GitHub token reaches this machine.
-    const relay = this.relayGitUrl()
-    if (relay && want === new URL(relay).host.toLowerCase()) { const pass = await this.passString(); return pass ? { username: 'quilt', password: pass } : {} }
-    if (want !== 'github.com') return {}
-    // The repository is the folder's remote's, whatever branch is checked out (a new feature branch has no
-    // record on the relay yet); a remote that isn't a GitHub URL (a mirror, a local path) leaves it to the relay's record.
-    const repo = await this.originRepo()
-    // Write when the owner lets agents push (the relay gives read when it can't); read otherwise.
-    const policy = (this.access && this.access.agentCommits) || 'branches'
-    const token = await this.gitAuth({ access: policy !== 'off' ? 'write' : 'read', repo: repo && repo.github ? `${repo.owner}/${repo.name}` : null })
-    return token ? { username: 'x-access-token', password: token } : {}
-  }
-
-  /** Where the relay serves this session's git (plan §9): http(s)://<relay>/git/<room>.git, or null. */
-  relayGitUrl () {
-    try {
-      const u = new URL(String(this.server || ''))
-      if (!/^wss?:$/.test(u.protocol)) return null
-      return `${u.protocol === 'wss:' ? 'https:' : 'http:'}//${u.host}/git/${encodeURIComponent(this.room)}.git`
-    } catch { return null }
-  }
-
-  /** This member's current Quilt pass (what git signs in to the relay with), or null. */
-  async passString () {
-    try { return this.passes ? String(await this.passes.get()) : null } catch { return null }
-  }
-
-  /**
-   * An agent's folder whose origin is GitHub, in a session whose relay serves git (plan §9): origin
-   * becomes the relay, so no GitHub token is needed here and pushes are checked and published by the
-   * relay. Resolves whether it changed.
-   */
-  async moveOriginToRelay () {
-    if (this.kind !== 'agent' || !this.git) return false
-    const relay = this.relayEntryFor(this.branch)
-    const to = this.relayGitUrl()
-    if (!relay || !relay.git || !to) return false
-    // As configured, not as insteadOf rewrites it (git remote get-url would).
-    const url = await this.gitOut(['config', '--get', 'remote.origin.url'])
-    if (!url || url === to) return false
-    const repo = parseRepo(url)
-    if (!repo || !repo.github || `github.com/${repo.owner}/${repo.name}`.toLowerCase() !== String(relay.repo).toLowerCase()) return false
-    if ((await this.gitOut(['remote', 'set-url', 'origin', to])) === null) return false
-    const helpers = this.gitHelpers()
-    if (helpers) { try { await installGitHelpers(this.root, { ...helpers, host: new URL(to).hostname, origin: urlOrigin(to) }) } catch {} }
-    this.log(`🔁 this folder's git goes through the relay now (origin ${to}): pushes are checked and put on GitHub there, with no GitHub token on this machine`)
-    return true
-  }
-
-  /**
-   * After a push through the relay that GitHub had moved past, the relay put the commits on its head
-   * as new commits (replayed): this folder's branch then follows GitHub's, its own commits kept under
-   * refs/quilt/original/<branch>/, when every one of them is there (git cherry). Resolves whether it moved.
-   */
-  async followReplayed ({ up, at }) {
-    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
-    // 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
-    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: to }
-    this.gitIndex = indexStamp(this.root)
-    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
-  }
-
-  /** The repository this folder's git pushes to (parseRepo of the branch's remote, or origin), or null. */
-  async originRepo () {
-    const branch = this.git && this.git.branch
-    const remote = (branch && await this.gitOut(['config', '--get', `branch.${branch}.remote`])) || 'origin'
-    const url = await this.gitOut(['remote', 'get-url', remote])
-    // Through the relay's git (plan §9): the session's repository, not the relay's address.
-    if (url && url === this.relayGitUrl()) { const e = this.relayEntryFor(this.branch); return e && e.repo ? parseRepo(`https://${e.repo}`) : null }
-    return url ? parseRepo(url) : null
-  }
-
-  /**
-   * Whether a push from this folder may go ahead (the pre-push hook, `quilt git-pre-push`): `refs`
-   * are [{ localRef, localSha, remoteRef, remoteSha }] for `remote`. Agents push within the owner's
-   * policy: 'off' nothing, 'branches' only quilt/<agent>/… branches, 'any' anything; and never a push
-   * that rewrites what is on GitHub (a force-push: the branch there must be an ancestor of what is
-   * pushed). A push that may go is remembered, and once git's remote-tracking branch shows it, the
-   * session records what was published and tells the chat (notePushed). People's pushes are their own: always ok.
-   */
-  async pushCheck ({ remote = 'origin', refs = [] } = {}) {
-    const list = (Array.isArray(refs) ? refs : []).filter((r) => r && typeof r.remoteRef === 'string')
-    // A session that is a quilt lands work through Seam, and GitHub takes only Seam's export: an
-    // agent's push goes nowhere, and a person's to the session's repository is told the Seam way.
-    if (this.quilt && this.quilt.id && (this.kind === 'agent' || await this.isSessionRemote(remote))) return { ok: false, why: pushRefusal(this.quilt.slug || this.quilt.id) }
-    if (this.kind !== 'agent') return this.personPushCheck({ remote })
-    const policy = (this.access && this.access.agentCommits) || 'branches'
-    if (policy === 'off') return { ok: false, why: `${gitForEveryoneWords({ policy: 'off', by: this.offBy() })} Ask a person for the commit with quilt_request_commit.` }
-    if (policy === 'branches') {
-      const prefix = agentPrefix(this.name)
-      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 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".
-    const repo = await this.originRepo()
-    // Through the relay's git (plan §9) the relay signs in to GitHub itself: no token is asked for here.
-    const viaRelay = (await this.gitOut(['config', '--get', `remote.${remote || 'origin'}.url`])) === this.relayGitUrl()
-    if (repo && repo.github && list.length && !viaRelay) {
-      const token = await this.gitAuth({ access: policy !== 'off' ? 'write' : 'read', repo: `${repo.owner}/${repo.name}` })
-      if (!token) return { ok: false, why: `This folder can't sign in to GitHub to push: ${noCredentialsText({ state: (this.gitToken && this.gitToken.no) || 'error' }, `${repo.owner}/${repo.name}`, { verb: 'push to' })}` }
-    }
-    const sha = (s) => /^[0-9a-f]{40}$/.test(s || '') && !/^0+$/.test(s)
-    for (const r of list) {
-      if (!sha(r.localSha) || !sha(r.remoteSha)) continue // a new branch, or a deletion: nothing to rewrite
-      if ((await this.gitOut(['merge-base', '--is-ancestor', r.remoteSha, r.localSha])) === null) {
-        return { ok: false, why: `That push would rewrite ${r.remoteRef.replace(/^refs\/heads\//, '')} on GitHub (what is there isn't an ancestor of what you push). Quilt never rewrites or force-pushes history, and neither do agents: fetch, then rebase or merge onto the branch as it is, and push without --force.` }
-      }
-    }
-    const now = Date.now()
-    for (const r of list) {
-      if (!sha(r.localSha)) continue // a deletion: nothing published
-      if (!r.remoteRef.startsWith('refs/heads/')) continue
-      this.pendingPushes.push({ remote: String(remote || 'origin'), branch: r.remoteRef.slice('refs/heads/'.length), sha: r.localSha, was: sha(r.remoteSha) ? r.remoteSha : null, at: now, tries: 0 })
-    }
-    if (this.pendingPushes.length) this.notePushedSoon(1500)
-    return { ok: true }
-  }
-
-  /**
-   * A person's push (git for everyone): while git is on they push any branch; off is off for everyone,
-   * so a push to the session's repository is refused, saying who turned it off. Other remotes (a fork)
-   * are their own business.
-   */
-  async personPushCheck ({ remote = 'origin' } = {}) {
-    if (this.gitPolicy() !== 'off') return { ok: true }
-    const name = String(remote || 'origin')
-    const url = /^[a-z][a-z0-9+.-]*:\/\/|^[^/\s]+@[^/\s]+:/i.test(name) ? name : await this.gitOut(['config', '--get', `remote.${name}.url`])
-    const repo = url ? parseRepo(url) : null
-    if (!repo || !repo.github || !this.sessionRepos().has(`github.com/${repo.owner}/${repo.name}`.toLowerCase())) return { ok: true }
-    const by = this.offBy()
-    return { ok: false, why: `${gitForEveryoneWords({ policy: 'off', by })} ${by ? 'Its admins turn it back on in its settings.' : 'The session owner turns it back on in the session\'s settings (under Version control, This session\'s source control).'}` }
-  }
-
-  /** Whether `remote` (a name or URL) is the session's GitHub repository: its own folder's origin, or one its branches follow. */
-  async isSessionRemote (remote = 'origin') {
-    const name = String(remote || 'origin')
-    const url = /^[a-z][a-z0-9+.-]*:\/\/|^[^/\s]+@[^/\s]+:/i.test(name) ? name : await this.gitOut(['config', '--get', `remote.${name}.url`])
-    if (url && url === this.relayGitUrl()) return true
-    const repo = url ? parseRepo(url) : null
-    if (!repo || !repo.github) return false
-    return name === 'origin' || this.sessionRepos().has(`github.com/${repo.owner}/${repo.name}`.toLowerCase())
-  }
-
-  /** The rule over the session that turned git off ({ by, name }), or null when the owner did (or it is on). */
-  offBy () {
-    const by = this.access && this.access.agentCommitsBy
-    return by && by.mode === 'off' && this.gitPolicy() === 'off' ? by : null
-  }
-
-  /** Git for this session ('off', 'branches', 'any'), as the relay last said. */
-  gitPolicy () { return (this.access && this.access.agentCommits) || 'branches' }
-
-  /** The GitHub repositories the session's branches follow, as 'github.com/owner/name' in lower case. */
-  sessionRepos () {
-    const out = new Set()
-    for (const b of this.branchList) if (b && b.relay && /^github\.com\//i.test(String(b.relay.repo || ''))) out.add(String(b.relay.repo).toLowerCase())
-    return out
-  }
-
-  /** The GitHub account whose connection covers `repo` ('github.com/owner/name') for this session, or '' (none does). */
-  connectedLogin (repo = null) {
-    const want = repo ? String(repo).toLowerCase() : null
-    const e = this.branchList.find((b) => b && b.relay && b.relay.github && b.relay.github.state === 'ok' && (!want || String(b.relay.repo || '').toLowerCase() === want))
-    return e ? String(e.relay.github.login || '') || 'connected' : ''
-  }
-
-  /** Whether git is on for everyone here and a connection covers the session's repository (a person's folder gets Quilt's helper then). */
-  personGitOn () { return this.kind !== 'agent' && !!(this.access && this.access.state === 'approved') && this.gitPolicy() !== 'off' && !!this.connectedLogin() }
-
-  /** Git for everyone, as this member's app shows it: { on, words, login }. */
-  gitForEveryone () {
-    const policy = this.gitPolicy()
-    const login = this.connectedLogin()
-    return { on: policy !== 'off' && !!login, policy, words: gitForEveryoneWords({ policy, by: this.offBy(), login: login === 'connected' ? '' : login }), ...(login ? { login } : {}) }
-  }
-
-  /** syncPersonGit, when what it depends on changed since it last ran. */
-  syncPersonGitSoon () {
-    if (this.kind === 'agent' || !this.cli || this.stopped || !this.git) return
-    const sig = `${this.gitPolicy()}|${this.personGitOn()}|${[...this.sessionRepos()].sort().join(',')}|${this.connectedLogin()}`
-    if (sig === this.personGitSig) return
-    this.personGitSig = sig
-    this.syncPersonGit().catch((err) => this.emit('debug', `git helpers: ${err.message}`))
-  }
-
-  /**
-   * Git for everyone in a person's own folder: while it is a checkout of the session's GitHub repository
-   * over https, Quilt's pre-push hook is in it, and while git is on and a connection covers the repository,
-   * Quilt's credential helper for that repository's URL too (gitstate.js setPersonGit). Off takes the
-   * helper away; `leaving` takes both away. One at a time; a call meanwhile runs again after.
-   */
-  async syncPersonGit ({ leaving = false } = {}) {
-    if (this.kind === 'agent' || !this.cli) return
-    if (this.personGitBusy) { if (!leaving) { this.personGitAgain = true; return } await this.personGitBusy }
-    let done
-    this.personGitBusy = new Promise((resolve) => { done = resolve })
-    try {
-      do {
-        this.personGitAgain = false
-        if (!gitDir(this.root)) return
-        const configured = await this.gitOut(['config', '--get', 'remote.origin.url'])
-        const repo = configured ? parseRepo(configured) : null
-        const full = repo && repo.github ? `github.com/${repo.owner}/${repo.name}`.toLowerCase() : ''
-        const ours = !!full && this.sessionRepos().has(full)
-        // As git asks for credentials: the remote's URL with insteadOf applied; https only (ssh signs in with keys).
-        const effective = ours ? await this.gitOut(['remote', 'get-url', 'origin']) : null
-        const url = effective && /^https?:\/\//i.test(effective) ? effective.replace(/\/\/[^/@]*@/, '//') : ''
-        const helper = !leaving && ours && !!url && this.personGitOn() && !!this.connectedLogin(full)
-        const hook = !leaving && ours
-        const r = await setPersonGit(this.root, { ...this.cli, url, helper, hook })
-        const was = this.personGit
-        this.personGit = { url, repo: repo && repo.github ? `${repo.owner}/${repo.name}` : null, helper: r.helper, hook: r.hook }
-        if (leaving) continue
-        if (r.helper && !(was && was.helper)) this.log(`🔑 ${gitForEveryoneWords({ policy: this.gitPolicy(), login: this.connectedLogin(full) })} (Quilt signs git in for ${repo.owner}/${repo.name} in this folder only)`)
-        if (!r.helper && was && was.helper) this.log(`🔒 Quilt no longer signs git in for ${was.repo} here: ${this.gitPolicy() === 'off' ? 'git is off for everyone in this session' : 'no GitHub connection covers it now'}`)
-      } while (this.personGitAgain && !this.stopped)
-    } finally { this.personGitBusy = null; done() }
-  }
-
-  notePushedSoon (ms) {
-    if (this.pushTimer) clearTimeout(this.pushTimer)
-    this.pushTimer = setTimeout(() => { this.pushTimer = null; this.notePushed().catch((err) => this.emit('debug', `pushed: ${err.message}`)) }, ms)
-    this.pushTimer.unref()
-  }
-
-  /**
-   * Pushes the hook announced that git's remote-tracking branch now shows went through: the files
-   * they changed are recorded as published (so the session's copy is kept when the branch is merged
-   * and comes back down, upstream.js), and the chat hears what was pushed. Looked at again for up to two minutes.
-   */
-  async notePushed () {
-    if (this.stopped || !this.pendingPushes.length) return
-    const left = []
-    for (const p of this.pendingPushes) {
-      const tip = await this.gitOut(['rev-parse', '--verify', '-q', `refs/remotes/${p.remote}/${p.branch}`])
-      if (tip !== p.sha) { if (Date.now() - p.at < 2 * 60 * 1000) left.push(p); continue }
-      // What the push added: since the branch's old tip; for a new branch, since it left the default branch (or the remote's HEAD), or everything.
-      const main = (this.branchList.find((b) => b && b.default) || {}).key || 'main'
-      const base = p.was || (await this.gitOut(['merge-base', p.sha, `refs/remotes/${p.remote}/${main}`])) || (await this.gitOut(['merge-base', p.sha, `refs/remotes/${p.remote}/HEAD`])) || EMPTY_TREE
-      const names = base ? (await this.gitOut(['diff', '--name-only', '--no-renames', '-z', base, p.sha]) || '').split('\0').filter(Boolean).map(toPosix) : []
-      const files = new Map()
-      for (const rel of names) {
-        const buf = await this.gitOut(['cat-file', 'blob', `${p.sha}:${rel}`], { buffer: true })
-        if (buf) files.set(rel, buf)
-      }
-      const count = base ? Number(await this.gitOut(['rev-list', '--count', `${base}..${p.sha}`])) || 1 : 1
-      const repo = await this.originRepo()
-      const full = repo && repo.owner ? `${repo.owner}/${repo.name}` : null
-      const where = full ? `${full} ${p.branch}` : p.branch
-      this.log(`⬆️ pushed ${count} commit${count === 1 ? '' : 's'} to ${where}${names.length ? ` (${names.slice(0, 8).join(', ')}${names.length > 8 ? ', …' : ''})` : ''}`)
-      // The relay keeps the record and tells the chat (it writes for members whose own writes are held to a folder too); without it, this folder does.
-      const entries = [...files].map(([rel, buf]) => ({ path: rel, id: crypto.createHash('sha1').update(buf).digest('hex') }))
-      let told = false
-      if (this.conn && this.conn.adminRequest) {
-        const subject = (await this.gitOut(['log', '-1', '--format=%s', p.sha])) || ''
-        try { told = !!(await this.conn.adminRequest({ op: 'pushed', branch: p.branch, sha: p.sha, count, files: entries, subject })) } catch (err) { this.emit('debug', `pushed: ${err.message}`) }
-      }
-      if (!told) {
-        if (files.size) notePublished(this.doc, files, LOCAL)
-        this.postGitNote(`${this.name} pushed ${count} commit${count === 1 ? '' : 's'} to ${where}${names.length ? `: ${names.slice(0, 8).join(', ')}${names.length > 8 ? ` and ${names.length - 8} more` : ''}` : ''}${repo && repo.github ? ` https://github.com/${full}/commit/${p.sha}` : ''}`)
-      }
-    }
-    const landed = this.pendingPushes.length - left.length
-    this.pendingPushes = left
-    // A push landed: it may have set the branch's upstream (git push -u) or moved it. A fetch now tells the relay, not the next poll.
-    if (landed > 0) this.checkUpstreamSoon({ fetch: true, delay: 500 })
-    if (left.length) this.notePushedSoon(Math.min(30000, 2000 * 2 ** Math.min(4, ++left[0].tries)))
-  }
-
-  /** git's standard output in this folder (trimmed, or a Buffer with `buffer`), or null when it fails. */
-  gitOut (args, { buffer = false } = {}) {
-    return new Promise((resolve) => {
-      execFile('git', args, { cwd: this.root, encoding: buffer ? 'buffer' : 'utf8', maxBuffer: 64 * 1024 * 1024, timeout: 20000 }, (err, out) => resolve(err ? null : buffer ? out : String(out).trim()))
-    })
-  }
-
-  /**
-   * This folder's branch has no upstream, but its remote has a branch of the same name (a partner
-   * pushed it): fetched, and set as its upstream, as `git push -u` would. Returns upstreamOf after, or null.
-   */
-  async trackRemoteBranch () {
-    const branch = this.git && this.git.branch
-    if (!branch) return null
-    const main = (this.branchList.find((b) => b && b.default) || {}).key || 'main'
-    const remote = (await this.gitOut(['config', '--get', `branch.${main}.remote`])) || 'origin'
-    const url = await this.gitOut(['remote', 'get-url', remote])
-    if (!url) return null
-    const f = await fetchSignedIn(this.root, { name: `${remote}/${branch}`, remote, url, sha: null }, { kept: this.gitTokenNow(), fresh: () => this.gitAuth(), drop: () => { this.gitToken = null }, retry: remoteHost(url) === 'github.com' })
-    if (!f.ok) return null
-    if (!(await this.gitOut(['rev-parse', '-q', '--verify', `refs/remotes/${remote}/${branch}^{commit}`]))) return null
-    if ((await this.gitOut(['branch', `--set-upstream-to=${remote}/${branch}`, branch])) === null) return null
-    this.log(`🔗 ${branch} follows ${remote}/${branch} now (a partner pushed it), so its commits come into this folder`)
-    return upstreamOf(this.root)
-  }
-
-  /** How git in this agent's folder runs Quilt, and whom its commits are credited to (installGitHelpers), or null. */
-  gitHelpers () { return this.cli && this.kind === 'agent' ? { ...this.cli, identity: { name: this.name, email: noreply(this.name) } } : null }
-
-  /** Puts the credential helper and pre-push hook in an agent's folder that git already knows (a clone, or one backed before they existed). */
-  async ensureGitHelpers () {
-    const helpers = this.gitHelpers()
-    if (!helpers || !this.git || this.helpersDone) return
-    this.helpersDone = true
-    try {
-      // The host git signs in to: the remote's, or GitHub's when the session follows a GitHub repository and the remote is a path (a mirror).
-      if (await this.moveOriginToRelay()) return
-      const up = await upstreamOf(this.root)
-      const host = (up && up.url && remoteHost(up.url)) || (this.branchList.some((b) => b && b.relay && /^github\.com\//.test(String(b.relay.repo || ''))) ? 'github.com' : null)
-      await installGitHelpers(this.root, { ...helpers, host, origin: up && up.url ? urlOrigin(up.url) : '' })
-    } catch (err) { this.emit('debug', `git helpers: ${err.message}`) }
-  }
-
   // --------------------------------------------------------------- access --
 
   setAccess (a) {
     const was = this.access
     this.access = a
-    // What agents may push changed: the token here may be the wrong one now (or taken back). Ask again.
-    if (was && was.agentCommits !== a.agentCommits) this.gitToken = null
-    this.syncPersonGitSoon() // git for everyone: a person's helper follows git on or off
     if (a.state === 'approved' && a.owner) this.sendStartName()
     if (this.force && this.force.migrate && a.state === 'approved' && a.owner) this.onForce(this.force)
     // A new session becomes a quilt as its owner (in a room with no owner, the relay lets any editor: quiltPlanRefusal).
@@ -1362,17 +812,6 @@ export class Session extends EventEmitter {
    * the folders they may change.
    */
   approve (key, { role, scopes, typeId, access } = {}) { return this.conn.adminRequest({ op: 'approve', key, role, scopes, typeId, access }) }
-  /** The owner's "Sync with GitHub" switch for this session (GitHub as a node). */
-  setGithubSync (on) { return this.conn.adminRequest({ op: 'githubSync', on: on !== false }) }
-  /** The owner lets the relay read large files on branches that sync with GitHub, so it can commit them (plan §10). */
-  setLargeToRelay (on) { return this.conn.adminRequest({ op: 'largeToRelay', on: on === true }) }
-  /** A person takes an agent's branch into theirs, pushed as one commit (relay-outbound.js adoptBranch). */
-  async adoptBranch (from) { return (await this.conn.adminRequest({ op: 'adopt', from: String(from || '') }, { timeoutMs: PUSH_REQUEST_TIMEOUT_MS })).adopt }
-  /** quilt_clash: a file held because the session and GitHub changed the same lines (relay-clash.js), resolved through the relay. */
-  async clash ({ action, path: rel = '', content = null, checks = null, force = false } = {}) {
-    if (!this.conn || !this.conn.adminRequest) throw new Error('not connected')
-    return this.conn.adminRequest({ op: 'clash', action, path: rel, ...(typeof content === 'string' ? { content } : {}), ...(checks ? { checks } : {}), ...(force ? { force: true } : {}) })
-  }
   deny (key) { return this.conn.adminRequest({ op: 'deny', key }) }
   setMember (key, { role, scopes, access } = {}) { return this.conn.adminRequest({ op: 'set', key, role, scopes, access }) }
   removeMember (key) { return this.conn.adminRequest({ op: 'remove', key }) }
@@ -1382,21 +821,8 @@ export class Session extends EventEmitter {
   /** Owner only: names the session for everyone in it (1 to 80 characters). */
   rename (name) { return this.conn.adminRequest({ op: 'name', name }) }
 
-  /**
-   * Owner only: the read-only GitHub token the relay uses to bring commits in from a private
-   * repository while no folder is online (relay-upstream.js); '' clears it. It goes to the relay
-   * and stays there: never in presence, the branch list or this app's status (only whether one is set).
-   */
-  async setGithubToken (token) {
-    if (!this.conn) throw new Error('not connected to the relay')
-    if (!this.isOwner) throw new Error('only the session owner can set the GitHub token')
-    const r = await this.conn.adminRequest({ op: 'githubToken', token: String(token ?? '').trim() })
-    return { ok: true, githubToken: !!r.githubToken }
-  }
-
   /** A new session is named after its folder, once, as soon as the relay lets us in as its owner. */
   sendStartName () {
-    this.sendStartAgentCommits()
     this.sendWorkspace()
     if (!this.startName || this.startNameSent) return
     this.startNameSent = true
@@ -1429,15 +855,6 @@ export class Session extends EventEmitter {
     this.sendWorkspace()
   }
 
-  /** A new room starts with the relay's default (branches); your setting, when it differs, is put on the room once. */
-  sendStartAgentCommits () {
-    const mode = this.startAgentCommits
-    if (!mode || this.startAgentCommitsSent) return
-    this.startAgentCommitsSent = true
-    if (mode === ((this.access && this.access.agentCommits) || 'branches')) return
-    this.setAgentCommits(mode).catch((err) => this.log(`couldn't set what agents may commit: ${err.message}`))
-  }
-
   goLive () {
     this.observeBranch()
     this.shareKeysWithViewers()
@@ -1469,25 +886,10 @@ export class Session extends EventEmitter {
     })
     this.activity.observe(() => this.scheduleStatusWrite())
     this.tasks.observe((ev, tr) => {
-      this.scanInbox({ quiet: tr.origin === LOCAL || tr.origin === CLASH })
-      // A clash task moved, reassigned or taken off the board by someone else: looked at again.
-      if (tr.origin !== CLASH) {
-        const clashTasks = new Set([...this.clashes.values()].map((r) => r && r.task))
-        if ([...ev.keysChanged].some((k) => clashTasks.has(k))) this.reviewClashSoon()
-      }
+      this.scanInbox({ quiet: tr.origin === LOCAL })
       this.scheduleStatusWrite()
     })
-    this.clashes.observe((ev, tr) => { if (tr.origin !== CLASH) this.reviewClashSoon() })
     this.taskComments.observe(() => this.scheduleStatusWrite())
-    this.commitRequests.observe((ev, tr) => {
-      for (const [id, change] of ev.changes.keys) {
-        const r = this.commitRequests.get(id)
-        if (tr.origin === LOCAL || !r) continue
-        if (change.action === 'add') { this.log(`📌 ${r.by} asked for a commit: ${r.message}`); this.reviewCommitsSoon() }
-        else if (r.state === 'done') this.log(`✅ ${r.doneBy || 'the host'} committed ${r.hash ? r.hash.slice(0, 7) : ''} (${r.message})`)
-      }
-      this.emit('status-changed')
-    })
     this.agentFeed.observe((ev) => {
       const added = []
       for (const item of ev.changes.added) for (const e of item.content.getContent()) if (e && e.id) added.push(e)
@@ -1497,11 +899,6 @@ export class Session extends EventEmitter {
     this.ready = true
     this.scanInbox({ quiet: true }) // take stock: what is already here wakes nobody
     this.fetchMissedFiles()
-    // Commit requests: those waiting are looked at once this folder has settled, and again now and then
-    // (a file someone held is let go of, a request that couldn't be committed by itself is retried).
-    this.reviewCommitsSoon(20000)
-    this.reviewCommitsTimer2 = setInterval(() => this.reviewCommitsSoon(0), 2 * 60 * 1000)
-    if (this.reviewCommitsTimer2.unref) this.reviewCommitsTimer2.unref()
     this.scheduleStateSave()
     this.scheduleStatusWrite()
   }
@@ -1657,7 +1054,7 @@ export class Session extends EventEmitter {
     }
     // When we were last in touch with the session: "you left 3h ago" on the next catch-up.
     if (this.conn && this.conn.connected) this.savedSeenAt = Date.now()
-    fs.writeFileSync(path.join(this.stateDir, 'state.json'), JSON.stringify({ room: this.room, server: this.server, layout: 2, branch: this.branch, ...(this.branchEpoch ? { epoch: this.branchEpoch } : {}), ...(this.branchForm ? { form: this.branchForm } : {}), ...(this.diffBase ? { diffBase: this.diffBase } : {}), storedOnDisk: Object.fromEntries(this.storedOnDisk), known, ...(this.boxBase.size ? { boxBase: Object.fromEntries(this.boxBase) } : {}), ...(Object.keys(behind).length ? { behind } : {}), ...this.gitState(), ...this.roleState(), ...(this.savedSeenAt ? { seenAt: this.savedSeenAt } : {}) }))
+    fs.writeFileSync(path.join(this.stateDir, 'state.json'), JSON.stringify({ room: this.room, server: this.server, layout: 2, branch: this.branch, ...(this.branchEpoch ? { epoch: this.branchEpoch } : {}), ...(this.branchForm ? { form: this.branchForm } : {}), ...(this.diffBase ? { diffBase: this.diffBase } : {}), storedOnDisk: Object.fromEntries(this.storedOnDisk), known, ...(this.boxBase.size ? { boxBase: Object.fromEntries(this.boxBase) } : {}), ...(Object.keys(behind).length ? { behind } : {}), ...this.roleState(), ...(this.savedSeenAt ? { seenAt: this.savedSeenAt } : {}) }))
   }
 
   /** This member's role, so the next start knows it before the relay says (ignoreQuiltState). */
@@ -1666,18 +1063,6 @@ export class Session extends EventEmitter {
     return role ? { role } : {}
   }
 
-  /**
-   * What state.json keeps of git: the branch this session syncs, the commit
-   * it was last seen at there, and whether a hold was on. The next start
-   * reads them in resumeHold.
-   */
-  gitState () {
-    if (!this.git) return this.savedGit ? { gitKey: this.savedGit.key, gitSha: this.savedGit.sha, gitHeld: this.savedGit.held } : {}
-    const seen = this.hold ? this.hold.prevHead : this.gitSeen
-    // A burst still being classified counts as held: a crash then restarts held, never sharing what git did.
-    return { gitKey: this.git.key, gitSha: seen && seen.key === this.git.key ? seen.sha : null, gitHeld: this.held() }
-  }
-
   // ------------------------------------------------------------ reconcile --
 
   sharedPaths () {
@@ -1871,7 +1256,6 @@ export class Session extends EventEmitter {
 
   /** Merges one captured path. Returns what happened, or null when nothing needed doing. */
   async mergeOne (e) {
-    if (e.carried) return this.mergeCarried(e) // work a checkout carried from another branch
     const { rel, base, via = null } = e
     const release = () => this.merging.delete(rel)
     const disk = this.readDisk(rel)
@@ -1915,14 +1299,6 @@ export class Session extends EventEmitter {
       release()
       return 'merged'
     }
-    // A pull of GitHub's commits on a branch that syncs live with GitHub, that the relay didn't bring in first
-    // (relayHasPull): GitHub's commits come into the session combined line by line, as the relay brings them
-    // (relay-sync.js); the rule below is for changes between people. Lines both changed are still left to settle.
-    if (via === 'pull' && !conflicts.length && this.branchLive()) {
-      this.applyMerged(rel, text, 'with GitHub\'s changes', { pulled })
-      release()
-      return 'merged'
-    }
     // Otherwise (offline, a pull) both sides changed it: Quilt combines them itself.
     return this.autoSettle({ rel, base, ours, theirs, theirsBy, disk, binary: false, via })
   }
@@ -2041,14 +1417,9 @@ export class Session extends EventEmitter {
       applyTextDiff(ytext, text)
       this.recordActivity(rel, 'merged', detail, { before, after: text }, { pulled }) // the chronology keeps the merge's diff
     }, LOCAL)
-    if (this.held()) {
-      // git is at work on the folder: the merge reaches the disk when the hold ends (lastKnown, the base then, stays).
-      this.heldPaths.add(rel)
-    } else {
-      fs.mkdirSync(path.dirname(abs), { recursive: true })
-      this.writeFile(rel, abs, text)
-      this.lastKnown.set(rel, text)
-    }
+    fs.mkdirSync(path.dirname(abs), { recursive: true })
+    this.writeFile(rel, abs, text)
+    this.lastKnown.set(rel, text)
     this.setOnDisk(rel, null)
     this.noteMyEdit(rel, { pulled })
     this.log(`🧵 merged ${rel} ${detail}`)
@@ -2238,7 +1609,7 @@ export class Session extends EventEmitter {
     // The folder follows its square: the block sees every change; git moving HEAD may take it to another branch's square.
     // The app hears of each change on disk all the same (its Files list and an open file read the folder then: squareFiles).
     if (this.syncStopped) return // live sync stopped at the forced date (onForce): the folder is plain git
-    if (this.inSquare) { if (rel === HEAD_CHANGED) this.squareHeadMoved(); else this.emit('file-changed', { path: rel }); return }
+    if (this.inSquare) { this.emit('file-changed', { path: rel }); return }
     this.pending.add(rel)
     if (!this.flushTimer) this.flushTimer = setTimeout(() => this.flushPending(), FLUSH_MS)
   }
@@ -2248,22 +1619,6 @@ export class Session extends EventEmitter {
     this.flushTimer = null
     const paths = [...this.pending]
     this.pending.clear()
-    if (this.classifying) {
-      // A burst is being classified: these wait behind it, and are looked at together once it's known.
-      for (const rel of paths) this.classifying.behind.add(rel)
-      return
-    }
-    if (this.hold) {
-      for (const rel of paths) if (rel !== HEAD_CHANGED) this.heldPaths.add(rel)
-      // Only a change here puts the settle off: the flush before each update from the room
-      // (beforeRemote) has none, and a partner typing must not hold this folder for good.
-      // A move to another branch ends on its own (finishMove).
-      if (paths.length && this.hold.kind !== 'switching') this.settleSoon()
-      // A move that didn't finish follows HEAD wherever git takes it next (back to the old branch resumes it).
-      else if (this.hold.kind === 'switching' && paths.includes(HEAD_CHANGED) && !this.following) this.recheckSoon()
-      return
-    }
-    if (this.git && this.isBurst(paths)) return this.startClassify(paths)
     this.ingestAll(paths)
   }
 
@@ -2273,152 +1628,10 @@ export class Session extends EventEmitter {
     }
   }
 
-  // ------------------------------------------------------------------ git --
-  // A git operation in a synced folder (stash, reset, pull, rebase, checkout)
-  // rewrites files in a burst. Those are not edits: the folder's sync is held
-  // until git is done, then the room's work is put back (discard), the new
-  // commits are merged into it (advance), or the folder pauses (switch).
-
-  /** Did git just touch this folder? (index written, HEAD moved, an operation in progress, or a flood of paths) */
-  isBurst (paths) {
-    const stamp = indexStamp(this.root)
-    const indexChanged = stamp !== this.gitIndex
-    this.gitIndex = stamp
-    this.burstByIndex = indexChanged
-    return indexChanged || Date.now() - this.headChangedAt < 2000 || !!this.gitBusy() || paths.length >= BURST_PATHS ||
-      // A session file gone from here: git is asked first whether a fetched pull brings it (making way, not a deletion).
-      paths.some((rel) => this.syncable(rel) && this.sharedKey(rel) !== undefined && !this.onDisk(rel))
-  }
-
-  /** The git operation under way in this folder, or null; a leftover index.lock doesn't count. */
-  gitBusy () { return gitBusy(this.root, undefined, this.leftoverLock) }
-
-  /** Whether the folder's sync is held: git is at work on it, or a burst of changes is being classified. (A move's own writes go through: arrive.) */
-  held () { return !!((this.hold && !this.arriving) || this.classifying) }
-
-  /**
-   * Runs git work in this folder one piece at a time, in order (a burst's
-   * classification, a settle, a look at HEAD), each skipped once stopped.
-   */
-  gitTask (fn) {
-    const run = this.gitChain.then(() => this.stopped ? undefined : fn())
-    this.gitChain = run.catch(() => {})
-    return run
-  }
-
-  /**
-   * Asks git what a burst was, off the event loop. Until it's known the
-   * folder is held as during a hold: nothing is shared or written, and later
-   * flushes wait behind it.
-   */
-  startClassify (paths) {
-    const c = this.classifying = { behind: new Set() }
-    this.gitTask(() => this.classifyBurst(paths, c)).catch((err) => {
-      this.log(`could not read git: ${err.message}`)
-      if (this.classifying !== c || this.stopped) return
-      // Never held for good: held as git being busy, and asked again every SETTLE_MS.
-      const behind = this.endClassify(c)
-      for (const rel of paths) if (rel !== HEAD_CHANGED) this.heldPaths.add(rel)
-      this.setHold('busy')
-      this.settleSoon()
-      this.requeue(behind)
-    })
-  }
-
-  /** The burst is known: the folder is no longer held for it. Returns the paths that waited behind it. */
-  endClassify (c) {
-    if (this.classifying !== c) return []
-    this.classifying = null
-    return [...c.behind]
-  }
-
   requeue (paths) {
     if (!this.stopped) for (const rel of paths) this.queue(rel)
   }
 
-  async classifyBurst (all, c) {
-    let paths = all.filter((p) => p !== HEAD_CHANGED)
-    let again = false
-    let r
-    for (;;) {
-      await this.noteCommits()
-      r = await classify(this.root, { changed: paths, before: this.gitSeen, leftover: this.leftoverLock, indexWrote: this.burstByIndex || again })
-      if (this.stopped) return
-      // git wrote the index, yet HEAD hasn't moved and the paths aren't clean: a checkout or a pull
-      // can be in the instant between writing the index and moving the branch. Asked once more, a flush later.
-      if (r.kind !== 'edit' || !r.head || !paths.length || !this.burstByIndex || r.putBack.length || again || this.hold) break
-      again = true
-      await new Promise((resolve) => setTimeout(resolve, FLUSH_MS))
-      if (this.stopped) return
-      const more = [...c.behind].filter((p) => p !== HEAD_CHANGED)
-      c.behind.clear()
-      paths = [...new Set([...paths, ...more])]
-      this.isBurst(paths) // the index as the next flush would see it
-    }
-    const runs = r.head ? true : await gitRuns(this.root) // asked while still held
-    if (this.stopped) return
-    // Removed files the fetched upstream adds: making way for a pull (git won't pull over untracked files), kept for everyone.
-    if (r.head && (r.kind === 'edit' || r.kind === 'discard')) r.awaitPull = await this.makingWay(paths)
-    if (this.stopped) return
-    const behind = this.endClassify(c)
-    try { this.settleBurst(r, paths, again, runs) } finally { this.requeue(behind) }
-  }
-
-  /** Acts on what git says a burst was (classifyBurst). Nothing here waits on git. */
-  settleBurst (r, paths, again, runs) {
-    if (r.awaitPull && r.awaitPull.length) {
-      this.waitForPull(r.awaitPull, r.kind === 'discard')
-      const away = new Set(r.awaitPull)
-      paths = paths.filter((rel) => !away.has(rel))
-    }
-    if (this.hold) {
-      // git's watcher started a hold meanwhile: the burst is held with the rest.
-      for (const rel of paths) this.heldPaths.add(rel)
-      if (this.hold.kind !== 'switching') this.settleSoon()
-      return
-    }
-    if (!r.head) return this.headless(paths, runs) // this.git is set, so this is a repo
-    this.gitFailures = 0
-    this.gitSeen = r.head
-    if (r.kind === 'edit') {
-      // git wrote the index and put some of these paths back (a stash in the same flush as an
-      // untracked file's save): held, so the settle restores those and shares only the rest.
-      if (paths.length && (this.burstByIndex || again) && r.putBack.length) {
-        for (const rel of paths) this.heldPaths.add(rel)
-        this.setHold('settling', { prevHead: r.prevHead })
-        this.settleSoon()
-        return
-      }
-      // What changed while git was asked (from the room, or a retried write) was held. A path
-      // outside the burst whose disk is as Quilt left it gets the room's version as it is; the
-      // rest merge against the version both sides last had, as a settle merges what changed during a hold.
-      const late = [...this.heldPaths]
-      this.heldPaths.clear()
-      const waited = new Set(late)
-      const burst = new Set(paths)
-      this.ingestAll(paths.filter((rel) => !waited.has(rel)))
-      const entries = []
-      for (const rel of late) {
-        if (!this.syncable(rel) || this.merging.has(rel)) continue
-        if (!burst.has(rel) && this.untouchedHere(rel)) this.tryWrite(rel)
-        else entries.push({ rel, base: this.lastKnown.get(rel), via: 'hold' })
-      }
-      if (entries.length) this.mergeHeld(entries).catch((err) => this.log(`could not merge: ${err.message}`))
-      return
-    }
-    for (const rel of paths) this.heldPaths.add(rel)
-    if (r.kind === 'busy') {
-      this.setHold('busy', { prevHead: r.prevHead })
-      if (r.conflict) this.noteConflict(r.conflict)
-      this.settleSoon() // polls until the operation is over, in case its end goes unseen
-    } else if (r.kind === 'switch') {
-      this.followHead(r.head.key, r.prevHead)
-    } else { // discard, advance
-      this.setHold('settling', { prevHead: r.prevHead })
-      this.settleSoon()
-    }
-  }
-
   /** The disk at rel is as Quilt last wrote or read it (or still absent, for a path it never had). */
   untouchedHere (rel) {
     const disk = this.readDisk(rel)
@@ -2426,1168 +1639,10 @@ export class Session extends EventEmitter {
     return (disk ? disk.key : undefined) === this.lastKnown.get(rel)
   }
 
-  // ------------------------------------------------------------ branches --
-  // A folder is on one branch of the session at a time, the one git has it on.
-  // Quilt never switches branches itself: when a person or an agent checks out
-  // another branch in git, the folder moves to that branch's document, and the
-  // branch it left keeps its work in the session. Nothing is synced branch on
-  // branch. Uncommitted work git carries over in the checkout is the old
-  // branch's (the session has it there): on a branch the session already has,
-  // Quilt writes that branch's version over it; a branch new to the session
-  // starts from the folder as git left it, carried work included.
-
-  /**
-   * git moved HEAD to branch `to` (a checkout in a terminal or by an agent, or while Quilt was
-   * stopped): the folder moves there. `prevHead`: where HEAD was before git moved it.
-   */
-  followHead (to, prevHead = null) {
-    if (!to || this.stopped || this.following || this.pendingMove || to === this.branch) return
-    this.following = to
-    this.setHold('switching', { to, ...(prevHead ? { prevHead } : {}) }) // nothing more is shared on the old branch from here
-    this.gitTask(() => this.moveTo(to))
-      // The branch it failed on: a move can retarget on the way (moveTo, abandonMove).
-      .catch((err) => this.moveFailed((this.pendingMove && this.pendingMove.to) || (this.hold && this.hold.to) || to, err))
-      .finally(() => { this.following = null })
-  }
-
-  /**
-   * A move that didn't finish: the folder stays held (nothing of either branch reaches the
-   * other) and recheckMove tries again, less and less often, or follows git wherever it goes
-   * next. A refusal the relay will repeat (a viewer starting a branch, the branch limit) is
-   * said once, with what to do; checking the old branch out again resumes sync there.
-   */
-  moveFailed (to, err) {
-    if (this.stopped || !this.hold || this.hold.kind !== 'switching') return
-    const msg = (err && err.message) || String(err)
-    const connected = !!(this.conn && this.conn.connected)
-    const refused = connected && !/did not answer|not connected|disconnected/.test(msg)
-    // Offline is no try: reconnecting tries again at once (start: the 'connected' status clears moveRetryAt).
-    if (connected) this.moveTries = (this.moveTries || 0) + 1
-    this.moveRetryAt = !connected ? 0 : Date.now() + (refused ? MOVE_RETRY_MAX_MS : Math.min(MOVE_RETRY_MAX_MS, RETRY_MS * 2 ** (this.moveTries - 1)))
-    this.hold.waiting = refused ? 'refused' : 'retrying'
-    this.emit('hold', this.hold)
-    this.scheduleStatusWrite()
-    const said = `${to}\0${refused ? msg : ''}`
-    if (this.moveSaid === said) return
-    this.moveSaid = said
-    if (refused) {
-      const text = `The session can't take ${to}: ${msg}. This folder isn't syncing while it's on ${to}; check out ${this.branch} again in git to keep syncing there.`
-      this.log(`⚠️ ${text}`)
-      this.notice(text)
-    } else {
-      this.log(`⚠️ You're on ${to} in git, but its work in the session can't be loaded yet (${msg}). This folder waits and tries again.`)
-    }
-  }
-
-  /** While a move is unfinished: where is HEAD now? Back on the folder's branch resumes it; elsewhere is followed (backing off on the same branch). */
-  async recheckMove () {
-    if (!this.hold || this.hold.kind !== 'switching' || this.following || this.stopped) return null
-    const at = await this.headNow()
-    if (this.stopped || !at || this.following) return null
-    const m = this.pendingMove
-    const target = m ? m.to : this.hold.to
-    if (at !== this.branch && at === target && Date.now() < (this.moveRetryAt || 0)) return null // tried a moment ago
-    this.following = at
-    try {
-      if (m) return await (m.to === at ? this.finishMove(m) : this.abandonMove(m, at))
-      if (at === this.branch) return this.settleBack()
-      this.hold.to = at
-      return await this.moveTo(at)
-    } finally { this.following = null }
-  }
-
-  /** Where HEAD is: its branch, `@<sha>` when detached, or a branch with no commits yet; null when git can't say. */
-  async headNow () {
-    const head = await headKey(this.root)
-    return head ? head.key : headRef(this.root)
-  }
-
-  /** recheckMove, as git work; what fails is a move that failed again. */
-  recheckSoon () {
-    this.gitTask(() => this.recheckMove()).catch((err) => this.moveFailed(this.pendingMove ? this.pendingMove.to : this.hold && this.hold.to, err))
-  }
-
-  /** HEAD is back on the folder's branch before it moved: the trip is settled like any git work. */
-  settleBack () {
-    this.moveTries = 0
-    this.moveSaid = null
-    this.hold = { kind: 'settling', since: this.hold ? this.hold.since : Date.now(), prevHead: this.hold ? this.hold.prevHead : this.gitSeen }
-    this.emit('hold', this.hold)
-    this.scheduleStatusWrite()
-    this.settleSoon()
-    return null
-  }
-
-  /**
-   * Moves this folder to branch `to`, which git has already checked out: every change on the
-   * branch it leaves is confirmed in the room where it can be, that branch's document is kept
-   * aside here (parkLocalState), and finishMove joins the new one. Runs as git work.
-   */
-  async moveTo (to) {
-    const from = this.branch
-    const fromSha = this.git ? this.git.sha : null
-    const at = await this.headNow()
-    if (this.stopped) return null
-    if (at === from) return this.settleBack()
-    if (at && at !== to) { to = at; if (this.hold) this.hold.to = at }
-    const oldKeys = new Map() // path -> the old branch's version (as lastKnown keys it), to tell what git carried over
-    for (const rel of this.sharedPaths()) if (this.syncable(rel)) oldKeys.set(rel, this.sharedKey(rel) ?? null)
-    // What doesn't reach the relay now stays in `from`'s document kept here, and goes out when the folder is back.
-    try { await this.conn.confirmBranch() } catch (err) { this.emit('debug', `confirming ${from} before moving: ${err.message}`) }
-    if (this.stopped) return null
-    await this.releaseAutoClaims().catch(() => {}) // claims that followed edits on `from` don't come along
-    const carried = await this.carriedFrom(oldKeys, fromSha)
-    if (this.stopped) return null
-    this.parkLocalState(from)
-    const claims = this.claims
-    const doc = new Y.Doc()
-    const left = this.unparkLocalState(to, doc)
-    return this.finishMove({ from, to, doc, left, epoch: left ? this.parkedEpoch(to) : null, carried, claims })
-  }
-
-  /**
-   * Joins the new branch's document, writes it onto the folder and goes live there. HEAD is
-   * read again before and after the join: if git has moved on (a quick checkout back, or a
-   * retry long after), this move is dropped without writing anything and the folder follows
-   * HEAD from where it is. Tried again (recheckMove) when the relay can't load the branch yet.
-   */
-  async finishMove (m) {
-    const { from, to, carried } = m
-    let { doc, left } = m
-    let at = await this.headNow()
-    if (this.stopped) return null
-    if (at !== to) return this.abandonMove(m, at)
-    let head = await headKey(this.root)
-    let reply
-    let fresh = null // the relay's document of `to` is newer than the one this folder kept (P27)
-    try {
-      // A branch new to the session is kept as differences from git when the relay can (branch-view.js).
-      const diff = await this.diffJoinFields()
-      reply = await this.conn.joinBranch(to, doc, { ...(head && head.sha ? { base: head.sha } : {}), ...diff, epoch: m.epoch || null, onStale: () => (fresh = new Y.Doc()) })
-      await this.conn.waitForBranchSync()
-    } catch (err) {
-      if (fresh) fresh.destroy()
-      this.pendingMove = m
-      throw err
-    }
-    if (fresh) {
-      // `to` was removed from the session and started again since this folder left it: what it
-      // kept of the old document is dropped, and the folder arrives as one that was never there.
-      doc.destroy()
-      m.doc = doc = fresh
-      m.left = left = null
-      m.epoch = null
-      const said = `${to} was removed from the session (nobody was on it for 30 days) and has been started again since, so what this folder had kept of it is not brought back; the session's files there are on disk.`
-      this.log(`⚠️ ${said}`)
-      this.notice(said)
-    }
-    if (this.stopped) return null
-    head = await headKey(this.root)
-    at = head ? head.key : headRef(this.root)
-    if (this.stopped) return null
-    if (at !== to) return this.abandonMove(m, at)
-    this.pendingMove = null
-    this.moveTries = 0
-    this.moveSaid = null
-    const old = this.bdoc
-    this.bindBranchDoc(doc)
-    old.destroy()
-    this.branch = reply.branch || to
-    this.branchEpoch = typeof reply.epoch === 'string' && reply.epoch ? reply.epoch : null
-    this.branchForm = reply.form === 'diff' ? 'diff' : 'full'
-    this.diffBase = reply.form === 'diff' && typeof reply.diffBase === 'string' ? reply.diffBase : null
-    this.git = head || { key: to, branch: to, sha: null } // a branch with no commits yet has no sha
-    this.gitSeen = this.git
-    this.rejoin = false
-    this.observeBranch()
-    this.announceBranch()
-    let entries = []
-    let movedOn = null
-    try { entries = await this.arrive({ created: !!reply.created, left, carried }) } finally {
-      // git moved again while the branch was written: still held, and the folder follows on (below).
-      const ref = headRef(this.root)
-      if (ref && ref !== this.branch && !this.stopped && this.hold) { movedOn = ref; this.hold.to = ref }
-      if (!movedOn) {
-        // What git and the move wrote is accounted for: the next flush is an edit unless git moves again.
-        const late = [...this.heldPaths]
-        this.heldPaths.clear()
-        this.releaseHold()
-        this.gitIndex = indexStamp(this.root)
-        this.headChangedAt = 0
-        this.stashSeen = stashStamp(this.root)
-        this.scanDisk({ baseline: true })
-        this.requeue(late.filter((rel) => this.syncable(rel) && !this.untouchedHere(rel)))
-      }
-    }
-    if (this.stopped) return null
-    if (entries.length && !movedOn) {
-      this.mergeHeld(entries).then(({ conflicts }) => {
-        if (conflicts) this.log(`🔀 ${conflicts} file${conflicts === 1 ? '' : 's'} you changed on ${to} clash with the session's; see Merges.`)
-      }).catch((err) => this.log(`could not merge: ${err.message}`))
-    } else for (const e of entries) this.merging.delete(e.rel)
-    this.saveStateNow()
-    fs.rmSync(this.branchStateDir(to), { recursive: true, force: true }) // in state.bin from here
-    // The upstream is the new branch's now.
-    this.upstream = null
-    this.fetchState = null
-    this.upstreamSaid = ''
-    this.upstreamDeferred = null
-    this.indexLate = null
-    this.shareGit()
-    this.refreshPull()
-    this.checkUpstreamSoon({ fetch: true })
-    const note = this.moveNote({ from, to: this.branch, created: !!reply.created, carried: [...carried.keys()] })
-    this.log(`🔀 ${note}`)
-    // Agents working in this folder hear it with their next answer; the room sees it in the activity log.
-    this.notice(`This folder moved from ${from} to ${this.branch} (a checkout in git): its files are ${this.branch}'s in the session now, and ${from}'s work stays in the session on ${from}.`)
-    this.doc.transact(() => {
-      this.activity.push([{ by: this.name, path: '', kind: 'switched', detail: '', branch: this.branch, from, ts: Date.now() }])
-      if (this.activity.length > 300) this.activity.delete(0, this.activity.length - 300)
-    }, LOCAL)
-    this.emit('branch', this.branch)
-    this.scheduleStatusWrite()
-    if (movedOn) { this.following = movedOn; return this.moveTo(movedOn) }
-    return { branch: this.branch, note }
-  }
-
-  /**
-   * git moved on before a move finished: nothing of it was written. The connection goes back
-   * to the folder's branch if the join had moved it, and the folder settles there (HEAD came
-   * back) or moves to wherever HEAD is now.
-   */
-  async abandonMove (m, at) {
-    this.pendingMove = null
-    this.claims = m.claims
-    m.doc.destroy()
-    if (this.conn.branchKey !== this.branch) {
-      this.conn.setBranch(this.branch, this.bdoc) // a reconnect meanwhile joins it again by itself
-      this.conn.branchEpoch = this.branchEpoch // the document it holds, for that join (not the one it left)
-      try {
-        await this.conn.joinBranch(this.branch, this.bdoc)
-        await this.conn.waitForBranchSync()
-      } catch (err) { this.emit('debug', `rejoining ${this.branch}: ${err.message}`) }
-    }
-    if (this.stopped) return null
-    if (!at || at === this.branch) return this.settleBack()
-    if (this.hold) this.hold.to = at
-    return this.moveTo(at)
-  }
-
-  /**
-   * Writes the branch document onto a folder git has just put on that branch. A document new
-   * to the session (or empty) is made from the folder as git left it instead, carried work
-   * included. Otherwise what git carried over from the old branch (`carried`: path -> the
-   * old branch's version, still on disk) gets this branch's version, or HEAD's when the
-   * document hasn't the path: the old branch's work never enters this one. Any other path git
-   * shows as changed (an edit made on this branch while Quilt wasn't looking) is merged into
-   * the document: against the version this folder had when it last left the branch (`left`),
-   * else HEAD's; returned as entries for mergeHeld. A file HEAD has that the document hasn't
-   * is left as git has it, and not shared.
-   */
-  /**
-   * A branch new to the session, kept as differences from git (branch-view.js): only what the folder
-   * has that differs from the branch's first commit (its edits, new files, local commits) goes in,
-   * deletions into `gone`; everything else is git's, and stays on disk as git put it. When git can't
-   * say what differs, every file goes in (a diff document may hold more than it needs; never less).
-   */
-  async seedDiff () {
-    const base = this.diffBase
-    const diff = base ? await changedSince(this.root, base).catch(() => null) : null
-    if (this.stopped) return []
-    this.arriving = true
-    this.seeding = true
-    this.seedBase = base
-    try {
-      for (const rel of walk(this.root, this.ig)) {
-        if (!diff || diff.changed.has(rel)) { this.ingest(rel); continue }
-        const disk = this.readDisk(rel)
-        if (disk && !disk.skip && !disk.tooLarge) { this.lastKnown.set(rel, disk.key); this.gitOnly.set(rel, disk.key) }
-      }
-      if (diff) {
-        const gone = [...diff.deleted].filter((rel) => this.syncable(rel) && !this.onDisk(rel))
-        if (gone.length) {
-          this.transact(() => {
-            for (const rel of gone) {
-              this.gone.set(rel, { at: Date.now(), by: this.name })
-              if (!this.fileBases.has(rel)) this.fileBases.set(rel, base)
-            }
-          }, LOCAL)
-        }
-      }
-    } finally { this.seeding = false; this.arriving = false; this.seedBase = null }
-    return []
-  }
-
-  async arrive ({ created, left = null, carried = new Map() }) {
-    this.lastKnown.clear()
-    this.storedOnDisk.clear()
-    this.known = null
-    this.writeFailed.clear()
-    this.retry.clear()
-    this.gitOnly.clear()
-    if (created && this.diffForm) return this.seedDiff()
-    if (created || (!this.files.size && !this.blobs.size && !(this.diffForm && this.gone.size))) {
-      // What the folder brings to the room is its starting point, not a change anyone made.
-      this.arriving = true
-      this.seeding = true
-      try { for (const rel of walk(this.root, this.ig)) this.ingest(rel) } finally { this.seeding = false; this.arriving = false }
-      return []
-    }
-    // Carried, and still as git carried it (an edit made since is this branch's, and merges).
-    const away = new Set([...carried].filter(([rel, key]) => { const d = this.readDisk(rel); return (d ? d.key : null) === key }).map(([rel]) => rel))
-    const tree = await treeState(this.root, [])
-    if (this.stopped) return []
-    // git can't say what it changed: every path that differs from the session's is merged (a record at worst).
-    const dirty = (tree
-      ? [...tree.dirty].filter((rel) => this.syncable(rel))
-      : [...new Set([...this.sharedPaths(), ...walk(this.root, this.ig)])].filter((rel) => {
-          if (!this.syncable(rel)) return false
-          const disk = this.readDisk(rel)
-          return !(disk && (disk.skip || disk.tooLarge)) && (disk ? disk.key : undefined) !== this.sharedKey(rel)
-        })).filter((rel) => !away.has(rel))
-    const fromHead = [...away].filter((rel) => this.sharedKey(rel) === undefined) // the document hasn't it: HEAD's file
-    // Carried, then edited since the checkout: only that edit is this branch's. Merged against the carried version.
-    const editedSince = new Set(dirty.filter((rel) => carried.has(rel)))
-    const ask = [...dirty, ...fromHead]
-    const atHead = this.git && this.git.sha && ask.length ? await filesAt(this.root, this.git.sha, ask) : null
-    const bins = new Map()
-    for (const rel of [...fromHead, ...editedSince]) {
-      const k = atHead ? atHead.get(rel) : null
-      if (typeof k === 'string' && k.startsWith('bin:')) bins.set(rel, await blobAt(this.root, this.git.sha, rel))
-    }
-    if (this.stopped) return []
-    const changed = new Set(dirty)
-    const shared = this.sharedPaths()
-    this.arriving = true
-    try {
-      this.writeBackAll([...shared].filter((rel) => this.syncable(rel) && !changed.has(rel)))
-      // A diff branch: what the session deleted goes from the folder too (a change of the folder's own to one merges below).
-      if (this.diffForm) this.writeBackAll([...this.gone.keys()].filter((rel) => this.syncable(rel) && !changed.has(rel) && !this.files.has(rel) && !this.blobs.has(rel)))
-      for (const rel of fromHead) this.putHeadVersion(rel, atHead ? atHead.get(rel) : null, bins.get(rel))
-      // HEAD's files the document hasn't: git's, not this folder's change, so not shared.
-      for (const rel of walk(this.root, this.ig)) {
-        if (shared.has(rel) || changed.has(rel) || this.lastKnown.has(rel) || !this.syncable(rel)) continue
-        const disk = this.readDisk(rel)
-        if (disk && !disk.skip && !disk.tooLarge) { this.lastKnown.set(rel, disk.key); this.gitOnly.set(rel, disk.key) }
-      }
-    } finally { this.arriving = false }
-    const baseOf = (rel) => left && left.has(rel) ? left.get(rel) : atHead ? atHead.get(rel) ?? undefined : undefined
-    const entries = []
-    for (const rel of dirty) {
-      if (!editedSince.has(rel)) { entries.push({ rel, base: baseOf(rel), via: 'hold' }); continue }
-      // Merged with this branch's version (HEAD's file when its document hasn't the path): see mergeCarried.
-      entries.push({ rel, base: carried.get(rel), via: 'hold', carried: true, head: atHead ? atHead.get(rel) : undefined, headBuf: bins.get(rel) })
-    }
-    for (const e of entries) this.merging.add(e.rel)
-    return entries
-  }
-
-  /**
-   * A path git carried over from the old branch, edited after the checkout: only that edit is
-   * this branch's. Merged three-way (base: the carried version; ours: the disk; theirs: this
-   * branch's version, or HEAD's file when its document hasn't the path). Anything that doesn't
-   * merge cleanly (a clash, a binary, a file this branch hasn't) is set aside: never a shared
-   * merge record, which would carry the old branch's text into this one.
-   */
-  async mergeCarried ({ rel, base, head, headBuf }) {
-    this.merging.delete(rel)
-    const disk = this.readDisk(rel)
-    if (disk && (disk.skip || disk.tooLarge)) return null
-    const ours = disk ? disk.key : null
-    const inDoc = this.sharedKey(rel) !== undefined
-    if (!inDoc && head === undefined) {
-      // git couldn't read HEAD's file (too large, a filter): left as it is, and not shared.
-      if (disk) this.lastKnown.set(rel, disk.key)
-      return null
-    }
-    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
-    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. */
-  putBranchVersion (rel, { inDoc, head, headBuf }) {
-    if (!inDoc) return this.putHeadVersion(rel, head, headBuf)
-    const disk = this.readDisk(rel)
-    if (disk && !disk.skip && !disk.tooLarge) this.lastKnown.set(rel, disk.key) // replaced without a copy here: setAsideCarried keeps one
-    this.tryWrite(rel)
-  }
-
-  /** A carried path edited after the checkout that can't merge: the folder's copy under .quilt/conflicts, this branch's version on disk, said once. */
-  setAsideCarried (rel, { inDoc, head, headBuf, clash }) {
-    let dest = null
-    try {
-      if (this.onDisk(rel)) {
-        dest = path.join(this.stateDir, 'conflicts', `${Date.now()}`, ...rel.split('/'))
-        fs.mkdirSync(path.dirname(dest), { recursive: true })
-        fs.copyFileSync(resolveInside(this.root, rel), dest)
-      }
-    } catch (err) { this.log(`could not keep a copy of ${rel}: ${err.message}`); return }
-    this.putBranchVersion(rel, { inDoc, head, headBuf })
-    const copy = dest ? `; your copy is in ${path.relative(this.root, dest).split(path.sep).join('/')}` : ''
-    const text = clash
-      ? `Your edit to ${rel} after switching to ${this.branch} and ${this.branch}'s own change to it are not combined on their own, so ${this.branch}'s version is on disk${copy}.`
-      : `${rel} came over from the old branch in the checkout and isn't on ${this.branch}, so it's off the disk${copy}.`
-    this.log(`📦 ${text}`)
-    this.notice(text)
-  }
-
-  /** A carried path the branch's document hasn't: HEAD's file goes back (`key` from filesAt, `buf` for a binary), or none when HEAD hasn't it either. */
-  putHeadVersion (rel, key, buf) {
-    if (key === undefined) return // git couldn't read it (too large, a filter): left as it is
-    try {
-      const abs = resolveInside(this.root, rel)
-      if (key === null) {
-        fs.rmSync(abs, { force: true })
-        removeEmptyParents(this.root, path.dirname(abs))
-        this.lastKnown.delete(rel)
-        return
-      }
-      const data = key.startsWith('bin:') ? buf : key
-      if (data === null || data === undefined) return
-      fs.mkdirSync(path.dirname(abs), { recursive: true })
-      this.writeFile(rel, abs, data)
-      this.lastKnown.set(rel, key)
-      if (this.sharedKey(rel) === undefined) this.gitOnly.set(rel, key)
-    } catch (err) { this.log(`could not put ${rel} back to your last commit: ${err.message}`) }
-  }
-
-  /**
-   * The paths git carried over from the old branch (path -> the old branch's version): changed
-   * on disk, where the old branch's document differs from its HEAD. (git keeps uncommitted
-   * changes across a checkout; Quilt wrote the session's work there as such.)
-   */
-  async carriedFrom (oldKeys, fromSha) {
-    const out = new Map()
-    const tree = await treeState(this.root, [])
-    if (!tree) return out
-    // .gitignore's .quilt/ line is Quilt's own, carried on every checkout: not the session's work.
-    const dirty = [...tree.dirty].filter((rel) => this.syncable(rel) && rel !== '.gitignore')
-    const was = fromSha && dirty.length ? await filesAt(this.root, fromSha, dirty) : null
-    for (const rel of dirty) {
-      const disk = this.readDisk(rel)
-      if (disk && (disk.skip || disk.tooLarge)) continue
-      // The old branch had uncommitted work here, and git kept a change across the checkout. (The disk may
-      // have been edited again since: arrive merges that edit against the old branch's version.)
-      const head = was ? was.get(rel) : undefined // undefined: git couldn't read it
-      if (oldKeys.has(rel)) { if (oldKeys.get(rel) !== head) out.set(rel, oldKeys.get(rel)) } else if (!disk && head !== null && head !== undefined) out.set(rel, null) // a deletion the old branch made
-    }
-    return out
-  }
-
-  /** The session's version of each path onto the disk, over what git put there (git has that: no copy is kept). */
-  writeBackAll (rels) {
-    for (const rel of rels) {
-      const disk = this.readDisk(rel)
-      if (disk && (disk.skip || disk.tooLarge)) continue
-      if (disk) this.lastKnown.set(rel, disk.key); else this.lastKnown.delete(rel)
-      this.tryWrite(rel)
-    }
-  }
-
-  /** Where the saved state of branch `key` waits while this folder is on another branch. */
-  branchStateDir (key) { return path.join(this.stateDir, 'branches', Buffer.from(key, 'utf8').toString('base64url')) }
-
-  /** Keeps the branch this folder leaves: its document as this app has it (anything the relay hasn't got yet included) and its claims. */
-  parkLocalState (key) {
-    const dir = this.branchStateDir(key)
-    try {
-      fs.mkdirSync(dir, { recursive: true })
-      fs.writeFileSync(path.join(dir, 'state.bin'), Y.encodeStateAsUpdate(this.bdoc))
-      fs.writeFileSync(path.join(dir, 'claims.json'), JSON.stringify([...this.claims.values()]))
-      if (this.branchEpoch) fs.writeFileSync(path.join(dir, 'epoch'), this.branchEpoch)
-      else fs.rmSync(path.join(dir, 'epoch'), { force: true })
-    } catch (err) { this.log(`could not keep ${key}'s state: ${err.message}`) }
-  }
-
-  /** Which document of branch `key` its kept state is a copy of (parkLocalState), or null. */
-  parkedEpoch (key) {
-    try { return fs.readFileSync(path.join(this.branchStateDir(key), 'epoch'), 'utf8').trim() || null } catch { return null }
-  }
-
-  /**
-   * The saved document of a branch this folder was on before (into `doc`), and its claims until
-   * the relay sends them. Returns what the folder had of each path when it left (path -> key),
-   * or null when it was never on that branch here.
-   */
-  unparkLocalState (key, doc) {
-    const dir = this.branchStateDir(key)
-    let had = false
-    try { Y.applyUpdate(doc, fs.readFileSync(path.join(dir, 'state.bin')), LOCAL); had = true } catch {}
-    this.claims = new Map()
-    try { for (const c of JSON.parse(fs.readFileSync(path.join(dir, 'claims.json'), 'utf8'))) this.claims.set(c.pattern, c) } catch {}
-    if (!had) return null
-    const left = new Map()
-    for (const rel of [...doc.getMap('files').keys(), ...doc.getMap('blobs').keys()]) left.set(rel, docKey(doc, rel))
-    return left
-  }
-
-  /** Partners see which branch this folder is on (presence). */
-  announceBranch () {
-    if (this.conn && this.conn.awareness.getLocalState()) this.conn.awareness.setLocalStateField('branch', this.branch)
-  }
-
-  /** What a move says in the log. */
-  moveNote ({ from, to, created, carried = [] }) {
-    const head = `You're on ${to} now (you switched in git)`
-    if (created) return `${head}. ${to} is new to the session: this folder's files are its starting point, and ${from}'s work stays in the session on ${from}.`
-    const list = carried.slice(0, 3).join(', ') + (carried.length > 3 ? ', …' : '')
-    const brought = carried.length ? ` git had carried ${from}'s uncommitted work in ${list} over: that stays in the session on ${from}, and ${to}'s version is on disk.` : ''
-    return `${head}; the session's work there is on disk.${brought}`
-  }
-
-  /**
-   * HEAD can't be read as a commit. A branch with no commits yet (`git
-   * checkout --orphan`, git itself running: `runs`) is a switch to it, and
-   * once the folder is on it, a change there is an edit (there is no commit
-   * to tell git's work from). Otherwise git can't be asked here.
-   */
-  headless (paths = [], runs = false) {
-    const ref = headRef(this.root)
-    if (ref && this.git && runs && ref !== this.git.key) {
-      for (const rel of paths) this.heldPaths.add(rel)
-      this.followHead(ref)
-      return
-    }
-    if (ref && this.git && runs && !this.git.sha) {
-      const late = [...this.heldPaths]
-      this.heldPaths.clear()
-      if (this.hold) this.releaseHold()
-      const burst = new Set(paths)
-      this.ingestAll(paths)
-      for (const rel of late) {
-        if (burst.has(rel) || !this.syncable(rel) || this.merging.has(rel)) continue
-        if (this.untouchedHere(rel)) this.tryWrite(rel); else this.ingestAll([rel])
-      }
-      return
-    }
-    this.gitUnreadable(paths)
-  }
-
-  /**
-   * git can't be run (missing, or HEAD unreadable) in a folder that is a repo:
-   * whatever happened can't be told apart from an edit, so the folder stays
-   * held and nothing is shared. Asked again every SETTLE_MS, for good.
-   */
-  gitUnreadable (paths = []) {
-    for (const rel of paths) this.heldPaths.add(rel)
-    if (++this.gitFailures === GIT_FAILURES_TO_SAY) this.log('⚠️ Quilt can\'t read git here; this folder stays paused')
-    this.setHold('busy') // a switching hold stays as it is
-    this.settleSoon()
-  }
-
-  /**
-   * Commits made here of work the room already has (`git commit` touches no
-   * file, so no burst saw them) move gitSeen forward, so a later pull or
-   * rebase is measured from them: otherwise the room's text, now committed,
-   * would look like a change of the room's against the older commit and clash
-   * with what the operation made of it. Read from the branch, not HEAD: a
-   * rebase has already moved HEAD away when its first files land.
-   */
-  async noteCommits () {
-    const seen = this.gitSeen
-    if (!seen || !seen.branch) return
-    const tip = await branchTip(this.root, seen.branch)
-    if (!tip || tip === seen.sha) return
-    const changes = await changesBetween(this.root, seen.sha, tip)
-    if (!changes) return // git could not say: gitSeen stays, and the burst merges against it
-    const changed = [...changes.keys()].filter((rel) => this.syncable(rel))
-    const now = await filesAt(this.root, tip, changed)
-    if (!now) return
-    for (const rel of changed) if ((now.get(rel) ?? undefined) !== this.lastKnown.get(rel)) return // new content: the burst merges it
-    const next = { ...seen, sha: tip }
-    if (this.gitSeen === seen) this.gitSeen = next // unless a newer head was seen meanwhile
-    // A hold that started from this head (setHold) measures from the commits too.
-    if (this.hold && this.hold.prevHead === seen) this.hold.prevHead = next
-  }
-
-  setHold (kind, extra = {}) {
-    // A move to another branch ends only once the folder is there (finishMove): git at work meanwhile doesn't change it.
-    if (this.hold && (this.hold.kind === kind || this.hold.kind === 'switching')) return
-    // The git watcher can start a hold before any burst is classified: commits of the room's work
-    // move its starting point on, asked before it can settle (gitTask runs in order).
-    if (!this.hold) this.gitTask(() => this.noteCommits()).catch(() => {})
-    this.settleBoxesSoon() // a commit may have taken boxed work in
-    // since: when the folder was first held (the app's "git is busy" note waits on it), kept across kinds.
-    this.hold = { kind, since: this.hold ? this.hold.since : Date.now(), ...(this.hold ? { prevHead: this.hold.prevHead } : {}), ...extra }
-    if (!this.hold.prevHead) this.hold.prevHead = this.gitSeen
-    this.emit('hold', this.hold)
-    this.scheduleStatusWrite()
-    // state.json's gitHeld at once: a crash a moment later must restart held, not as an offline rejoin.
-    this.saveStateNow()
-  }
-
-  releaseHold () {
-    this.hold = null
-    this.heldConflicts.clear()
-    clearTimeout(this.settleTimer); this.settleTimer = null
-    this.emit('hold', null)
-    this.scheduleStatusWrite()
-    // Not at once: the settle writes back and merges just after this, and a crash before
-    // those finish must still restart held (and settle again) rather than as an offline rejoin.
-    this.scheduleStateSave()
-    const later = this.upstreamAfterHold
-    this.upstreamAfterHold = null
-    if (later) this.checkUpstreamSoon({ fetch: later.fetch })
-  }
-
-  /** (Re)arms the settle timer: the hold ends SETTLE_MS after the last file or git event. */
-  settleSoon () {
-    if (!this.hold || this.hold.kind === 'switching' || this.stopped || this.holdAwaitsSync || this.inSquare) return
-    clearTimeout(this.settleTimer)
-    const gen = ++this.settleGen
-    this.settleTimer = setTimeout(() => {
-      this.settleTimer = null
-      this.gitTask(() => this.onSettled(gen)).catch((err) => {
-        this.log(`could not settle: ${err.message}`)
-        this.settleSoon() // every hold has a way out: asked again
-      })
-    }, SETTLE_MS)
-    this.settleTimer.unref()
-  }
-
-  /** Whether a hold is on that a settle may end now. */
-  settleable () {
-    return !!this.hold && this.hold.kind !== 'switching' && !this.stopped && !this.holdAwaitsSync
-  }
-
-  /** `gen`: the settleSoon that armed it. A later one (a file or git event since) means not settled yet. */
-  async onSettled (gen = this.settleGen) {
-    if (!this.settleable()) return
-    let busy = this.gitBusy()
-    if (busy === 'index-lock' && Date.now() - this.lastFileEventAt >= STALE_LOCK_MS) {
-      // Only the index lock, there a while, and the tree quiet as long (a long checkout writes files
-      // all along): a git that crashed may have left it.
-      const stamp = await leftoverLock(this.root)
-      if (!this.settleable()) return
-      if (stamp) {
-        this.leftoverLock = stamp
-        this.log('⚠️ a leftover .git/index.lock is being ignored; delete it if git complains')
-        busy = this.gitBusy()
-      }
-    }
-    if (busy) { this.setHold('busy'); this.settleSoon(); return } // still mid-operation: look again later
-    // git left a conflict for the person (a `stash pop` that clashed has no marker file): their
-    // resolution is shared once git has it (git add), never git's conflict markers.
-    const conflicts = await unmergedPaths(this.root)
-    if (!this.settleable()) return
-    if (conflicts && conflicts.size) { this.setHold('busy'); this.noteConflict([...conflicts]); this.settleSoon(); return }
-    const head = await headKey(this.root)
-    if (!this.settleable()) return
-    if (!head) {
-      const runs = await gitRuns(this.root)
-      return this.settleable() ? this.headless([], runs) : undefined
-    }
-    if (this.git && head.key !== this.git.key) {
-      // Landed on another branch while settling: the folder follows it there.
-      this.followHead(head.key)
-      return
-    }
-    const plan = await this.planSettle(head)
-    if (!this.settleable()) return
-    // A file or git event since this settle's timer was armed (it armed another), or a path the room
-    // changed that the plan never saw: the folder hasn't settled. Asked again, the hold on meanwhile.
-    if (gen !== this.settleGen || (plan && [...this.heldPaths].some((rel) => !plan.considered.has(rel)))) { this.settleSoon(); return }
-    if (!plan) return this.gitUnreadable()
-    const from = this.hold.prevHead // where HEAD was before git moved it: the pull's commits are from..head
-    // Out of normal sync from here on: a partner's edit arriving
-    // during a merge must not land on a pulled file before it is merged.
-    for (const e of plan.advance) this.merging.add(e.rel)
-    this.heldPaths.clear()
-    this.rejoin = false
-    this.gitFailures = 0
-    this.gitSeen = head
-    // What git wrote is accounted for here: the next flush is an edit unless git moves again.
-    this.gitIndex = indexStamp(this.root)
-    this.headChangedAt = 0
-    const stash = stashStamp(this.root)
-    const why = stash !== this.stashSeen ? 'stash' : 'reset'
-    this.stashSeen = stash
-    this.releaseHold()
-    // Made way for a pull that has landed now: those files are the pull's (merged in plan.advance).
-    for (const rel of [...this.pullWait.keys()]) if (this.onDisk(rel)) this.endPullWait(rel)
-    if (plan.awaitPull && plan.awaitPull.length) {
-      this.waitForPull(plan.awaitPull.filter((a) => a.stash).map((a) => a.rel), true)
-      this.waitForPull(plan.awaitPull.filter((a) => !a.stash).map((a) => a.rel), false)
-    }
-    this.writeBack(plan.discarded, why)
-    if (plan.advance.length) this.pullWaitOver.clear() // new commits: what was waited for is a different question now
-    this.refreshPull()
-    // Not awaited: merging (an AI merge can take a while) never holds up the next git work.
-    this.mergeSettled(plan, { from, to: head }).catch((err) => this.log(`could not merge: ${err.message}`))
-    this.settleBoxesSoon() // what git did may have committed (or put back) boxed work
-  }
-
-  async mergeSettled (plan, { from = null, to = null } = {}) {
-    await this.mergeHeld(plan.edited)
-    const { conflicts, changed } = await this.mergeHeld(plan.advance)
-    const n = plan.advance.length
-    if (n) this.log(`🔀 Merged the commits you pulled into the session's work (${n} file${n === 1 ? '' : 's'}${conflicts ? `, ${conflicts} need${conflicts === 1 ? 's' : ''} merging` : ''})`)
-    // Commits that only moved HEAD over work the room already has (your own commit) change nothing: no event.
-    if (changed) await this.notePull({ from, to, files: changed })
-  }
-
-  /**
-   * One line for the whole pull in the activity log ("pulled 45 commits from main · 269 files"),
-   * in place of an entry per file: the pull brought other people's work, not edits of ours.
-   */
-  async notePull ({ from, to, files }) {
-    let commits = null
-    if (from && from.sha && to && to.sha && from.sha !== to.sha) commits = await commitsBetween(this.root, from.sha, to.sha)
-    const branch = (to && to.branch) || null
-    const what = [commits ? `${commits} commit${commits === 1 ? '' : 's'}` : 'commits', branch ? `from ${branch}` : ''].filter(Boolean).join(' ')
-    const detail = `${what} · ${files} file${files === 1 ? '' : 's'}`
-    this.log(`⬇️ shared as one pull: ${detail}`)
-    // Someone who may not post can't add lines of their own to the log (the relay would undo it).
-    if (this.stopped || !this.mayTalk()) return
-    this.doc.transact(() => {
-      this.activity.push([{ by: this.name, path: '', kind: 'pulled', detail, ts: Date.now() }])
-      if (this.activity.length > 300) this.activity.delete(0, this.activity.length - 300)
-    }, LOCAL)
-  }
-
-  /**
-   * What ending the hold does, all asked of git before anything changes, in a
-   * handful of git calls whatever the number of paths. Null only when git
-   * can't be run (the hold stays on); a git call that fails is retried once
-   * (one that timed out is not), then the settle goes on with less (never
-   * parks the folder for good).
-   * - advance: each path the new commits changed, settled into the
-   *   doc: base = the file at the old commit, ours = the disk, theirs = the room.
-   * - discarded: held paths git put back (clean, and tracked or gone from
-   *   disk: stash, reset, restore). The room's version goes back on disk.
-   * - edited: every other held path, changed here or in the room while held.
-   *   Merged against the version both sides last had, so an edit made during
-   *   a hold (a commit, an agent's `git status`) is shared, never reverted.
-   * - considered: every path the plan looked at. One held while git was being
-   *   asked that isn't among them means the folder hasn't settled (onSettled).
-   */
-  async planSettle (head) {
-    const prev = this.hold.prevHead
-    const paths = new Set(this.heldPaths)
-    // Restarted held: changes made while stopped were never seen, so every path is checked.
-    if (this.rejoin) for (const rel of [...this.sharedPaths(), ...walk(this.root, this.ig)]) paths.add(rel)
-    const free = (rel) => this.syncable(rel) && !this.merging.has(rel)
-    const twice = (ask) => askTwice(this.root, ask) // not again after a timeout: that would stall the app as long again
-    let changes = new Map()
-    // A reset that dropped commits made here for another history (git reset --hard origin/main): only what that
-    // history brought since the two met is what came in. What the dropped commits changed was this folder's own work,
-    // which the session already has; measured from them, it would be taken away from everyone. (A rebase is measured
-    // from them: its new commits carry this folder's work, as the person resolved it.)
-    let from = prev && prev.sha
-    const last = from && from !== head.sha ? await this.gitOut(['reflog', '-1', '--format=%H%x00%gs', 'HEAD']) : null
-    const reset = !!last && last.split('\0')[0] === head.sha && /^reset: /.test(last.split('\0')[1] || '')
-    if (reset && !(await isAncestor(this.root, from, head.sha))) {
-      const met = await this.gitOut(['merge-base', from, head.sha])
-      if (met && /^[0-9a-f]{40}$/.test(met)) from = met
-    }
-    if (from && from !== head.sha) {
-      changes = await twice(() => changesBetween(this.root, from, head.sha))
-      if (!changes) {
-        if (!(await gitRuns(this.root))) return null
-        // Each held path is then checked against HEAD below: the pulled ones look discarded and get the room's version.
-        this.log('⚠️ git could not list what the new commits changed; the session\'s version of those files is kept')
-        changes = new Map()
-      }
-    }
-    const changed = [...changes.keys()].filter(free)
-    let old = await filesAt(this.root, from, changed.filter((rel) => changes.get(rel) !== 'A'))
-    if (!old) return null
-    // A pull of GitHub's commits on a branch that syncs live: the relay brings the same commits into the session
-    // (bringIn). Once it is at the pulled commit or past it, the pulled files are measured from that commit, so the
-    // pull's change isn't shared a second time on top of the relay's. Nothing to wait for when the session has the
-    // pulled versions already (a commit made here, its edits shared as they were made).
-    if (changed.length && this.followsRelay && this.branchLive()) {
-      const atHead = await filesAt(this.root, head.sha, changed)
-      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 = this.pulledBases(changed, 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, 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' }))
-    const rest = [...paths].filter((rel) => !changes.has(rel) && free(rel))
-    const tree = rest.length ? await twice(() => treeState(this.root, rest)) : { dirty: new Set(), tracked: new Set() }
-    if (!tree) {
-      if (!(await gitRuns(this.root))) return null
-      // git can't say which paths it put back. Each is merged against the file at HEAD: a discarded
-      // one (the disk is HEAD's) takes the room's version, an edited one merges three-way. Never
-      // against lastKnown: after a stash that is the room's version, and the stashed-away disk would win.
-      const atHead = await filesAt(this.root, head.sha, rest)
-      if (!atHead) return null
-      this.log(`⚠️ git could not say what it changed here; ${rest.length} held file${rest.length === 1 ? '' : 's'} merged against your last commit`)
-      return { advance, discarded: [], edited: rest.map((rel) => ({ rel, base: atHead.get(rel) ?? undefined, via: this.rejoin ? undefined : 'hold' })), considered: new Set([...paths, ...changes.keys()]) }
-    }
-    const discarded = []; const edited = []
-    for (const rel of rest) {
-      // git calls an untracked or ignored file clean too, but nothing put it back to a commit: that is an edit.
-      if (!tree.dirty.has(rel) && (tree.tracked.has(rel) || !this.onDisk(rel))) discarded.push(rel)
-      else edited.push({ rel, base: this.lastKnown.get(rel), via: this.rejoin ? undefined : 'hold' })
-    }
-    const gone = [...discarded, ...edited.map((e) => e.rel)].filter((rel) => !changes.has(rel))
-    const away = new Set(await this.makingWay(gone))
-    return {
-      advance,
-      discarded: discarded.filter((rel) => !away.has(rel)),
-      edited: edited.filter((e) => !away.has(e.rel)),
-      awaitPull: [...away].map((rel) => ({ rel, stash: discarded.includes(rel) })),
-      considered: new Set([...paths, ...changes.keys()])
-    }
-  }
-
-  /**
-   * The base of each pulled path once the relay is at the pulled commit (planSettle): the file at that commit,
-   * so the pull's change isn't shared again on top of the relay's. Not for a file the session doesn't have at
-   * that commit (the relay holds GitHub's change while someone holds the file) whose disk doesn't have the
-   * pull's change either (git moved the branch and left the file, as `git reset` does): measured from the
-   * commit, the disk would look like it took the pull's change away. That one is measured from the old commit.
-   */
-  pulledBases (rels, old, atHead) {
-    const out = new Map(atHead)
-    out.failed = 0
-    const text = (k) => typeof k === 'string' && !k.startsWith('bin:')
-    for (const rel of rels) {
-      const pulled = atHead.get(rel) ?? undefined
-      const was = old.get(rel) ?? undefined
-      if (pulled === was || this.sharedKey(rel) === pulled) continue
-      const disk = this.readDisk(rel)
-      const ours = disk && !disk.skip && !disk.tooLarge ? disk.key : null
-      if (ours === pulled) continue
-      // The disk has the pull's change when combining the pull into it changes nothing.
-      const hasPull = text(ours) && text(was) && text(pulled) && (() => { const m = merge3(was, ours, pulled); return !m.conflicts.length && m.text === ours })()
-      if (!hasPull) out.set(rel, old.get(rel))
-    }
-    return out
-  }
-
   onDisk (rel) {
     try { fs.lstatSync(path.join(this.root, ...rel.split('/'))); return true } catch { return false }
   }
 
-  /**
-   * At start, before captureOffline: the folder is on another branch than the
-   * one this session synced, or it stopped mid-hold. Its tree is then not the
-   * session's work plus offline edits (it is another branch, or what git left
-   * half-done), so nothing is captured from it. On another branch the folder
-   * moves there once the relay has synced (start: followHead); otherwise the
-   * hold carries on, and when it settles every path is restored or merged
-   * against the version the session had when it stopped.
-   */
-  resumeHold () {
-    const saved = this.savedGit
-    if (!saved) return false
-    const head = this.git // null: git can't say where HEAD is (an unborn branch, or git not running)
-    if (!head && !gitDir(this.root)) return false
-    const at = head ? head.key : headRef(this.root) // null: unreadable, and not on a named branch
-    const away = !!at && at !== saved.key
-    if (head && !away && !saved.held) return false
-    this.git = { key: saved.key, branch: saved.key.startsWith('@') ? null : saved.key, sha: saved.sha }
-    this.gitSeen = head
-    // An unfinished offline merge's bases are no bases for this hold; left, the next start would read them.
-    fs.rmSync(this.heldBasesFile, { force: true })
-    // The base for merging what the folder holds once it's back: the session's version at the last stop.
-    for (const rel of this.sharedPaths()) {
-      const k = this.sharedKey(rel)
-      if (this.syncable(rel) && k !== undefined) this.lastKnown.set(rel, k)
-    }
-    this.rejoin = true
-    // Back on the branch but git can't be read: held as busy, asked again every SETTLE_MS (see gitUnreadable).
-    const kind = away ? 'switching' : head ? 'settling' : 'busy'
-    this.hold = { kind, since: Date.now(), prevHead: saved.sha ? { ...this.git } : null, ...(away ? { to: at } : {}) }
-    if (away) this.resumeAway = at
-    return true
-  }
-
-  /** Said once at start: the folder is a repo, but git can't be read here. */
-  saysGitUnreadable (held) {
-    if (held) {
-      this.gitFailures = GIT_FAILURES_TO_SAY // said here: gitUnreadable doesn't say it again
-      this.log('⚠️ Quilt can\'t read git here; this folder stays paused')
-    } else {
-      this.log('⚠️ Quilt can\'t read git here, so a git command in this folder is shared like any edit')
-    }
-  }
-
-  /**
-   * Of these paths, the ones gone from this folder that the fetched upstream
-   * adds, and that the session has: they were moved out of the way of a pull.
-   */
-  async makingWay (paths) {
-    const gone = paths.filter((rel) => this.syncable(rel) && !this.onDisk(rel) && this.sharedKey(rel) !== undefined && !this.pullWaitOver.has(rel))
-    if (!gone.length) return []
-    const up = await upstreamAdds(this.root, gone)
-    return up ? [...up.keys()] : []
-  }
-
-  /** rel is in the way of a fetched pull (as last asked of git), and the session has it. */
-  blocksPull (rel) {
-    return !!(this.pull && this.pull.adds.some((a) => a.path === rel && !a.waiting) && this.sharedKey(rel) !== undefined && !this.pullWaitOver.has(rel))
-  }
-
-  /** Keeps files removed (or stashed: `stash`) to make way for a pull for everyone, until it lands or PULL_WAIT_MS passes. */
-  waitForPull (rels, stash) {
-    const fresh = rels.filter((rel) => !this.pullWait.has(rel))
-    if (!fresh.length) return
-    for (const rel of fresh) {
-      const timer = setTimeout(() => this.pullWaitEnded(rel), this.pullWaitMs)
-      timer.unref()
-      this.pullWait.set(rel, { since: Date.now(), stash, timer })
-    }
-    this.log(`⏳ ${fresh.join(', ')} out of the way for a pull: kept for everyone until it lands.`)
-    this.refreshPull()
-  }
-
-  endPullWait (rel) {
-    const w = this.pullWait.get(rel)
-    if (!w) return
-    clearTimeout(w.timer)
-    this.pullWait.delete(rel)
-  }
-
-  /** No pull came in time: a removal was meant (shared as a deletion), a stash puts the session's copy back. */
-  pullWaitEnded (rel) {
-    const w = this.pullWait.get(rel)
-    if (!w || this.stopped) return
-    if (this.held()) { w.timer = setTimeout(() => this.pullWaitEnded(rel), SETTLE_MS); w.timer.unref(); return } // after git is done
-    this.pullWait.delete(rel)
-    if (this.onDisk(rel)) return
-    this.pullWaitOver.add(rel)
-    if (w.stash) {
-      this.log(`↩️ No pull came: ${rel} is back from the session.`)
-      this.writeBack([rel])
-    } else {
-      this.log(`🗑️ No pull came: ${rel} is deleted for everyone.`)
-      try { this.ingest(rel) } catch (err) { this.log(`could not sync ${rel}: ${err.message}`) } // as a deletion, not asked of git again
-    }
-    this.refreshPull()
-  }
-
-  /** Asks git what a pull would bring over files the session put here (after a fetch, a settle, a start). */
-  refreshPull () {
-    if (!this.git || this.stopped) return
-    this.gitTask(async () => {
-      const st = await pullState(this.root)
-      if (!this.stopped) this.setPull(st)
-    }).catch(() => {})
-  }
-
-  setPull (st) {
-    const adds = []
-    for (const [rel, key] of st ? st.adds : []) {
-      const waiting = this.pullWait.has(rel)
-      if (!waiting && !this.onDisk(rel)) continue // not in the way
-      if (this.sharedKey(rel) === undefined) continue // not the session's: git's usual advice applies
-      const disk = waiting ? null : this.readDisk(rel)
-      const here = disk && disk.key !== undefined ? disk.key : this.sharedKey(rel)
-      adds.push({ path: rel, same: here === key, waiting })
-    }
-    adds.sort((a, b) => a.path < b.path ? -1 : 1)
-    this.pull = st ? { upstream: st.upstream, behind: st.behind, adds } : null
-    // Told once per set of files in the way (at the top of the AI's next quilt answer, and in the log).
-    const said = adds.filter((a) => !a.waiting).map((a) => `${a.path}:${a.same}`).join('|')
-    if (said && said !== this.pullSaid) {
-      const text = pullAdvice(this.pull)
-      this.notice(text)
-      this.log(`⬇️ ${text}`)
-    }
-    this.pullSaid = said
-    this.scheduleStatusWrite()
-  }
-
-  // ------------------------------------------------------------ upstream --
-  // Commits made outside the session (pushed from a worktree, merged on GitHub,
-  // or another worktree moving this branch) come in without anyone pulling:
-  // the folder's branch moves forward to them, with the session's uncommitted
-  // work merged into their files (upstream.js). Never a history merge: a branch
-  // that has commits of its own the upstream lacks is left to a person or AI.
-
-  /** Looks again shortly (a branch moved, a fetch landed); several asks in a row make one look. */
-  checkUpstreamSoon ({ fetch = false, delay = SETTLE_MS } = {}) {
-    if (!this.git || !this.git.branch || this.stopped || this.inSquare || this.syncStopped) return
-    this.upstreamFetch = this.upstreamFetch || fetch
-    if (this.upstreamTimer) return // one look is already on its way: it takes this ask too
-    this.upstreamTimer = setTimeout(() => {
-      this.upstreamTimer = null
-      const f = this.upstreamFetch
-      this.upstreamFetch = false
-      this.gitTask(() => this.checkUpstream({ fetch: f })).catch((err) => this.log(`could not check for new commits: ${err.message}`))
-    }, delay)
-    this.upstreamTimer.unref()
-  }
-
-  /** Asks again once it's quiet: when the hold ends if held (a push's look must not wait for the next poll), else shortly. */
-  upstreamLater (fetch) {
-    if (!this.hold) { this.checkUpstreamSoon({ fetch }); return }
-    this.upstreamAfterHold = { fetch: !!(fetch || (this.upstreamAfterHold && this.upstreamAfterHold.fetch)) }
-  }
-
-  /** Nothing under way here: no hold, no burst, no file changes waiting, no git operation. */
-  quietForUpstream () {
-    return !this.stopped && !!this.git && !!this.git.branch && !this.held() && !this.pending.size &&
-      Date.now() - this.lastFileEventAt >= SETTLE_MS && !this.gitBusy() && this.ready !== false
-  }
-
-  /**
-   * The look itself (in gitTask order). Asks git where the branch and its upstream are,
-   * fetching first when asked, and catches up when the branch is behind. Returns the state.
-   */
-  async checkUpstream ({ fetch = false, now = false } = {}) {
-    if (!this.git || !this.git.branch || this.stopped || this.inSquare || this.syncStopped) return this.upstream
-    if (!this.quietForUpstream()) {
-      this.upstreamLater(fetch) // busy for a moment: asked again once it's quiet
-      return this.upstream
-    }
-    const head = await headKey(this.root)
-    if (!head || head.key !== this.git.key) return this.upstream
-    await this.fixIndex()
-    let up = await upstreamOf(this.root)
-    // A diff branch's unchanged files come from git (branch-view.js): a branch made here follows its GitHub branch once there is one.
-    if (!up && fetch && this.diffForm) up = await this.trackRemoteBranch()
-    if (up && fetch && up.remote && up.remote !== '.') {
-      const started = Date.now()
-      // The session's GitHub connection reads the repository when the folder can't sign in itself (an
-      // agent's folder, or a person's): relay-github.js, read only. A kept token that stopped working is dropped.
-      const f = await fetchSignedIn(this.root, up, { kept: this.gitTokenNow(), fresh: () => this.gitAuth(), drop: () => { this.gitToken = null }, retry: remoteHost(up.url) === 'github.com' })
-      this.noteFetch(f, up)
-      if (f.ok) { up = await upstreamOf(this.root); this.fetchedFrom = started }
-    }
-    this.refreshRepo()
-    // Whether the upstream descends from the commit the relay records for this branch: the relay
-    // only moves its record forward on a folder's word (relay-upstream.js noteFolders).
-    const rs = this.relaySha()
-    const past = rs && up && up.sha ? (rs === up.sha || await isAncestor(this.root, rs, up.sha) ? rs : null) : null
-    // Whether this folder's own commit is on the upstream (at or behind its tip), or a local commit not pushed
-    // yet: the relay records the former as the branch's commit, and the upstream's tip for the latter.
-    const mine = this.reportedHead()
-    const headPushed = mine && up && up.sha ? (mine === up.sha || await isAncestor(this.root, mine, up.sha)) : null
-    // Whether this folder has the relay's recorded commit at all: a folder without it that fetched after it heard of
-    // the record says the record is a commit the upstream never had. One that hasn't fetched since says nothing.
-    const relayKnown = rs ? (await hasCommit(this.root, rs) ? true : (this.fetchedFrom || 0) >= (this.relayShaAt || 0) ? false : null) : null
-    // Each said only along with what it was found for (gitSummary): the head, the upstream's commit and the relay's record.
-    this.upstreamFacts = { head: mine, up: (up && up.sha) || null, rs, past, headPushed, relayKnown }
-    // Files changed here during the fetch (the relay syncing, an edit): looked at again once it's quiet.
-    if (this.stopped) return this.upstream
-    if (!this.quietForUpstream()) { this.upstreamLater(false); return this.upstream }
-    // The branch moved without this folder's files moving with it: another worktree of the
-    // repository moved it (a commit made here was taken in by noteCommits instead).
-    const seen = this.gitSeen
-    if (this.bringInUpstream && seen && seen.sha && seen.key === head.key && seen.sha !== head.sha) {
-      await this.noteCommits()
-      if (this.gitSeen && this.gitSeen.sha !== head.sha && await isAncestor(this.root, seen.sha, head.sha)) {
-        await this.bringIn(seen.sha, head.sha, { moveRef: false, up, now: true })
-      }
-    }
-    if (!up || !up.sha) { this.setUpstream(up ? { ...up, behind: 0, ahead: 0 } : null); return this.upstream }
-    if (!this.bringInUpstream) return this.upstream
-    const at = (this.gitSeen && this.gitSeen.sha) || head.sha
-    if (up.sha === at) { this.setUpstream({ ...up, behind: 0, ahead: 0 }); return this.upstream }
-    const behind = await commitsBetween(this.root, at, up.sha)
-    const ahead = await commitsBetween(this.root, up.sha, at)
-    if (behind === null || ahead === null) return this.upstream
-    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 })
-    return this.upstream
-  }
-
-  /**
-   * GitHub as a node (plan §6): this person's folder has local commits GitHub hasn't, on a branch
-   * that syncs live. Only when the person opted in (Settings: Push my local commits for me; otherwise
-   * they push with git themselves, and are told once per commit) do they go to GitHub: pushed with the person's own git when it can and the branch
-   * isn't behind or protected (a); otherwise handed to the relay as a git bundle, which puts them on
-   * GitHub's head with their message and author (b), replaying them when GitHub moved meanwhile
-   * (a diverged branch). The folder then follows GitHub's head, its own commits kept under
-   * refs/quilt/original/<branch>/; only the branch and the index move, never a file. A change that
-   * clashes with GitHub's is the session's to merge (relay-clash.js): the folder follows all the same.
-   * Agents' folders, and branches that don't sync live, are left as they are.
-   */
-  async publishLocal ({ up, at, behind, ahead = 1 }) {
-    if (this.kind === 'agent' || !this.git || !this.git.branch || !up || !up.remote || up.remote === '.') return
-    const entry = (this.branchList || []).find((b) => b.key === this.branch)
-    if (!entry || !entry.relay || !entry.relay.live) return
-    if (this.published === at) return
-    const branch = this.git.branch
-    if (!this.pushesLocalCommits()) {
-      if (this.toldLocal !== at) { this.toldLocal = at; this.log(`your ${ahead === 1 ? 'local commit' : `${ahead} local commits`} on ${branch} ${ahead === 1 ? 'isn\'t' : 'aren\'t'} on GitHub yet: push with git (or let Quilt push them for you: Settings, Push my local commits for me)`) }
-      return
-    }
-    const ref = upstreamRef(up.name, up.remote)
-    if (!ref || gitBusy(this.root) || (await stagedAgainst(this.root, at)) !== false) return
-    this.published = at
-    if (!behind && !entry.relay.protected) {
-      const r = await pushLocal(this.root, up.remote, at, ref)
-      if (r.ok) {
-        this.log(`⬆️ pushed your ${ahead === 1 ? 'local commit' : `${ahead} local commits`} on ${branch} to ${up.name}`)
-        this.checkUpstreamSoon({ fetch: true, delay: 200 })
-        return
-      }
-      this.emit('debug', `push from the folder: ${r.error}; handing the commits to the relay`)
-    }
-    const bundle = await bundleOf(this.root, branch, up.sha)
-    if (!bundle) { this.published = null; return }
-    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 }
-    const f = await fetchSignedIn(this.root, up, { kept: this.gitTokenNow(), fresh: () => this.gitAuth(), drop: () => { this.gitToken = null }, retry: remoteHost(up.url) === 'github.com' })
-    if (!f.ok) return
-    const now = await upstreamOf(this.root)
-    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${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)
@@ -3595,218 +1650,6 @@ export class Session extends EventEmitter {
     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
-  }
-
-  /**
-   * Brings commits `from`..`to` into this folder and the session: every file they changed is
-   * merged with the session's uncommitted work, then the branch moves to `to` (moveRef) or,
-   * when it already has, the index follows it. All or nothing: one file that can't be merged
-   * cleanly and nothing is written; the AIs are told which, and why.
-   */
-  async bringIn (from, to, { moveRef, up = null, now = false }) {
-    const branch = this.git.branch
-    const upName = up ? up.name : branch
-    const state = (extra) => this.setUpstream({ ...(up || { name: upName }), behind: extra.behind ?? (up ? up.behind : 0), ahead: 0, ...extra })
-    // A branch that syncs live with GitHub (plan §6): the relay brings GitHub's commits into the session, and this
-    // folder follows them with git alone. Sharing them from here as well would share them twice: two writers of one
-    // change, and the session's document keeps both copies. So it asks the relay to look, and waits until it is at `to`.
-    if (await this.relayBrings(to, up, { moveRef })) {
-      state({ waiting: RELAY_WAITING })
-      this.askRelayFor(to)
-      this.checkUpstreamSoon({ fetch: false, delay: 2 * 1000 })
-      return
-    }
-    // Another member's folder on this branch, with its own upstream, takes it first: two folders
-    // sharing the same commits at once would share them twice. This one waits, looking every few
-    // seconds, until that folder is at `to` (then it follows), leaves, or takes longer than catcherWaitMs.
-    // A first in line that hasn't said it is bringing `to` in gets one look, as it may never (no upstream of its own).
-    const ahead = !now && !this.memberAt(to) ? this.otherCatcherFirst(to) : false
-    if (ahead) {
-      if (this.upstreamDeferred !== to) { this.upstreamDeferred = to; this.upstreamDeferredAt = Date.now() }
-      if (Date.now() - this.upstreamDeferredAt < (ahead === 'busy' ? this.catcherWaitMs : 3 * 1000)) {
-        state({ waiting: CATCHER_WAITING })
-        this.checkUpstreamSoon({ fetch: false, delay: 3 * 1000 })
-        return
-      }
-      this.log(`⏱️ the member first in line hasn't brought in ${to.slice(0, 7)} after ${Math.round(this.catcherWaitMs / 1000)}s; bringing it in here`)
-    }
-    const staged = await stagedAgainst(this.root, from)
-    if (staged !== false) { state({ waiting: staged ? 'changes are staged for a commit here' : 'git could not say what is staged' }); return }
-    // Said in presence: another folder on this branch waits for this one instead of bringing `to` in too.
-    this.bringing = to
-    this.shareGit()
-    try { await this.bringInNow(from, to, { moveRef, up, state }) } finally { this.bringing = null; this.shareGit() }
-  }
-
-  async bringInNow (from, to, { moveRef, up, state }) {
-    const branch = this.git.branch
-    const upName = up ? up.name : branch
-    // The relay brought the session to a commit between here and `to` while this folder was away:
-    // follow it first (git only, the session has those files), then bring in only what came after.
-    const mid = this.relaySha()
-    if (moveRef && mid && mid !== from && mid !== to && !this.memberAt(to) && await isAncestor(this.root, from, mid) && await isAncestor(this.root, mid, to)) {
-      await this.bringInNow(from, mid, { moveRef, up, state })
-      if (!this.gitSeen || this.gitSeen.sha !== mid || this.stopped) return
-      from = mid
-    }
-    const changes = await changesBetween(this.root, from, to)
-    if (!changes) return
-    // A member's folder on this branch is already at `to`, in step with the session: the session's
-    // files are that commit plus the session's work already (that folder brought it in, or someone
-    // there resolved it by hand). This folder follows: only files the session doesn't share are merged.
-    const following = this.memberAt(to)
-    // A diff branch's files the session never changed follow git (branch-view.js): no folder shares them, so
-    // a folder following another still writes them itself.
-    const own = (rel) => !following || !this.syncable(rel) || this.followsGit(rel)
-    const paths = [...changes.keys()].filter(own)
-    const scope = new Map([...changes].filter(([rel]) => own(rel)))
-    const [base, theirs] = [await filesAt(this.root, from, paths), await filesAt(this.root, to, paths)]
-    if (!base || !theirs || this.stopped || !this.quietForUpstream()) return
-    // Claims are checked on what would actually be written (below, after the plan): a file someone
-    // holds whose version the session already has (it came from the session) holds nothing up.
-    for (const rel of paths) {
-      if (this.syncable(rel) && this.writeRefusal(rel)) { state({ waiting: `you may not change ${rel} in this session` }); return }
-    }
-    // Links are git's (the session never syncs them): one the folder has as git has it at either end is that version, and one the commits bring is written as a link.
-    const [linksFrom, linksTo] = [await linksAt(this.root, from, paths), await linksAt(this.root, to, paths)]
-    if (!linksFrom || !linksTo) return
-    const linkKey = (rel) => {
-      let target
-      try { target = fs.readlinkSync(resolveInside(this.root, rel)) } catch { return undefined }
-      if (linksTo.has(rel) && theirs.get(rel) === target) return target
-      if (linksFrom.has(rel) && base.get(rel) === target) return target
-      return undefined
-    }
-    const diskKey = (rel) => { const k = this.diskKey(rel); return k === undefined ? linkKey(rel) : k }
-    // 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.
-    for (const rel of following ? changes.keys() : paths) {
-      if (!this.syncable(rel)) continue
-      // A file git has that the session leaves to it: in step when the folder still has git's version (an edit not shared yet waits).
-      const want = this.followsGit(rel) ? (this.gitOnly.has(rel) ? this.gitOnly.get(rel) : this.lastKnown.has(rel) ? this.lastKnown.get(rel) : (diskKey(rel) ?? undefined)) : this.sharedKey(rel)
-      if ((diskKey(rel) ?? undefined) !== want) { this.checkUpstreamSoon(); return }
-    }
-    // Files the session moved: same name, somewhere the old commit didn't have them.
-    const goneHere = new Set(paths.filter((rel) => base.get(rel) && diskKey(rel) === null).map((rel) => rel.slice(rel.lastIndexOf('/') + 1)))
-    const moved = new Map()
-    if (goneHere.size) {
-      const cands = [...this.sharedPaths()].filter((rel) => goneHere.has(rel.slice(rel.lastIndexOf('/') + 1)) && !changes.has(rel))
-      const atFrom = cands.length ? await filesAt(this.root, from, cands) : new Map()
-      if (!atFrom) return
-      for (const rel of cands) if (atFrom.get(rel) === null) { const k = diskKey(rel); if (k) moved.set(rel, k) }
-    }
-    // Folders the session emptied, that the new commits add files to (a reorganisation they predate).
-    const emptied = new Set()
-    for (const rel of paths) {
-      if (base.get(rel) !== null || theirs.get(rel) === null) continue
-      const dir = rel.includes('/') ? rel.slice(0, rel.lastIndexOf('/')) : ''
-      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)
-    }
-    // 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)
-      state({ behind, conflicts: plan.conflicts })
-      return
-    }
-    // Clean, but a file it would write is held for a clash's merge by someone else: it waits for them.
-    for (const rel of [...plan.writes.keys(), ...plan.moves.flatMap((m) => [m.from, m.to])]) {
-      const claim = this.syncable(rel) ? this.claimFor(rel) : null
-      if (claim && !this.ownClaim(claim)) { state({ waiting: `${claim.by} holds ${rel}` }); return }
-    }
-    // Under git's index lock: if the branch moved meanwhile, nothing is written. Then the files, the
-    // index, and last the branch (gitstate.js fastForward): a commit made meanwhile can't undo them.
-    let written = 0
-    const writeFiles = async () => {
-      this.gitSeen = { key: branch, branch, sha: to }
-      for (const [rel, key] of plan.writes) {
-        try {
-          const abs = resolveInside(this.root, rel)
-          if (key === null) {
-            fs.rmSync(abs, { force: true })
-            removeEmptyParents(this.root, path.dirname(abs))
-          } else {
-            const data = key.startsWith('bin:') ? await blobAt(this.root, to, rel) : key
-            if (data === null) throw new Error('git could not read it')
-            fs.mkdirSync(path.dirname(abs), { recursive: true })
-            if (linksTo.has(rel)) { fs.rmSync(abs, { force: true }); fs.symlinkSync(String(data), abs) } else this.writeFile(rel, abs, data)
-          }
-          written++
-          if (this.syncable(rel)) this.ingest(rel, { pulled: true })
-        } catch (err) { this.log(`could not bring in ${rel}: ${err.message}`) }
-      }
-    }
-    if (!(await fastForward(this.root, moveRef ? branch : null, from, to, writeFiles))) {
-      this.checkUpstreamSoon()
-      return
-    }
-    // The index follows at the next look if git couldn't set it, or if another git that read it
-    // just before (an AI's `git status`) writes its old copy back over it: checked for a few seconds.
-    this.indexLate = to
-    this.indexWatchUntil = Date.now() + INDEX_WATCH_MS
-    for (const ms of [500, 2000, INDEX_WATCH_MS]) setTimeout(() => this.gitTask(() => this.fixIndex()).catch(() => {}), ms).unref()
-    // What git and Quilt just wrote is accounted for: the next flush is no burst of git's.
-    this.gitIndex = indexStamp(this.root)
-    this.headChangedAt = 0
-    this.upstreamDeferred = null
-    const count = await commitsBetween(this.root, from, to)
-    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 ? ', …' : '')
-      this.notice(`The commits Quilt just brought in from ${upName} add ${list} to a folder the session had emptied (moved elsewhere?). Check whether they belong where the session moved the rest.`)
-    }
-    // On the way to the upstream's tip (a commit the relay brought the session to first): still behind it.
-    const left = up && up.sha && up.sha !== to ? ((await commitsBetween(this.root, to, up.sha)) ?? 1) : 0
-    this.setUpstream({ ...(up || { name: upName }), sha: up ? up.sha : to, behind: left, ahead: 0, brought: { count, files: written, at: Date.now() } })
-  }
-
-  /**
-   * Just after a bring-in, the index must be the new commit's. A git that read the index before
-   * and wrote it back after (status refreshing it) leaves the old commit's there, which reads as
-   * "the session staged a revert": set again. Only while the bring-in is recent, and only when
-   * HEAD is still where it put it: later staging is the person's.
-   */
-  async fixIndex () {
-    const sha = this.indexLate
-    if (!sha || this.stopped || !this.git) return
-    if (Date.now() > this.indexWatchUntil) { this.indexLate = null; return }
-    const head = await headKey(this.root)
-    if (!head || head.sha !== sha || this.gitBusy()) return
-    if (await stagedAgainst(this.root, sha) && await resetIndex(this.root, sha)) this.gitIndex = indexStamp(this.root)
-  }
-
-  /**
-   * Asked for by an AI (quilt_sync_branch): fetch and bring commits in now, without waiting for
-   * the next look or another member's folder. What happened: { branch, upstream, moved, busy }.
-   */
   /**
    * What making this session a quilt would do (Seam's plans/quilt-source-control/16), read only: the
    * relay's dry run (behind QUILT_SOURCE_URL there, the owner's), as { plan, text }.
@@ -3964,9 +1807,6 @@ export class Session extends EventEmitter {
     try { back = putGitBack(this.root) } catch (err) { this.log(`⚠️ couldn't put git back in this folder (${err.message}); it is in .quilt/git-before-seam`); return false }
     if (!back) { this.log('⚠️ this folder has a new .git, so the one set aside stays in .quilt/git-before-seam'); return false }
     this.gitAside = null
-    this.git = await headKey(this.root)
-    this.gitSeen = this.git
-    if (this.git && !this.stopped) this.startGitWatch()
     this.log('git is back in this folder.')
     this.scheduleStatusWrite()
     return true
@@ -3998,8 +1838,6 @@ export class Session extends EventEmitter {
       }
     }
     this.scanDisk({ baseline: true })
-    this.checkUpstreamSoon({ fetch: true })
-    this.settleSoon()
     this.scheduleStatusWrite()
   }
 
@@ -4041,11 +1879,6 @@ export class Session extends EventEmitter {
     return !(b && b.stored)
   }
 
-  /** The paths this folder's branch changed since it left the default branch, { committed, uncommitted } (the square's first look keeps those as the folder's), or null when git can't say. */
-  branchOwnPaths () {
-    return ownSinceFork(this.root, gitAsideOf(this.root) ? { gitDir: path.join(this.root, GIT_ASIDE) } : {}).catch(() => null)
-  }
-
   /**
    * The paths whose edits this folder made into its branch document but the relay does not hold
    * (session-follow.js unsentPaths): at layout 3 the read-only document refused them, so the
@@ -4112,9 +1945,7 @@ export class Session extends EventEmitter {
     if (this.boxBase.has(rel)) { const b = this.boxBase.get(rel); return b && typeof b.text === 'string' ? b.text : null }
     const k = this.lastKnown.get(rel)
     if (k !== undefined) return typeof k === 'string' && !/^bin:[0-9a-f]{40}$/.test(k) ? k : null
-    if (!this.followsGit(rel) || !gitAsideOf(this.root)) return null
-    const buf = await blobAt(this.root, 'HEAD', rel, { gitDir: path.join(this.root, GIT_ASIDE) })
-    return buf && !looksBinary(buf) ? buf.toString('utf8') : null
+    return null
   }
 
   /** Whether the session never syncs anything in folder `rel` (.git, .quilt, node_modules, ignored ones): the block's walk skips it. */
@@ -4123,20 +1954,6 @@ export class Session extends EventEmitter {
   /** The branch the folder is on for its square: git's, once git moved it while following (squareHeadMoved). */
   squareBranchKey () { return this.squareBranch || this.branchKey() }
 
-  /** git moved HEAD while the folder follows a square: on another branch, the folder follows that branch's square. */
-  squareHeadMoved () {
-    clearTimeout(this.squareHeadTimer)
-    this.squareHeadTimer = setTimeout(async () => {
-      const head = await headKey(this.root).catch(() => null)
-      if (!head || !this.inSquare || this.stopped) return
-      const key = head.key === DEFAULT_KEY ? this.branchKey() : head.key
-      if (key === this.squareBranchKey()) return
-      this.squareBranch = key
-      if (this.squareFollower) await this.squareFollower.branchMoved(this.quilt).catch((err) => this.log(`🧵 ${err.message}`))
-    }, SETTLE_MS)
-    this.squareHeadTimer.unref?.()
-  }
-
   /** Reads of the quilt for the folder's block: through the relay, with the room's read token (session-follow.js relayReader). */
   squareReader () { return relayReader(this.conn) }
 
@@ -4315,188 +2132,6 @@ export class Session extends EventEmitter {
     return { ...r, text: lines.join('\n') }
   }
 
-  async syncBranchNow () {
-    // A folder that can't bring commits in itself (no git here, or its fetch fails) asks the
-    // relay to look at GitHub for its branch now (relay-upstream.js), as a hosted agent can.
-    const relay = () => this.askRelaySync()
-    if (!this.git) return { git: false, relay: await relay() }
-    if (!this.git.branch) return { git: true, branch: null }
-    // A save or a git command a moment ago: give it a few seconds to settle first.
-    for (let i = 0; i < 30 && !this.quietForUpstream() && !this.hold; i++) await new Promise((r) => setTimeout(r, 200))
-    const before = this.gitSeen && this.gitSeen.sha
-    const busy = this.hold ? this.hold.kind : this.quietForUpstream() ? null : 'files are still changing here'
-    if (!busy) await this.gitTask(() => this.checkUpstream({ fetch: true, now: true }))
-    const failed = this.upstream && this.upstream.fetchOk === false
-    return { git: true, branch: this.git.branch, busy, upstream: this.upstream, moved: !!(this.gitSeen && before && this.gitSeen.sha !== before), ...(failed ? { relay: await relay() } : {}) }
-  }
-
-  /** Asks the relay to look at GitHub for this branch now; what it said ({ state, ... }), or { error }. Never throws. */
-  async askRelaySync () {
-    try {
-      if (!this.conn || !this.conn.adminRequest) return { error: 'not connected to the relay' }
-      const r = await this.conn.adminRequest({ op: 'syncUpstream' })
-      return r && r.sync ? r.sync : { error: 'the relay did not say' }
-    } catch (err) { return { error: /not connected/.test(err.message) ? 'not connected to the relay' : err.message } }
-  }
-
-  /**
-   * What the last git fetch of the upstream said: recorded, shared in presence (upstream.fetchOk
-   * false: the relay then brings commits in for this branch itself) and said once per reason.
-   */
-  noteFetch (f, up) {
-    if (!f || f.skipped) return
-    const prev = this.fetchState
-    this.fetchState = { ok: !!f.ok, error: f.ok ? null : (f.error || 'git fetch failed'), at: Date.now() }
-    // In place: a clash review under way holds this object, and a new one would make it give up.
-    if (this.upstream) Object.assign(this.upstream, { fetchOk: this.fetchState.ok, fetchError: this.fetchState.error, fetchAt: this.fetchState.at })
-    if (prev && prev.ok === this.fetchState.ok && prev.error === this.fetchState.error) return
-    const name = up && up.name ? up.name : 'the upstream'
-    if (!this.fetchState.ok) {
-      const said = `Couldn't fetch ${name}: ${this.fetchState.error}. Commits pushed elsewhere can't come in through this folder until it can (git needs credentials that work without a prompt); meanwhile the relay brings them in from GitHub for \`${this.git ? this.git.branch : this.branch}\` when it knows the repository.`
-      this.log(`⚠️ ${said}`)
-      this.notice(said)
-    } else if (prev && !prev.ok) this.log(`✅ fetching ${name} works again`)
-    this.shareGit()
-    this.scheduleStatusWrite()
-  }
-
-  /**
-   * A member whose folder is on this branch at `sha`, in step with the session (not held), or null.
-   * The relay counts as one at the commit it records for the branch (relay-upstream.js): the last
-   * commit a folder there was at in step with the session, or the one the relay brought the
-   * session's files to itself while no folder was online. Either way the session's files are
-   * that commit plus its work, so this folder follows without merging them again.
-   */
-  memberAt (sha) {
-    if (!this.conn || !this.conn.awareness) return null
-    const me = this.conn.awareness.clientID
-    for (const [id, st] of this.conn.awareness.getStates()) {
-      if (id === me || !st || !st.git || !st.name) continue
-      if (st.git.branch === this.git.branch && st.git.sha === sha && !st.git.held) return st.name
-    }
-    const mine = this.branchList.find((b) => b.key === this.branch)
-    // Live sync says the commit the session's content is acknowledged at too (relay-sync.js syncStatus revision).
-    if (sha && mine && mine.relay && (mine.relay.sha === sha || (mine.relay.sync && mine.relay.sync.revision === sha))) return RELAY_BY
-    return null
-  }
-
-  /**
-   * Whether commit `to` is the relay's to bring into the session, and it hasn't yet: the branch syncs live with
-   * GitHub, `to` is GitHub's (the upstream's tip or behind it; a commit only made here is this folder's to
-   * share), and neither the relay nor a member's folder is at it.
-   */
-  async relayBrings (to, up, { moveRef = true } = {}) {
-    if (!this.followsRelay || !this.branchLive() || this.memberAt(to)) return false
-    if (moveRef) return true
-    return !!(up && up.sha && (up.sha === to || await isAncestor(this.root, to, up.sha)))
-  }
-
-  /** Whether the relay has brought the session to commit `sha` or past it (relaySha), or a member's folder is at it. */
-  async relayPast (sha) {
-    if (this.memberAt(sha)) return true
-    const rs = this.relaySha()
-    return !!(rs && rs !== sha && await hasCommit(this.root, rs) && await isAncestor(this.root, sha, rs))
-  }
-
-  /**
-   * A pull here brought commit `sha` on a branch that syncs live, and `sha` is GitHub's: waits up to
-   * RELAY_PULL_WAIT_MS for the relay to be at it or past it (asking it to look), or for `has()` (the session has
-   * the pulled versions), and says whether either came.
-   */
-  async relayHasPull (sha, has = () => false) {
-    if (!this.followsRelay || !sha || !this.branchLive()) return false
-    // Waited for this commit once already: a settle started again (an edit came in meanwhile) doesn't wait again,
-    // or a busy session would keep the folder held, its edits unshared, for as long as edits keep coming.
-    if (this.relayPullWaited === sha) return has() || this.relayPast(sha)
-    // A commit made here (git commit, not a merge): its edits are this folder's to share; the relay never brings them in.
-    const last = await this.gitOut(['reflog', '-1', '--format=%H%x00%gs', 'HEAD'])
-    if (last) { const [at, subject] = last.split('\0'); if (at === sha && /^commit( \((amend|initial)\))?:/.test(subject || '')) return false }
-    const up = await upstreamOf(this.root)
-    if (!up || !up.sha || !(up.sha === sha || await isAncestor(this.root, sha, up.sha))) return false
-    for (const until = Date.now() + RELAY_PULL_WAIT_MS; !this.stopped;) {
-      if (has() || await this.relayPast(sha)) return true
-      if (Date.now() > until) { this.relayPullWaited = sha; this.log(`⏱️ the relay hasn't brought in ${sha.slice(0, 7)} after ${RELAY_PULL_WAIT_MS / 1000}s; sharing what the pull brought from here`); return false }
-      this.askRelayFor(sha)
-      await new Promise((resolve) => setTimeout(resolve, 300))
-    }
-    return false
-  }
-
-  /** Asks the relay to look at GitHub for this branch now, for commit `to`: again every few seconds while it is waited for (the relay takes one ask per branch that often). */
-  askRelayFor (to) {
-    const now = Date.now()
-    if (this.relayAsked && this.relayAsked.to === to && now - this.relayAsked.at < RELAY_ASK_EVERY_MS) return
-    this.relayAsked = { to, at: now }
-    this.askRelaySync().then((r) => { if (r && r.error) this.emit('debug', `asking the relay to bring ${to.slice(0, 7)} in: ${r.error}`) })
-  }
-
-  /** Whether this folder's branch syncs live with GitHub through the relay (GitHub as a node). */
-  branchLive () {
-    const mine = (this.branchList || []).find((b) => b.key === this.branch)
-    return !!(mine && mine.relay && mine.relay.live)
-  }
-
-  /** The commit the relay records for this folder's branch (the session's files are it plus the session's work), or null. */
-  relaySha () {
-    const mine = (this.branchList || []).find((b) => b.key === this.branch)
-    return mine && mine.relay && typeof mine.relay.sha === 'string' ? mine.relay.sha : null
-  }
-
-  /**
-   * Whether another member's folder on this branch is first in line to bring commits in (the
-   * lowest client id): 'busy' when it says it is bringing in `to` itself, true when it is only
-   * first in line, false when none is.
-   */
-  otherCatcherFirst (to = null) {
-    if (!this.conn || !this.conn.awareness) return false
-    const me = this.conn.awareness.clientID
-    let first = false
-    for (const [id, st] of this.conn.awareness.getStates()) {
-      if (id === me || !st || !st.git) continue
-      // A folder whose fetch fails (no credentials, no network) never brings commits in, nor does one
-      // stopped by a clash or waiting on something of its own (staged changes, a claim): not waited for.
-      const u = st.git.upstream
-      const stuck = u && (u.fetchOk === false || u.conflicts || (u.waiting && u.waiting !== CATCHER_WAITING))
-      if (st.git.branch === this.git.branch && !st.git.held && !stuck && id < me) {
-        if (to && st.git.bringing === to) return 'busy'
-        first = true
-      }
-    }
-    return first
-  }
-
-  setUpstream (up) {
-    const prev = this.upstream
-    // Through the relay's git (plan §9), the repository is the session's, not the relay's address.
-    const viaRelay = up && up.url && up.url === this.relayGitUrl()
-    const entry = viaRelay ? this.relayEntryFor(this.branch) : null
-    const next = up ? {
-      name: up.name, url: entry && entry.repo ? `https://${entry.repo}.git` : (up.url || null), remote: up.remote || null, sha: up.sha || null, behind: up.behind || 0, ahead: up.ahead || 0,
-      diverged: !!up.diverged, conflicts: up.conflicts || [], waiting: up.waiting || null, brought: up.brought || (prev && prev.brought) || null, checkedAt: Date.now(),
-      // The last fetch: false with a reason when it failed, so nobody reads "up to date" from stale refs.
-      fetchOk: this.fetchState ? this.fetchState.ok : null, fetchError: this.fetchState ? this.fetchState.error : null, fetchAt: this.fetchState ? this.fetchState.at : null,
-      // Who is merging a clash stays said until reviewClash looks again (no flicker in the branch list).
-      mergedBy: (prev && prev.mergedBy) || null, clashTask: (prev && prev.clashTask) || null, clashMine: !!(prev && prev.clashMine)
-    } : null
-    this.upstream = next
-    if (!next || !(next.diverged || next.conflicts.length)) this.upstreamSaid = ''
-    // Found for another upstream commit or head (a bring-in, a push just made): looked at again, so the relay hears it soon.
-    const f = this.upstreamFacts
-    if (next && next.sha && (!f || f.up !== next.sha || f.head !== this.reportedHead())) this.checkUpstreamSoon()
-    this.shareGit()
-    // What this folder's AI is told about a clash depends on who is merging it (reviewClash).
-    this.reviewClash()
-    this.scheduleStatusWrite()
-  }
-
-  /** Tells this person's AI about the branch's catch-up once per state (at the top of its next quilt answer, and in the log). */
-  sayUpstream (said) {
-    if (!said || said === this.upstreamSaid) return
-    this.upstreamSaid = said
-    this.notice(said)
-    this.log(`⬇️ ${said}`)
-  }
-
   // A catch-up that stopped on clashing files is handed to ONE AI as a task (clash.js). Every
   // folder reporting it works out the same order from presence (clashOrder); only the first
   // writes the task, for its own AI, under an id derived from the branch and the commit, and its
@@ -4504,250 +2139,12 @@ export class Session extends EventEmitter {
   // branch is told to leave those files to them; whoever's folder gets past that commit with
   // nothing clashing closes it. A diverged branch is the folder's own history: never handed out.
 
-  /** Looks again in `ms`; a sooner ask moves the look earlier. */
-  reviewClashSoon (ms = 100) {
-    if (this.stopped) return
-    const due = Date.now() + ms
-    if (this.clashTimer && this.clashDue <= due) return
-    clearTimeout(this.clashTimer)
-    this.clashDue = due
-    this.clashTimer = setTimeout(() => { this.clashTimer = null; this.clashDue = 0; this.reviewClash() }, ms)
-    this.clashTimer.unref()
-  }
-
-  /** Looks at this branch's clash now (one look at a time; an ask meanwhile looks again after). Resolves to reviewClashNow's answer. */
-  reviewClash () {
-    if (this.clashReview) { this.clashAgain = true; return this.clashReview }
-    this.clashReview = this.reviewClashNow()
-      .catch((err) => { this.log(`could not hand the clash on ${this.git && this.git.branch} to one AI: ${err.message}`); return null })
-      .finally(() => {
-        this.clashReview = null
-        if (this.clashAgain) { this.clashAgain = false; this.reviewClashSoon(0) }
-      })
-    return this.clashReview
-  }
-
-  /** Whether commit a is in b's history, asked of git once per pair; null when git can't say. */
-  async clashAncestor (a, b) {
-    if (a === b) return true
-    const key = `${a}>${b}`
-    if (this.clashAncestry.has(key)) return this.clashAncestry.get(key)
-    const r = await isAncestor(this.root, a, b)
-    if (r !== null) {
-      this.clashAncestry.set(key, r)
-      if (this.clashAncestry.size > 200) this.clashAncestry.delete(this.clashAncestry.keys().next().value)
-    }
-    return r
-  }
-
-  /**
-   * The look itself: writes, updates, reopens or hands on the clash task when this folder is
-   * first in line, closes it once this folder is past the commit, and tells this folder's AI who
-   * is merging. Returns { task, label, mine } while this folder reports a file clash, else null.
-   */
-  async reviewClashNow () {
-    const branch = this.git && this.git.branch
-    if (!branch || this.stopped || !this.conn || !this.conn.awareness) return null
-    // The files held for our clash task: let go of once it is done or someone else's.
-    if (this.clashClaims) {
-      const t = readTasks(this.tasks).find((x) => x.id === this.clashClaims.task)
-      if (!t || t.column === 'done' || !this.isMine(t.assignee)) await this.releaseClashClaims(t && t.column !== 'done' ? `task ${this.clashClaims.task} went to ${t.assignee}` : `the merge (task ${this.clashClaims.task}) is done`)
-    }
-    const u = this.upstream
-    let info = null
-    if (u && u.diverged) this.sayUpstream(catchUpAdvice({ branch, upstream: u.name, ...u }))
-    else if (u && u.sha && u.conflicts.length) info = await this.clashHere(branch, u)
-    else if (u && u.sha && !u.behind) await this.clashCaughtUp(branch, u)
-    if (this.stopped || this.upstream !== u || !u) return info
-    // The branch list says who is merging it (gitSummary).
-    const was = JSON.stringify([u.mergedBy, u.clashTask, u.clashMine])
-    u.mergedBy = info ? info.label : null
-    u.clashTask = info ? info.task : null
-    u.clashMine = info ? info.mine : false
-    if (was !== JSON.stringify([u.mergedBy, u.clashTask, u.clashMine])) { this.shareGit(); this.scheduleStatusWrite() }
-    return info
-  }
-
-  /** The commit this folder's files are at. */
-  syncedSha () { return (this.gitSeen && this.gitSeen.sha) || (this.git && this.git.sha) || null }
-
-  /** Who this member's clash task goes to: an agent member by name, else its AI session active last, else the person. */
-  clashAssignee () {
-    if (this.kind === 'agent') return this.name
-    const published = this.conn.awareness.getLocalState()?.personas
-    if (Array.isArray(published) && published.length) {
-      const lead = this.leadPersona()
-      return lead ? lead.name : published[0].name
-    }
-    return this.name
-  }
-
   /** How a member that may take the clash is named before the task exists. */
   candidateLabel (c) {
     if (c.kind === 'agent' || !c.ai) return c.name
     return `${c.name}'s AI`
   }
 
-  /** This folder reports clashing files: see reviewClashNow. */
-  async clashHere (branch, u) {
-    const now = Date.now()
-    const me = this.conn.awareness.clientID
-    const facts = clashFacts({ branch, upstream: u.name, ...u })
-    const advice = catchUpAdvice({ branch, upstream: u.name, ...u })
-    const id = clashTaskId(branch, u.sha)
-    let rec = readClash(this.clashes.get(branch), branch)
-    if (rec && rec.upstream !== u.name) rec = null
-    let tasks = readTasks(this.tasks)
-    let task = rec ? tasks.find((t) => t.id === rec.task) || null : null
-    // A task about an older commit, still open: brought up to date when the new commit follows it,
-    // closed as superseded when the upstream was rewritten without it.
-    let superseded = null
-    if (task && rec.sha !== u.sha) {
-      if (task.column === 'done') task = null
-      else {
-        const follows = await this.clashAncestor(rec.sha, u.sha)
-        if (this.stopped || this.upstream !== u) return null
-        if (follows === false) { superseded = { rec, task }; task = null } else if (follows === null) return this.clashTold(task, advice, facts, u)
-      }
-    }
-    // The record lost to a racing write: the task for this commit is the one.
-    if (!task) {
-      tasks = readTasks(this.tasks)
-      const same = tasks.find((t) => t.id === id)
-      if (same) { rec = { branch, task: id, sha: u.sha, upstream: u.name, ts: now }; task = same }
-    }
-    const states = [...this.conn.awareness.getStates()]
-    const order = clashOrder(clashCandidates(states, { branch, upstream: u.name }))
-    const first = order[0] || null
-    const firstIsMe = !!first && first.id === me
-
-    if (!task) {
-      // Handed out for this commit before and taken off the board: not again (a newer commit may be).
-      if (rec && rec.sha === u.sha) { this.sayUpstream(advice); return null }
-      if (!order.length) { this.sayUpstream(advice); return null }
-      // The first in line writes it. One whose Quilt doesn't within a while is passed over, in order.
-      if (!this.clashWait || this.clashWait.sha !== u.sha) this.clashWait = { sha: u.sha, since: now }
-      const k = Math.min(order.length - 1, Math.floor((now - this.clashWait.since) / this.clashWaitMs))
-      const writer = order[k]
-      if (writer.id !== me) {
-        this.reviewClashSoon(this.clashWait.since + (k + 1) * this.clashWaitMs - now + 50)
-        const label = this.candidateLabel(writer)
-        this.sayUpstream(leaveItNotice({ label, upstream: u.name, task: id, facts }))
-        return { task: id, label, mine: false }
-      }
-      if (superseded) this.closeClash(superseded.rec, `Superseded: ${u.name} was rewritten without ${superseded.rec.sha.slice(0, 7)}; the clash with ${u.sha.slice(0, 7)} is task ${id}.`)
-      const assignee = this.clashAssignee()
-      let t
-      try {
-        t = putTask(this.doc, this.tasks, { id, title: clashTitle({ upstream: u.name, ...u }), by: this.name, assignee, forAi: false, tool: '', files: clashFiles(u.conflicts) }, CLASH)
-      } catch (err) {
-        // A full board (or a refused write): no task, so everyone keeps the advice to pull and resolve.
-        this.log(`could not put the clash on the board: ${err.message}`)
-        this.sayUpstream(advice)
-        return null
-      }
-      this.writeClashRecord(branch, { task: t.id, sha: u.sha, upstream: u.name })
-      this.clashWait = null
-      this.log(`🔀 the clash with ${u.name} on ${branch} is this folder's to merge (task ${t.id}, for ${assignee})`)
-      // Its description is posted once the write has survived (two that raced would post it twice).
-      this.settleClash(t.id, assignee, clashBrief({ branch, upstream: u.name, ...u }))
-      this.sayUpstream(this.clashSettling(facts))
-      return { task: t.id, label: ownerLabel(t), mine: true }
-    }
-
-    if (task.column === 'done') {
-      // Landed (or superseded) and this folder hasn't followed yet: it will, by itself.
-      const landed = /^(Brought in at|Superseded)/.test(task.verified || '')
-      const someoneAt = this.memberAt(u.sha)
-      if (landed || someoneAt) { if (!someoneAt) this.sayUpstream(advice); return null }
-      // Moved to Done by hand while the commit still clashes and no folder has it: open again, same assignee.
-      this.clashDoneSeen.add(task.id)
-      if (firstIsMe) {
-        task = patchTask(this.doc, this.tasks, { id: task.id, column: 'doing' }, CLASH)
-        const why = `Open again: ${u.sha.slice(0, 7)} from ${u.name} still clashes with the session's work and no folder has it yet. Quilt closes this task by itself once the merge lands: no need to move it.`
-        // Our own AI's task: written quietly, so it is woken (and told again) once the write has settled.
-        if (this.isMine(task.assignee)) this.settleClash(task.id, task.assignee, why)
-        else this.clashComment(task.id, why)
-      }
-      return this.clashTold(task, advice, facts, u)
-    }
-
-    // Newer commits that follow the task's: the same task, brought up to date.
-    if (rec.sha !== u.sha && firstIsMe) {
-      task = patchTask(this.doc, this.tasks, { id: task.id, title: clashTitle({ upstream: u.name, ...u }), files: clashFiles(u.conflicts) }, CLASH)
-      this.writeClashRecord(branch, { task: task.id, sha: u.sha, upstream: u.name })
-      this.clashComment(task.id, `${u.name} moved on to ${u.sha.slice(0, 7)}.\n\n${clashBrief({ branch, upstream: u.name, ...u })}`)
-    }
-    // Its assignee: gone from this branch for a while, or a person without an AI while someone with one reports it.
-    const holder = holderOf(states, task.assignee, branch)
-    let handOn = ''
-    let stalled = false
-    // Present but making no progress (the clashing files unchanged, the task not moved) for a while.
-    const progress = JSON.stringify([task.assignee, task.column, (task.files || []).map((rel) => this.sharedKey(rel) ?? null)])
-    if (!this.clashProgress || this.clashProgress.task !== task.id || this.clashProgress.key !== progress) this.clashProgress = { task: task.id, key: progress, since: now }
-    const idleFor = now - this.clashProgress.since
-    if (holder && idleFor < this.clashIdleMs) this.reviewClashSoon(this.clashIdleMs - idleFor + 50)
-    if (holder && idleFor >= this.clashIdleMs && task.column !== 'done') {
-      const mins = Math.max(1, Math.round(this.clashIdleMs / 60000))
-      const next = order.find((c) => c.id !== holder.id)
-      if (!next) {
-        // Nobody else to hand it to: everyone behind may pull and resolve again, as before; its files are let go of.
-        if (this.clashClaims && this.clashClaims.task === task.id) await this.releaseClashClaims(`${task.assignee} made no progress on the merge for ${mins} minutes`)
-        this.sayUpstream(advice)
-        return null
-      }
-      if (next.id === me) { stalled = true; handOn = `${task.assignee} made no progress on it for ${mins} minute${mins === 1 ? '' : 's'}` }
-    }
-    if (!holder) {
-      if (!this.clashAbsent || this.clashAbsent.task !== task.id || this.clashAbsent.name !== task.assignee) this.clashAbsent = { task: task.id, name: task.assignee, since: now }
-      const left = this.clashAbsent.since + this.clashReassignMs - now
-      if (left > 0) this.reviewClashSoon(left + 50)
-      else {
-        const mins = Math.max(1, Math.round(this.clashReassignMs / 60000))
-        handOn = `${task.assignee} has been away from \`${branch}\` for ${mins} minute${mins === 1 ? '' : 's'}`
-      }
-    } else {
-      this.clashAbsent = null
-      // Given to a person (they had no AI session then): to the first member with an AI now (them too, once they have one).
-      const toPerson = holder.st.kind !== 'agent' && holder.st.name === task.assignee
-      if (!stalled && toPerson && first && first.rank < 2) handOn = first.id === holder.id ? `${task.assignee} has an AI session now` : `${task.assignee} has no AI session, and ${first.name} has one`
-    }
-    if (handOn && (firstIsMe || stalled) && task.assignee !== this.clashAssignee()) {
-      const gone = task.assignee
-      const assignee = this.clashAssignee()
-      task = patchTask(this.doc, this.tasks, { id: task.id, assignee, forAi: false, tool: '' }, CLASH)
-      this.log(`🔀 took over the clash on ${branch} (task ${task.id}) from ${gone}`)
-      this.clashAbsent = null
-      this.settleClash(task.id, assignee, `Handed to ${assignee}: ${handOn}, and the clash on \`${branch}\` is still there.\n\n${clashBrief({ branch, upstream: u.name, ...u })}`)
-    }
-    return this.clashTold(task, advice, facts, u)
-  }
-
-  /** Tells this folder's AI about an existing clash task: it is theirs (once settled), or someone else's to leave alone. */
-  clashTold (task, advice, facts, u) {
-    const mine = this.isMine(task.assignee)
-    const label = ownerLabel(task)
-    // Open again after Done: whoever has it is told again.
-    if (task.column !== 'done' && this.clashDoneSeen.delete(task.id)) this.forgetClashSaid()
-    if (mine) {
-      if (this.clashPending && this.clashPending.id === task.id) this.sayUpstream(this.clashSettling(facts))
-      else this.sayClash(task.assignee, `${advice} This merge is yours: task ${task.id} on the board. Quilt closes it by itself once the merge lands here.`, leaveItNotice({ label, upstream: u.name, task: task.id, facts }))
-    } else this.sayUpstream(leaveItNotice({ label, upstream: u.name, task: task.id, facts }))
-    return { task: task.id, label, mine }
-  }
-
-  /**
-   * The clash task is this member's: when it is one of its AI sessions', only that session is
-   * told it owns the merge and the others to leave it to that session (each session's own
-   * notices); otherwise every session of this member hears `own`.
-   */
-  sayClash (assignee, own, others) {
-    const p = [...this.personas.values()].find((q) => q.name === assignee || q.aliases.includes(assignee))
-    if (!p) return this.sayUpstream(own)
-    for (const q of this.personas.values()) this.personaNotice(q, q === p ? own : others)
-    if (own !== this.upstreamSaid) { this.upstreamSaid = own; this.log(`⬇️ ${p.name}: ${own}`) }
-  }
-
   /** A line for one AI session of this member only (takeNotices with its `via`), once per state. */
   personaNotice (p, text) {
     if (!text || p.clashSaid === text) return
@@ -4755,273 +2152,9 @@ export class Session extends EventEmitter {
     p.notices = [...(p.notices || []), text].slice(-NOTICE_CAP)
   }
 
-  /** The clash lines said so far are said again when they come up (a task opened again, handed back). */
-  forgetClashSaid () {
-    this.upstreamSaid = ''
-    for (const p of this.personas.values()) p.clashSaid = ''
-  }
-
-  /** What this folder's AI is told while its clash task settles: the facts, not yet whose it is. */
-  clashSettling (facts) { return `${facts} Quilt is handing this merge to one AI; you are told if it is you.` }
-
-  /**
-   * This member just wrote the clash task for its own AI. Two members that raced both did; the
-   * board keeps one. After a moment, the AI is woken and told only if the write survived;
-   * otherwise it is told quietly who has it.
-   */
-  settleClash (id, assignee, comment = '') {
-    clearTimeout(this.clashPending && this.clashPending.timer)
-    this.forgetClashSaid()
-    const timer = setTimeout(() => {
-      if (this.clashPending && this.clashPending.id === id) this.clashPending = null
-      if (this.stopped) return
-      const t = readTasks(this.tasks).find((x) => x.id === id)
-      if (t && t.column !== 'done' && t.assignee === assignee) {
-        if (comment) this.clashComment(id, comment)
-        this.claimClashFiles(t, assignee).catch((err) => this.log(`could not claim the clashing files for task ${id}: ${err.message}`))
-        for (const p of this.personas.values()) p.inbox.forget(id)
-        this.inboxTracker.forget(id)
-        this.scanInbox({ quiet: false, personas: false })
-      }
-      this.reviewClash()
-    }, this.clashSettleMs)
-    timer.unref()
-    this.clashPending = { id, timer }
-  }
-
-  /**
-   * The clash task `t` survived as this member's (its AI session `assignee`'s): every clashing file
-   * is claimed for that session while it merges, so nobody else edits them meanwhile (taken over
-   * from whoever held them for the task before). A file someone else holds is asked for in its file
-   * queue instead, and the task says so. The relay lets go of them when the task is done.
-   */
-  async claimClashFiles (t, assignee) {
-    if (!this.conn || this.stopped) return
-    const u = this.upstream
-    const paths = t.files && t.files.length ? t.files : u ? u.conflicts.map((c) => c.path) : []
-    const entry = [...this.personas.entries()].find(([, q]) => q.name === assignee || q.aliases.includes(assignee))
-    const via = entry ? entry[0] : null
-    const upstream = (u && u.name) || 'upstream'
-    const claimed = []
-    const asked = []
-    for (const rel of paths) {
-      try {
-        await this.conn.claimRequest({ op: 'claim', pattern: rel, note: `Merging commits from ${upstream} (task ${t.id})`, clash: t.id, ...this.as(via) })
-        claimed.push(rel)
-        // Held for the merge now, not because an edit followed: an AI going idle doesn't let go of it.
-        this.autoClaims.delete(rel)
-        this.autoVia.delete(rel)
-      } catch (err) {
-        const c = this.claimFor(rel)
-        if (!c || this.ownClaim(c)) { this.log(`could not claim ${rel} for the merge: ${err.message}`); continue }
-        try {
-          await this.conn.claimRequest({ op: 'request', path: rel, title: `Merging commits from ${upstream}`, description: `Task ${t.id}: the commits clash with the session's work in this file. I merge it once you hand it over.`, task: t.id, clash: t.id, ...this.as(via) })
-          asked.push(`${c.by} holds ${rel}`)
-        } catch (e2) { this.log(`could not ask for ${rel} for the merge: ${e2.message}`) }
-      }
-    }
-    this.clashClaims = { task: t.id, via, paths: claimed }
-    if (claimed.length) this.log(`🔒 holding ${claimed.join(', ')} for the merge (task ${t.id})`)
-    if (asked.length) this.clashComment(t.id, `${asked.join('; ')}: asked for ${asked.length === 1 ? 'it' : 'them'} in the file queue for ${assignee}, who gets ${asked.length === 1 ? 'it' : 'them'} with their context when they hand ${asked.length === 1 ? 'it' : 'them'} over.`)
-  }
-
-  /** Lets go of the files held for our clash task (handed to whoever waits, with `why`). */
-  async releaseClashClaims (why) {
-    const held = this.clashClaims
-    this.clashClaims = null
-    if (!held || !this.conn) return
-    for (const rel of held.paths) {
-      const c = this.claimFor(rel)
-      // Ours for this task, or ours with no task mark (a relay that predates it drops the mark).
-      if (!c || (c.clash && c.clash !== held.task) || !this.ownClaim(c)) continue
-      try {
-        if (c.queue && c.queue.length) await this.conn.claimRequest({ op: 'handoff', pattern: c.pattern, context: `Quilt let go of it: ${why}.`, ...this.as(held.via) })
-        else await this.conn.claimRequest({ op: 'release', pattern: c.pattern, ...this.as(held.via) })
-      } catch {}
-    }
-  }
-
-  /** The record of this branch's clash task, and old records pruned (a finished or dismissed one after a few days). */
-  writeClashRecord (branch, rec) {
-    const now = Date.now()
-    const tasks = new Map(readTasks(this.tasks).map((t) => [t.id, t]))
-    this.doc.transact(() => {
-      this.clashes.set(branch, { ...rec, ts: now })
-      const kept = []
-      for (const [key, value] of [...this.clashes.entries()]) {
-        if (key === branch) continue
-        const r = readClash(value, key)
-        const t = r && tasks.get(r.task)
-        if (!r || ((!t || t.column === 'done') && now - r.ts > CLASH_KEEP_MS)) this.clashes.delete(key)
-        else kept.push(r)
-      }
-      kept.sort((a, b) => a.ts - b.ts)
-      for (const r of kept.slice(0, Math.max(0, kept.length - CLASH_RECORDS + 1))) this.clashes.delete(r.branch)
-    }, CLASH)
-  }
-
-  /** A note on a clash task (its description, a handover), from this member when they may post. */
-  clashComment (id, text) {
-    if (!this.mayTalk()) return
-    try { putComment(this.doc, this.taskComments, readTasks(this.tasks), { taskId: id, by: this.name, text }, CLASH) } catch (err) { this.log(`could not note the clash on task ${id}: ${err.message}`) }
-  }
-
-  /** Moves a clash task to Done with `verified` (any member may; again is a no-op). */
-  closeClash (rec, verified) {
-    const t = readTasks(this.tasks).find((x) => x.id === rec.task)
-    if (!t || t.column === 'done') return
-    patchTask(this.doc, this.tasks, { id: rec.task, column: 'done', verified }, CLASH)
-    this.log(`✅ clash task ${rec.task} (${rec.upstream} on ${rec.branch}) done: ${verified}`)
-    this.reviewClashSoon()
-  }
-
-  /**
-   * This folder is caught up with nothing clashing. At or past the clash's commit: it landed, the
-   * task is done. The upstream rewritten without that commit (a force-push): superseded.
-   */
-  async clashCaughtUp (branch, u) {
-    const rec = readClash(this.clashes.get(branch), branch)
-    if (!rec || rec.upstream !== u.name) return
-    const task = readTasks(this.tasks).find((t) => t.id === rec.task)
-    if (!task || task.column === 'done') return
-    const head = this.syncedSha()
-    if (!head) return
-    const past = head === rec.sha || u.sha === rec.sha ? true : await this.clashAncestor(rec.sha, head)
-    if (this.stopped || this.upstream !== u) return
-    if (past) return this.closeClash(rec, `Brought in at ${head.slice(0, 7)}: ${this.name}'s folder on ${branch} is at or past ${rec.sha.slice(0, 7)} from ${rec.upstream}, with nothing clashing. Every other folder on ${branch} follows it.`)
-    if (await this.clashAncestor(rec.sha, u.sha) === false && !this.stopped) {
-      this.closeClash(rec, `Superseded: ${rec.upstream} was rewritten without ${rec.sha.slice(0, 7)} (now at ${u.sha.slice(0, 7)}), and ${this.name}'s folder on ${branch} is caught up with it with nothing clashing.`)
-    }
-  }
-
-  /** Reads every branch and worktree of the repository again (for the room's branch list). */
-  refreshRepo () {
-    repoBranches(this.root).then((r) => {
-      if (!r || this.stopped) return
-      const real = (p) => { try { return fs.realpathSync(p) } catch { return path.resolve(p) } }
-      const home = real(this.root)
-      this.repo = {
-        worktrees: r.worktrees.map((w) => ({ name: real(w.path) === home ? '.' : path.basename(w.path), branch: w.branch, sha: w.sha })),
-        branches: r.branches.slice(0, 30)
-      }
-      this.shareGit()
-    }).catch(() => {})
-  }
-
-  /** What this folder tells the room about git: its branch, its upstream, the repository's branches and worktrees. */
-  gitSummary () {
-    if (!this.git) return null
-    const u = this.upstream
-    return {
-      branch: this.git.branch,
-      key: this.git.key,
-      sha: this.gitSeen ? this.gitSeen.sha : this.git.sha,
-      held: this.hold ? this.hold.kind : null,
-      clash: 1, // this Quilt hands a clash to one AI (reviewClash): only such members are given one
-      // On a branch that syncs live with GitHub, this Quilt leaves GitHub's commits to the relay and follows them
-      // (bringIn, planSettle): the relay brings them in only while every folder there says so (relay-upstream.js catcherAble).
-      ...(this.followsRelay ? { followsRelay: 1 } : {}),
-      on: this.hold && this.hold.kind === 'switching' ? this.hold.to : this.git.key,
-      // The commit this folder is bringing into the session right now (bringIn): others on the branch wait for it.
-      ...(this.bringing ? { bringing: this.bringing } : {}),
-      upstream: u ? { name: u.name, url: u.url, remote: u.remote || null, sha: u.sha || null, behind: u.behind, ahead: u.ahead, diverged: u.diverged, conflicts: u.conflicts.length, waiting: u.waiting, checkedAt: u.checkedAt, mergedBy: u.mergedBy || null, clashTask: u.clashTask || null, mayWrite: u.conflicts.length ? this.mayWriteAll(u.conflicts.map((c) => c.path)) : null, ...(u.fetchOk === false ? { fetchOk: false, fetchError: u.fetchError || 'git fetch failed' } : {}), ...this.upstreamFactsFor(u) } : null,
-      repo: this.repo
-    }
-  }
-
   /** Whether this member may change every one of these files (its role and folders). */
   mayWriteAll (paths) { return paths.every((rel) => !this.writeRefusal(rel)) }
 
-  /** The parts of everyone's presence that bear on who merges a clash (reviewClash looks again when they change). */
-  clashPresence () {
-    const out = []
-    for (const [id, st] of this.conn.awareness.getStates()) {
-      if (!st || !st.git) continue
-      const g = st.git
-      const u = g.upstream || {}
-      out.push([id, st.name, st.kind, (Array.isArray(st.personas) ? st.personas : []).map((p) => p && p.name), g.branch, g.sha, g.held, g.clash, u.name, u.behind, u.conflicts, u.diverged, u.mayWrite])
-    }
-    return JSON.stringify(out)
-  }
-
-  /** The commit this folder says it is at (gitSummary's sha). */
-  reportedHead () { return this.git ? (this.gitSeen ? this.gitSeen.sha : this.git.sha) : null }
-
-  /**
-   * What checkUpstream found about the upstream `u` that presence says alongside it (relay-upstream.js
-   * noteFolders), only while it still holds: `at`, the head it was found for (the relay takes no word
-   * from a folder whose head has moved since: a commit made here, or a bring-in); `past` for the
-   * upstream's commit and the relay's record it was found for; `headPushed` for that commit and head;
-   * `relayKnown` for that record. A fact from another moment would have the relay record a commit
-   * nobody pushed, or step back to an older one.
-   */
-  upstreamFactsFor (u) {
-    const f = this.upstreamFacts
-    const rs = this.relaySha()
-    const forUp = !!f && f.up === (u.sha || null)
-    const out = { past: forUp && f.rs === rs ? f.past || null : null }
-    if (f) out.at = f.head || null
-    if (forUp && f.head === this.reportedHead() && typeof f.headPushed === 'boolean') out.headPushed = f.headPushed
-    if (f && f.rs === rs && typeof f.relayKnown === 'boolean') out.relayKnown = f.relayKnown
-    return out
-  }
-
-  shareGit () {
-    if (!this.conn || !this.conn.awareness) return
-    const g = this.gitSummary()
-    if (JSON.stringify(g) !== JSON.stringify(this.conn.awareness.getLocalState()?.git ?? null)) this.conn.awareness.setLocalStateField('git', g)
-  }
-
-  /** git left a conflict here (`stash pop`, a merge, a rebase): held until it's resolved, said once per hold. */
-  noteConflict (paths) {
-    if (!this.hold) return
-    for (const rel of paths) this.heldConflicts.add(rel)
-    const fresh = !this.hold.conflict
-    this.hold.conflict = [...this.heldConflicts]
-    if (!fresh) return
-    const list = this.hold.conflict.slice(0, 3).join(', ') + (this.hold.conflict.length > 3 ? ', …' : '')
-    this.log(`⏸️ git left a conflict in ${list} on this computer; Quilt shares your resolution once you resolve it and git add it.`)
-    this.emit('hold', this.hold)
-    this.scheduleStatusWrite()
-  }
-
-  /** Puts the room's version of each path back on disk (a discard on this machine never discards the room's work). */
-  writeBack (paths, say = false) {
-    let n = 0
-    for (const rel of paths) {
-      if (!this.syncable(rel) || this.merging.has(rel)) continue
-      const disk = this.readDisk(rel)
-      if (disk && (disk.skip || disk.tooLarge)) continue
-      if ((disk ? disk.key : undefined) === this.sharedKey(rel)) { if (disk) this.lastKnown.set(rel, disk.key); continue }
-      // What's on disk is what git put there (it has its own copy): no need to keep one under .quilt/conflicts.
-      if (disk) this.lastKnown.set(rel, disk.key); else this.lastKnown.delete(rel)
-      if (this.tryWrite(rel)) n++
-    }
-    if (!say || !n) return
-    const files = `${n} file${n === 1 ? '' : 's'}`
-    if (say === 'reset') this.log(`↩️ Quilt kept the session's work: git put ${files} back to your last commit on this computer only, and the session's version is back.`)
-    else this.log(`↩️ Quilt kept the session's work; your stash still has your copy. (${files})`)
-  }
-
-  /** Runs mergeOne over held entries ({ rel, base }), keeping each out of normal sync while it runs. Returns the conflicts. */
-  /** Merges each entry into the room: how many need a person (conflicts), and how many changed the room (changed). */
-  async mergeHeld (entries) {
-    for (const e of entries) this.merging.add(e.rel)
-    let conflicts = 0
-    let changed = 0
-    for (const e of entries) {
-      if (this.stopped) break
-      try {
-        const r = await this.mergeOne(e)
-        if (r === 'conflict') conflicts++
-        else if (r) changed++
-      } catch (err) { this.log(`could not merge ${e.rel}: ${err.message}`) }
-      this.merging.delete(e.rel)
-    }
-    for (const e of entries) this.merging.delete(e.rel)
-    return { conflicts, changed }
-  }
-
   /**
    * Pushes the on-disk state of a path into the shared doc. Returns true if anything changed.
    * `pulled`: git brought this version (a pull), so it is not an edit of ours: never claimed, and counted as the pull's.
@@ -5030,14 +2163,11 @@ export class Session extends EventEmitter {
   ingest (rel, { pulled = false, same = false, claim: mayClaim = true } = {}) {
     if (!this.syncable(rel) || this.inSquare || this.syncStopped) return false
     if (this.merging.has(rel)) return false // its offline merge hasn't run yet; see mergeOffline
-    if (this.held()) { this.heldPaths.add(rel); return false } // git is at work in this folder; see onSettled
-    if (this.pullWait.has(rel)) { if (!this.onDisk(rel)) return false; this.endPullWait(rel) } // made way for a pull: not a deletion
     // A plain `rm` of a file a fetched pull would bring (git said to remove it): making way, not a deletion.
-    if (!this.onDisk(rel) && this.blocksPull(rel)) { this.waitForPull([rel], false); return false }
     if (this.downloading.has(rel)) return false // our copy is being replaced by a download
     if (this.writeFailed.has(rel)) return false // the shared version never reached the disk: what's there is no edit of ours
     // New ignore rules: a box of ours on a file they now leave out lets go (settleBoxesOnce).
-    if (IGNORE_FILES.includes(path.posix.basename(rel)) || rel === '.gitmodules') { this.ig = loadIgnore(this.root); this.settleBoxesSoon() }
+    if (IGNORE_FILES.includes(path.posix.basename(rel)) || rel === '.gitmodules') { this.ig = loadIgnore(this.root) }
     const disk = this.readDisk(rel)
     const boxed = this.boxedByOther(rel)
     if (boxed) {
@@ -5103,7 +2233,6 @@ export class Session extends EventEmitter {
     if (quiltOwn) { this.quiltOwnWrite = null; this.quiltOwnKey = null }
     // With boxes, a deletion is boxed too: it reaches nobody else's folder until it's committed.
     if (mayClaim && (disk || this.boxesOn()) && !pulled && !quiltOwn && this.ready && !this.seeding && changesIt && (!claim || this.autoClaims.has(rel) || this.unboxedOwn(rel, claim)) && this.aiMayBeEditing()) this.autoClaim(rel)
-    if (!pulled && this.ownBox(rel)) this.settleBoxesSoon() // put back to what was committed, say: the box opens
 
     if (!disk) {
       if (!this.files.has(rel) && !this.blobs.has(rel)) {
@@ -5427,8 +2556,6 @@ export class Session extends EventEmitter {
     if (!this.syncable(rel) || this.inSquare || this.syncStopped) return
     if (this.ghost(rel)) return
     if (this.merging.has(rel)) return // mergeOffline writes this path once it has merged it
-    if (this.held()) { this.heldPaths.add(rel); return } // written back when the hold ends (writeBack)
-    if (this.pullWait.has(rel) && !this.onDisk(rel)) return // out of the way for a pull: putting it back would block it
     let abs
     try { abs = resolveInside(this.root, rel) } catch (err) { this.log(err.message); return }
     const shared = this.sharedKey(rel)
@@ -5470,7 +2597,7 @@ export class Session extends EventEmitter {
       this.lastKnown.set(rel, shared)
     }
     // New ignore rules: a box of ours on a file they now leave out lets go (settleBoxesOnce).
-    if (IGNORE_FILES.includes(path.posix.basename(rel)) || rel === '.gitmodules') { this.ig = loadIgnore(this.root); this.settleBoxesSoon() }
+    if (IGNORE_FILES.includes(path.posix.basename(rel)) || rel === '.gitmodules') { this.ig = loadIgnore(this.root) }
 
     if (this.ready && !this.arriving) { // a move writing its branch onto the folder is no partner's change
       this.emit('file-changed', { path: rel, by: this.lastEditorOf(rel) || 'partner' })
@@ -5623,7 +2750,6 @@ export class Session extends EventEmitter {
   /** Tries failed uploads, downloads and writes again. */
   retryFailed () {
     if (!this.ready || this.stopped || this.inSquare || this.syncStopped) return
-    if (this.hold && this.hold.kind === 'switching' && !this.following) this.recheckSoon()
     const failed = [...this.retry]
     this.retry.clear()
     for (const [rel, kind] of failed) {
@@ -5833,7 +2959,6 @@ export class Session extends EventEmitter {
       const cur = this.blobs.get(rel)
       if (!cur || cur.hash !== entry.hash) return // replaced meanwhile; that version is on its way
       if (this.stopped) return
-      if (this.held()) { this.heldPaths.add(rel); return } // git is at work on the folder: written back when the hold ends
       if (this.ghost(rel)) return // boxed by someone else meanwhile: written once it opens
       const abs = resolveInside(this.root, rel)
       let st = null
@@ -5875,26 +3000,7 @@ export class Session extends EventEmitter {
 
   // --------------------------------------------------------------- watcher --
 
-  /** Watches git in this folder (HEAD, the index, fetches) and looks for new upstream commits about once a minute. */
-  startGitWatch () {
-    if (this.gitWatcher || !this.git) return
-    this.gitWatcher = watchGit(this.root, (e) => {
-      if (this.stopped) return
-      if (e.type === 'head') { this.headChangedAt = Date.now(); this.queue(HEAD_CHANGED) } else if (e.type === 'busy') { this.setHold('busy'); this.settleSoon() } else if (e.type === 'fetch') { this.pullWaitOver.clear(); this.refreshPull(); this.checkUpstreamSoon() } else if (e.type === 'ref') { this.checkUpstreamSoon(); this.settleBoxesSoon() } else this.settleSoon() // idle, index (a branch moving is a commit: it may take boxed work in)
-    })
-    if (!this.hold || this.hold.kind !== 'switching') this.settleSoon() // a hold resumed at start ends once the tree has settled
-    this.upstreamPoll = setInterval(() => this.checkUpstreamSoon({ fetch: true }), UPSTREAM_MS)
-    this.upstreamPoll.unref()
-    this.checkUpstreamSoon({ fetch: true })
-  }
-
   async startWatcher () {
-    if (this.git) this.ensureGitHelpers().catch(() => {})
-    this.syncPersonGitSoon()
-    this.gitIndex = indexStamp(this.root)
-    this.stashSeen = stashStamp(this.root)
-    this.refreshPull() // a fetch before this start may already have something to say
-    if (this.git) this.startGitWatch()
     this.scanDisk({ baseline: true }) // the folder was just reconciled; the first re-scan catches anything since
     this.watcher = watch(this.root, {
       ignoreInitial: true,
@@ -5953,7 +3059,7 @@ export class Session extends EventEmitter {
     const color = this.color || COLORS[Math.abs(hashCode(this.name)) % COLORS.length]
     this.conn.awareness.setLocalState({
       name: this.name, tool: this.tool, color, focus: '', editing: {}, agents: [], kind: this.kind,
-      agent: { tool: null, status: 'idle', sharing: this.agentSharing }, git: this.gitSummary(),
+      agent: { tool: null, status: 'idle', sharing: this.agentSharing }, branch: this.branch,
       ...(this.aiOf ? { aiOf: this.aiOf } : {})
     })
     this.conn.awareness.on('change', ({ added, removed }, origin) => {
@@ -5966,11 +3072,6 @@ export class Session extends EventEmitter {
       this.scheduleStatusWrite()
       this.scheduleTypingExpiry()
     })
-    // Who reports a clash, and who is still here, decide who merges it (reviewClash).
-    this.conn.awareness.on('change', () => {
-      const seen = this.clashPresence()
-      if (seen !== this.clashSeen) { this.clashSeen = seen; this.reviewClashSoon() }
-    })
   }
 
   // ---------------------------------------------------------------- voice --
@@ -6153,77 +3254,6 @@ export class Session extends EventEmitter {
     return this.work
   }
 
-  /**
-   * Asks for a commit of `files` (or, without them, of the task's changes, or of everything this
-   * member changed): a person's Quilt with git on this branch commits exactly those that differ
-   * from HEAD and pushes (commitRequest), then tells the asker the hash. Agents' folders have no
-   * git, so this is how their work reaches the repository.
-   */
-  requestCommit (message, { files = null, task = null, via = null, by = null, id = null, description = '', quiet = false } = {}) {
-    message = String(message || '').trim().slice(0, MAX_MESSAGE)
-    if (this.access && this.access.state === 'approved' && this.access.role === 'viewer') throw new Error('viewers can’t ask for commits')
-    // In Seam nobody waits on someone with git: whoever is on a square commits it.
-    if (this.quilt && this.quilt.layout === 3) throw new Error('This session\'s code is committed in Seam, so there is no one to ask: commit your square yourself (the square button at the top of the app, quilt commit "<message>", or seam_commit for an AI).')
-    // A commit request is a message to the host: the relay undoes it from someone who may not post.
-    if (!this.mayTalk()) throw new Error(TALK_REFUSED)
-    const t = task ? this.taskList().find((x) => x.id === String(task)) : null
-    if (task && !t) throw new Error(`no task ${task} on the board`)
-    if (!message && t) message = t.title
-    if (!message) throw new Error('say what the commit is for')
-    const asker = by || this.actorName(via)
-    if (this.kind === 'agent' && this.canCommitHere()) throw new Error(`Get it into git yourself: commit the files you changed and push from this folder (git signs in through Quilt; by default to a branch of your own, ${agentPrefix(this.name)}<topic>, with a pull request), with nobody else needed. Asking a person is for when agents may not commit here.`)
-    let list = cleanFiles(cleanCommitFiles(files)) // a path outside the project is refused, not dropped
-    if (files && files.length && !list.length) throw new Error('none of those are files in the project (give paths relative to its top folder)')
-    if (!list.length) list = this.changedFilesFor({ task: t, by: t ? null : (asker === this.actorName(via) ? this.name : asker) })
-    if (!list.length) throw new Error(t ? `task ${t.id} has no changed files on record: give them in files` : 'Quilt has no changes of yours on record: give the files in files')
-    const desc = String(description || '').trim().slice(0, MAX_COMMIT_DESCRIPTION)
-    const r = { id: id || crypto.randomBytes(6).toString('hex'), by: asker, message, ...(desc ? { description: desc } : {}), branch: this.branch, ts: Date.now(), state: 'open', files: list, ...(t ? { task: { id: t.id, title: t.title } } : {}) }
-    // The session owner (whose machine usually commits) is told with a direct message that wakes their
-    // AI; it asks for a commit, not a reply, and waits in their inbox until the request is done.
-    const owner = ownerName(this.members)
-    const note = !quiet && owner && !this.isMine(owner) && owner !== asker
-      ? commitRequestMessage(r, { owner, id: crypto.randomBytes(8).toString('hex'), defaultBranch: DEFAULT_KEY, of: this.persona(via) ? this.name : null })
-      : null
-    this.doc.transact(() => {
-      this.commitRequests.set(r.id, r)
-      if (note) {
-        this.chat.push([note])
-        if (this.chat.length > 500) this.chat.delete(0, this.chat.length - 500)
-      }
-      // Keep the list short: drop old finished requests.
-      const done = [...this.commitRequests.values()].filter((x) => x.state === 'done').sort((a, b) => a.ts - b.ts)
-      for (const x of done.slice(0, Math.max(0, done.length - KEEP_DONE_COMMITS))) this.commitRequests.delete(x.id)
-    }, LOCAL)
-    this.log(`📌 ${asker === this.name ? 'you' : asker} asked for a commit: ${message} (${list.length} file${list.length === 1 ? '' : 's'})`)
-    this.reviewCommitsSoon()
-    return { ...r, notified: note ? owner : null, committer: this.committerLine() }
-  }
-
-  /**
-   * The files a request covers when it names none: what was changed for `task` (the session's
-   * history, and the files on the card), or every file `by` changed, newest last. Pulls from git
-   * are not anyone's changes. The committer keeps only those that differ from HEAD.
-   */
-  changedFilesFor ({ task = null, by = null } = {}) {
-    const out = []
-    const add = (p) => { if (p && !out.includes(p) && isSafeRelPath(p)) out.push(p) }
-    for (const e of this.history.entries()) {
-      if (e.pulled) continue
-      if (task ? e.task && e.task.id === task.id : e.by === by) add(e.path)
-    }
-    if (task) for (const f of task.files || []) add(f)
-    return out.slice(-MAX_REQUEST_FILES)
-  }
-
-  /** Who will commit, in a line for the asker: a person with git on this branch, or what is missing. */
-  committerLine () {
-    const st = this.status()
-    const here = [st.me, ...st.peers].filter((p) => p && p.git && p.git.key === this.branch && !p.persona && p.name !== this.name)
-    if (this.canCommit()) return `This folder has git on ${this.branch}: its app shows the request with a Commit button.`
-    if (here.length) return `${here.map((p) => p.name).join(' or ')} ${here.length === 1 ? 'has' : 'have'} git on ${this.branch} and will be asked in the app; you are told the commit when it is made.`
-    return `Nobody with git on ${this.branch} is here right now; the request waits in the app until someone is, and you are told the commit when it is made.`
-  }
-
   // ------------------------------------------------------------- tasks --
 
   /** The shared board: To do, In progress, QA, Done. Everyone in the room sees the same list. */
@@ -6512,8 +3542,7 @@ export class Session extends EventEmitter {
     if (all) return { ...r, events: this.withContext(r.events, via), me: this.readerNames(via) }
     const msgs = this.chat.toArray().filter((m) => this.canSee(m))
     const me = this.readerNames(via)
-    // A commit request (e.commit: its id) waits until the request is done; a note that a commit was made is shown once.
-    const open = (e) => typeof e.commit === 'string' ? this.commitRequests.get(e.commit)?.state === 'open' : (e.kind !== 'dm' && e.kind !== 'mention') || e.queue || e.commit || e.nudge ||
+    const open = (e) => (e.kind !== 'dm' && e.kind !== 'mention') || e.queue || e.commit || e.nudge ||
       (!this.settledIds.has(e.id) && !answered(msgs, me, e.by, e.ts))
     return { ...r, events: this.withContext(r.events.filter(open), via), me: this.readerNames(via) }
   }
@@ -6726,16 +3755,6 @@ export class Session extends EventEmitter {
     return this.webhookSending
   }
 
-  /** Marks open requests as done (by a commit made outside Quilt, or not needed): `ids`, or all. */
-  resolveCommitRequests ({ hash = '', ids = null } = {}) {
-    const open = [...this.commitRequests.values()].filter((r) => r.state === 'open' && (!ids || ids.includes(r.id)))
-    if (!open.length) return 0
-    this.doc.transact(() => {
-      for (const r of open) this.commitRequests.set(r.id, { ...r, state: 'done', doneBy: this.name, hash, doneAt: Date.now() })
-    }, LOCAL)
-    return open.length
-  }
-
   // ------------------------------------------------------------- commits --
   // Work gets into git with git: an agent's folder signs in to GitHub through Quilt (gitCredential,
   // pushCheck) within what the owner lets agents do, with nobody else needed; agents without a
@@ -6743,304 +3762,6 @@ export class Session extends EventEmitter {
   // (no GitHub connection, not GitHub, the owner keeps agents from committing): a person's folder
   // with git commits exactly its files (commit.js), from the app's commit panel.
 
-  /**
-   * A task moved to Done: when its work is in a pull request not yet merged, the relay merges it
-   * (relay-commit.js finishTaskFor): people always, agents only when the owner lets agents push to
-   * any branch. Resolves { merged } or throws with what to do. Without a relay connection, nothing.
-   */
-  async finishTask (id) {
-    if (!this.conn || !this.conn.adminRequest) return { merged: null }
-    const r = await this.conn.adminRequest({ op: 'finishTask', task: String(id || '') }, { timeoutMs: PUSH_REQUEST_TIMEOUT_MS })
-    return r && r.finishTask ? r.finishTask : { merged: null }
-  }
-
-  /**
-   * An agent took a task: its folder goes onto a branch of its own for it (quilt/<agent>/<task>),
-   * cut from where the folder is, when the folder is on a branch that isn't the agent's own and
-   * agents may push here. The agent then works and pushes there like anyone; the pull request opens
-   * by itself. Returns the branch, or null when nothing was done (people's folders, no git, already on its own branch).
-   */
-  branchForTask (task) { return this.branchMove(() => this.branchForTaskNow(task)) }
-
-  /**
-   * One branch move at a time in this agent's folder: a task's new branch (branchForTask) and leaving
-   * a merged one (leaveMergedBranch) both check out; at once, they fought over git's index, or the
-   * second undid the first (an agent taking a task as its last one's branch merged got no branch).
-   */
-  branchMove (fn) {
-    const p = (this.branchMoves || Promise.resolve()).then(fn)
-    this.branchMoves = p.catch(() => {})
-    return p
-  }
-
-  async branchForTaskNow (task) {
-    if (this.kind !== 'agent' || !this.git || !this.git.branch || !task || !task.title || !this.canCommitHere()) return null
-    const prefix = agentPrefix(this.name)
-    const settle = async () => { for (let i = 0; i < 20 && (this.hold || gitBusy(this.root, gitDir(this.root))); i++) await new Promise((r) => setTimeout(r, 250)) }
-    const run = (args) => new Promise((resolve) => execFile('git', args, { cwd: this.root, encoding: 'utf8', timeout: 20000 }, (err, _out, stderr) => resolve(err ? String(stderr || err.message) : '')))
-    // Right after a switch the folder settles for a moment (a hold): wait for it, briefly, rather than skip the branch.
-    await settle()
-    if (this.git.branch.startsWith(prefix)) {
-      // On a branch of its own already: the one it is still working on stays; a finished task's branch
-      // (merged, or its task Done) is left for the default branch, so the new task starts from there.
-      // A task is on the branch when its pull request is, or, not pushed yet, when the branch is named after it (as relay-commit.js ties them).
-      const here = this.git.branch
-      const tail = here.slice(prefix.length)
-      const named = (s) => tail === s || (tail.startsWith(`${s}-`) && /^\d+$/.test(tail.slice(s.length + 1)))
-      const onIt = (t) => (t.pr && t.pr.branch === here) || (!t.pr && named(slug(t.title)))
-      const busy = this.taskList().some((t) => t && !t.archived && t.column !== 'done' && onIt(t))
-      if (busy) return null
-      // Its own work not committed yet would come along onto the next task's branch: stay, and say why.
-      // Others' uncommitted work in the folder is the session's, not this task's: it doesn't hold the agent here.
-      const own = await this.myUncommitted().catch(() => null)
-      const dirty = own ? own.files.length > 0 : !!(await this.gitOut(['status', '--porcelain', '--untracked-files=no']))
-      if (dirty) { this.log(`🌿 staying on ${here}: it has changes not committed yet; commit them (or put them back) and take the task again for a branch of its own`); return null }
-      const main = (this.branchList.find((b) => b && b.default) || {}).key || 'main'
-      if (this.git.branch === main) return null
-      const back = await run(['checkout', '-q', main])
-      if (back) { this.emit('debug', `could not go back to ${main} for the task: ${back.trim()}`); return null }
-      for (let i = 0; i < 40 && (!this.git || this.git.branch !== main); i++) await new Promise((r) => setTimeout(r, 250))
-      await settle()
-    }
-    if (this.hold || gitBusy(this.root, gitDir(this.root)) || !this.git || !this.git.branch || this.git.branch.startsWith(prefix)) return null
-    // The new branch starts from the latest of where the folder is: fetch, and move forward when that is all it takes (never a merge here).
-    {
-      const here = this.git.branch
-      const remote = (await this.gitOut(['config', '--get', `branch.${here}.remote`])) || 'origin'
-      await new Promise((resolve) => execFile('git', ['fetch', '-q', remote, here], { cwd: this.root, encoding: 'utf8', timeout: 60000, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } }, () => resolve()))
-      await run(['merge', '-q', '--ff-only', `refs/remotes/${remote}/${here}`])
-      await settle()
-    }
-    let name = `${prefix}${slug(task.title)}`
-    for (let n = 2; (await this.gitOut(['rev-parse', '--verify', '-q', `refs/heads/${name}`])) !== null && n < 50; n++) name = `${prefix}${slug(task.title)}-${n}`
-    const r = await run(['checkout', '-q', '-b', name])
-    if (r) { this.emit('debug', `could not make a branch for the task: ${r.trim()}`); return null }
-    this.log(`🌿 on ${name} for "${task.title}": commit and push there; the pull request opens by itself`)
-    return name
-  }
-
-  /**
-   * This agent's folder is on branch `b`, which was merged (into b.merged.into): unless it has work of
-   * its own the merge didn't take (changes not committed, or commits the session's record of the branch
-   * hasn't), the folder checks out the branch it merged into and brings it up to date. Returns the branch, or null.
-   */
-  leaveMergedBranch (b) { return this.branchMove(() => this.leaveMergedBranchNow(b)) }
-
-  async leaveMergedBranchNow (b) {
-    const here = b.key
-    const into = this.branchList.some((x) => x.key === b.merged.into) ? b.merged.into : (this.branchList.find((x) => x.default) || {}).key || 'main'
-    if (!into || into === here) return null
-    for (let i = 0; i < 20 && (this.hold || gitBusy(this.root, gitDir(this.root))); i++) await new Promise((r) => setTimeout(r, 250))
-    if (this.stopped || !this.git || this.git.branch !== here) return null
-    const own = await this.myUncommitted().catch(() => null)
-    const dirty = own ? own.files.length > 0 : !!(await this.gitOut(['status', '--porcelain', '--untracked-files=no']))
-    const head = await this.gitOut(['rev-parse', 'HEAD'])
-    const rs = this.relaySha()
-    const ahead = head && rs && head !== rs && !(await isAncestor(this.root, head, rs))
-    if (dirty || ahead) { this.log(`🌿 staying on ${here}, which was merged into ${into}: it has ${dirty ? 'changes not committed yet' : 'commits the merge may not have'}; commit (or put back) and push them, then git checkout ${into}`); return null }
-    const r = await new Promise((resolve) => execFile('git', ['checkout', '-q', into], { cwd: this.root, encoding: 'utf8', timeout: 20000 }, (err, _o, stderr) => resolve(err ? String(stderr || err.message) : '')))
-    if (r) { this.emit('debug', `could not go back to ${into}: ${r.trim()}`); return null }
-    this.log(`🌿 ${here} was merged into ${into} (pull request #${b.merged.number || '?'}): this folder is on ${into} again`)
-    for (let i = 0; i < 40 && (!this.git || this.git.branch !== into); i++) await new Promise((res) => setTimeout(res, 250))
-    this.checkUpstreamSoon({ fetch: true })
-    return into
-  }
-
-  /** Which of this member's files (or a task's) aren't in git on GitHub yet, and whether agents may commit here themselves (relay-commit.js). People's sessions: nothing (they commit with git). */
-  async unpublished ({ files = null, task = null, column = '' } = {}) {
-    if (this.kind !== 'agent') return { able: false, unpublished: [] }
-    // A clash task (clash.js) is the merge itself: moving it on is how the merge lands, not a commit.
-    if (task && [...this.clashes.values()].some((c) => c && c.task === task)) return { able: false, unpublished: [] }
-    if (!this.conn || !this.conn.adminRequest) return { able: false, unpublished: [] }
-    const r = await this.conn.adminRequest({ op: 'unpublished', files, task, column: String(column || '') })
-    return r && r.unpublished ? r.unpublished : { able: false, unpublished: [] }
-  }
-
-  /** Asks the relay to look again at whether a member's GitHub connection covers this branch's repository (someone just connected). */
-  async githubRecheck () {
-    if (!this.conn || !this.conn.adminRequest) throw new Error('not connected to the relay')
-    const r = await this.conn.adminRequest({ op: 'githubRecheck' })
-    return r && r.github ? r.github : null
-  }
-
-  /** Owner only: what agents may do with commits ('off', 'branches', 'any'). */
-  async setAgentCommits (mode) {
-    if (!this.isOwner) throw new Error('only the session owner can decide what agents may commit')
-    const r = await this.conn.adminRequest({ op: 'agentCommits', agentCommits: String(mode || '') })
-    return { agentCommits: r.agentCommits }
-  }
-
-  /** Whether this folder can make the session's commits: a git checkout on a branch (agents' copies have no git). */
-  canCommit () {
-    return !!this.git && !!this.git.branch && !!gitDir(this.root) &&
-      !(this.access && this.access.state === 'approved' && this.access.role === 'viewer')
-  }
-
-  /**
-   * Commits request `id` here: its files that differ from HEAD, with its message, then pushes to
-   * the branch's upstream. Marks it done with the hash and tells the asker. Throws with the reason
-   * when it can't (another branch, behind the remote, conflict markers, git refused).
-   */
-  async commitRequest (id) {
-    const r = this.commitRequests.get(String(id || ''))
-    if (!r) throw new Error(`no commit request ${id}`)
-    if (r.state !== 'open') throw new Error(`that request is already ${r.hash ? `committed (${r.hash.slice(0, 7)})` : 'done'}`)
-    if (!this.canCommit()) throw new Error('this folder has no git (or no branch checked out), so it can’t commit: ask for the commit with quilt_request_commit, and a person with git commits it')
-    if (r.branch && r.branch !== this.git.branch) throw new Error(`the request is for ${r.branch} and this folder is on ${this.git.branch}`)
-    if (this.committing) throw new Error('a commit is already being made here')
-    this.committing = r.id
-    try {
-      return await this.gitTask(() => this.makeCommit(r))
-    } catch (err) {
-      const now = this.commitRequests.get(r.id)
-      if (now && now.state === 'open') this.doc.transact(() => this.commitRequests.set(r.id, { ...now, error: String(err.message).slice(0, 300), errorAt: Date.now() }), LOCAL)
-      throw err
-    } finally { this.committing = null }
-  }
-
-  /**
-   * Commits everything the session changed since its last commit, from this folder, with `message`,
-   * and pushes: the files here that differ from HEAD and sync. `mine` (the git panel's Commit and
-   * push): only this person's own work (myUncommitted), boxed or not. It goes on record as a commit
-   * request made and done here, so nobody else is asked.
-   */
-  async commitSessionWork (message, { mine = false } = {}) {
-    if (!this.canCommit()) throw new Error('this folder has no git (or no branch checked out), so it can’t commit: commit with git from a folder on this branch')
-    let files
-    if (mine) {
-      const own = await this.myUncommitted()
-      files = own ? own.files.map((f) => f.path).filter((rel) => this.syncable(rel)).slice(0, MAX_REQUEST_FILES) : []
-      if (!files.length) throw new Error('nothing of yours to commit: your work here is all in git')
-    } else {
-      const dirty = await uncommitted(this.root)
-      files = dirty ? [...dirty.keys()].filter((rel) => this.syncable(rel)).slice(0, MAX_REQUEST_FILES) : []
-    }
-    if (!files.length) throw new Error('nothing to commit: this folder matches its last commit')
-    const r = this.requestCommit(message, { files, by: this.name, quiet: true })
-    return this.commitRequest(r.id)
-  }
-
-  async makeCommit (r) {
-    let up = await upstreamOf(this.root)
-    if (up && up.remote && up.remote !== '.') {
-      const f = await fetchUpstream(this.root, up.remote, up.url)
-      if (f.ok) up = await upstreamOf(this.root)
-      const head = await headKey(this.root)
-      // The remote has commits this folder doesn't: catch up first (Quilt brings them in), then commit on top.
-      if (f.ok && up && up.sha && head && head.sha && !(await isAncestor(this.root, up.sha, head.sha))) {
-        const diverged = !(await isAncestor(this.root, head.sha, up.sha))
-        if (diverged) throw new Error(`${this.git.branch} has diverged from ${up.name}: a person needs to pull here before Quilt can commit on top`)
-        this.checkUpstreamSoon({ fetch: false })
-        throw new Error(`${up.name} has commits this folder doesn't have yet; Quilt is bringing them in: try again in a moment`)
-      }
-    }
-    const files = cleanFiles(r.files)
-    for (const rel of files) {
-      let text = null
-      try { text = fs.readFileSync(path.join(this.root, rel), 'utf8') } catch {}
-      if (text !== null && text.length < 2_000_000 && hasMarkers(text)) throw new Error(`${rel} has conflict markers: resolve them first`)
-    }
-    const res = await commitFiles(this.root, { files, message: commitMessage(r), upstream: up, branch: this.git.branch })
-    const done = { ...this.commitRequests.get(r.id), state: 'done', doneBy: this.name, doneAt: Date.now(), hash: res.hash || '', committed: res.files, pushed: res.pushed, ...(res.pushError ? { pushError: res.pushError } : {}) }
-    delete done.error; delete done.errorAt
-    this.doc.transact(() => this.commitRequests.set(r.id, done), LOCAL)
-    const short = res.hash ? res.hash.slice(0, 7) : ''
-    const what = res.nothing
-      ? `Nothing to commit for "${r.message}": those files are already in git as they are.`
-      : `Committed ${short} on ${this.git.branch}${res.pushed ? ` and pushed to ${up.remote}` : ''}: "${r.message}" (${res.files.length} file${res.files.length === 1 ? '' : 's'}).${res.pushError ? ` Not pushed yet: ${res.pushError}.` : ''}`
-    this.log(`${res.nothing ? 'ℹ️' : '✅'} ${what}`)
-    // The asker hears it like a handoff: it wakes them, and asks for no reply (duties.js).
-    if (!res.nothing && r.by && r.by !== this.name && this.mayTalk()) this.postCommitNote(r.by, what)
-    if (r.task && r.task.id && !res.nothing) {
-      try { putComment(this.doc, this.taskComments, readTasks(this.tasks), { taskId: r.task.id, by: this.name, text: what }, LOCAL) } catch {}
-    }
-    this.reviewCommitsSoon()
-    return done
-  }
-
-  /** A chat note to everyone about git (a push from this folder): it wakes nobody, and asks for no reply. */
-  postGitNote (text) {
-    const msg = { id: crypto.randomBytes(8).toString('hex'), by: this.name, text, ts: Date.now(), kind: 'commit' }
-    this.doc.transact(() => {
-      this.chat.push([msg])
-      if (this.chat.length > 500) this.chat.delete(0, this.chat.length - 500)
-    }, LOCAL)
-    this.markRead([msg.id])
-  }
-
-  /** A chat note to `to` that their commit was made: it wakes them, and asks for no reply. */
-  postCommitNote (to, text) {
-    const msg = { id: crypto.randomBytes(8).toString('hex'), by: this.name, to, text, ts: Date.now(), kind: 'commit' }
-    this.doc.transact(() => {
-      this.chat.push([msg])
-      if (this.chat.length > 500) this.chat.delete(0, this.chat.length - 500)
-    }, LOCAL)
-    this.markRead([msg.id])
-  }
-
-  /**
-   * The uncommitted work in this folder, by who made it: { groups: [{ by, files }], requests:
-   * [{ id, editors: { path: [names] }, blocker }] } (null without git). For the app's commit panel
-   * and for committing by itself.
-   */
-  async uncommittedWork () {
-    if (!this.canCommit()) return null
-    const dirty = await uncommitted(this.root)
-    if (!dirty) return null
-    const rels = [...dirty.keys()].filter((rel) => this.syncable(rel))
-    const history = this.history.entries()
-    const byPath = new Map()
-    for (const h of history) { if (h && h.path) { if (!byPath.has(h.path)) byPath.set(h.path, []); byPath.get(h.path).push(h) } }
-    // Who changed a file is worked out again only when the file, its history or HEAD changed since the
-    // last look. Done for every file every two minutes (reviewCommits), reading each one and its copy
-    // at HEAD and diffing them, it held hundreds of MB at a time in a folder far from its HEAD.
-    const head = ((await this.gitOut(['rev-parse', '--verify', '-q', 'HEAD'])) || '').trim()
-    const keyOf = (rel) => {
-      let st = null
-      try { st = fs.statSync(path.join(this.root, rel)) } catch {}
-      const h = byPath.get(rel) || []
-      return `${head} ${dirty.get(rel)} ${st ? `${st.size} ${st.mtimeMs}` : '-'} ${h.length} ${h.length ? h[h.length - 1].ts : 0}`
-    }
-    const cache = (this.editorsCache ||= new Map())
-    const editors = new Map()
-    const todo = new Map() // rel -> its key
-    for (const rel of rels) {
-      const key = keyOf(rel)
-      const c = cache.get(rel)
-      if (c && c.key === key) editors.set(rel, c.names)
-      else todo.set(rel, key)
-    }
-    // Each changed line is put down to whoever added or removed it last; a file git or this folder
-    // can't give as text falls back to who edited it since it was last committed.
-    const before = todo.size ? await filesAt(this.root, 'HEAD', [...todo.keys()].filter((rel) => dirty.get(rel) !== 'A')) || new Map() : new Map()
-    const rest = []
-    for (const rel of todo.keys()) {
-      const was = dirty.get(rel) === 'A' ? '' : before.get(rel)
-      let now = ''
-      if (dirty.get(rel) !== 'D') { try { now = fs.readFileSync(path.join(this.root, rel), 'utf8') } catch { now = null } }
-      if (typeof was !== 'string' || typeof now !== 'string' || now.includes('\0') || was.includes('\0')) { rest.push(rel); continue }
-      editors.set(rel, blameChange({ before: was, after: now, entries: byPath.get(rel) || [] }))
-    }
-    if (rest.length) for (const [rel, names] of editorsSince(rest, history, await lastCommitted(this.root))) editors.set(rel, names)
-    for (const [rel, key] of todo) cache.set(rel, { key, names: editors.get(rel) })
-    for (const rel of cache.keys()) if (!dirty.has(rel)) cache.delete(rel)
-    const st = this.commitStatus({ includeMe: false })
-    const busy = st.busy.map((b) => b.name)
-    const claims = [...this.claims.values()]
-    const requests = []
-    for (const r of st.open) {
-      const mine = new Map(cleanFiles(r.files).filter((f) => editors.has(f)).map((f) => [f, editors.get(f)]))
-      const markers = new Set()
-      for (const rel of mine.keys()) {
-        try { const t = fs.readFileSync(path.join(this.root, rel), 'utf8'); if (t.length < 2_000_000 && hasMarkers(t)) markers.add(rel) } catch {}
-      }
-      const taskEditors = new Set(r.task ? history.filter((e) => e.task && e.task.id === r.task.id && !e.pulled).map((e) => e.by) : [])
-      const blocker = r.branch && r.branch !== this.git.branch ? `for ${r.branch}` : !mine.size ? 'nothing to commit' : requestWarning(r, { editors: mine, claims, markers, taskEditors, busy })
-      requests.push({ id: r.id, editors: Object.fromEntries(mine), blocker })
-    }
-    return { branch: this.git.branch, groups: uncommittedByPerson(editors), requests }
-  }
-
   /** Whether a name the history gives is this person's: theirs, one of their AI sessions', or their cloud AI's. */
   ownName (name) {
     if (this.isMine(name)) return true
@@ -7058,79 +3779,6 @@ export class Session extends EventEmitter {
     return this.cloudNames
   }
 
-  /**
-   * This person's own work not committed in this folder (theirs and their AIs'; nobody else's), for
-   * the app's git panel: { branch, files: [{ path, boxed }] }, `boxed` when it is in their box (in
-   * this folder only so far), else everyone has it. Null without git.
-   */
-  async myUncommitted () {
-    const work = await this.uncommittedWork()
-    if (!work) return null
-    const dirty = new Set(work.groups.flatMap((g) => g.files))
-    const paths = new Set(work.groups.filter((g) => g.by && this.ownName(g.by)).flatMap((g) => g.files))
-    const boxed = new Set()
-    for (const c of this.claims.values()) if (c && c.box && this.ownClaim(c) && dirty.has(c.pattern)) boxed.add(c.pattern)
-    for (const rel of boxed) paths.add(rel)
-    return { branch: work.branch, files: [...paths].sort().map((p) => ({ path: p, boxed: boxed.has(p) })) }
-  }
-
-  /** Looks at the open requests again soon (one came in, or one was committed). */
-  reviewCommitsSoon (ms = 5000) {
-    if (this.stopped || !this.canCommit()) return
-    clearTimeout(this.reviewCommitsTimer)
-    this.reviewCommitsTimer = setTimeout(() => this.reviewCommits().catch((err) => this.emit('debug', `commit requests: ${err.message}`)), ms)
-    if (this.reviewCommitsTimer.unref) this.reviewCommitsTimer.unref()
-  }
-
-  /**
-   * In a folder that can commit: a request on this branch whose files are already in git as they
-   * are (its asker committed them, or someone did) is closed quietly once it is a minute old, and
-   * the app's count of what is not committed here is brought up to date.
-   */
-  async reviewCommits () {
-    if (this.stopped || !this.canCommit() || this.committing || this.hold) return
-    const work = await this.uncommittedWork()
-    if (!work) return
-    // For the app's commit chip: how much work here is not in git yet, and whose.
-    const summary = { files: new Set(work.groups.flatMap((g) => g.files)).size, people: work.groups.filter((g) => g.by).map((g) => g.by) }
-    if (JSON.stringify(summary) !== JSON.stringify(this.uncommittedSummary)) { this.uncommittedSummary = summary; this.emit('status-changed') }
-    let next = Infinity
-    for (const w of work.requests) {
-      const r = this.commitRequests.get(w.id)
-      if (!r || r.state !== 'open' || (r.branch && r.branch !== work.branch)) continue
-      const young = Date.now() - (r.ts || 0) < REQUEST_SETTLE_MS
-      if (young) { next = Math.min(next, r.ts + REQUEST_SETTLE_MS - Date.now()); continue }
-      if (w.blocker === 'nothing to commit') {
-        this.doc.transact(() => this.commitRequests.set(r.id, { ...r, state: 'done', doneBy: this.name, doneAt: Date.now(), hash: '', committed: [], note: 'already in git' }), LOCAL)
-        continue
-      }
-    }
-    if (next < Infinity) this.reviewCommitsSoon(Math.max(1000, next + 500))
-  }
-
-  /**
-   * Who's still working, open commit requests, and whether it's a good moment
-   * to commit. `includeMe: false` leaves out our own AI (it's the one asking).
-   */
-  commitStatus ({ includeMe = true } = {}) {
-    const st = this.status()
-    const people = [...(includeMe ? [{ ...st.me, work: this.work, isMe: true }] : []), ...st.peers]
-    const busy = []
-    for (const p of people) {
-      const a = p.agent
-      if (a && a.sharing !== false && a.status === 'working') busy.push({ name: p.name, why: `${p.isMe ? 'your' : `${p.name}'s`} ${a.tool || 'AI'} is working` })
-      else if (p.work && p.work.state === 'working') busy.push({ name: p.name, why: `${p.isMe ? 'you are' : `${p.name} is`} working${p.work.note ? `: ${p.work.note}` : ''}` })
-    }
-    const requests = [...this.commitRequests.values()].sort((a, b) => a.ts - b.ts)
-    return {
-      open: requests.filter((r) => r.state === 'open'),
-      recent: requests.filter((r) => r.state === 'done').slice(-5),
-      busy,
-      ready: busy.length === 0,
-      canCommit: this.canCommit()
-    }
-  }
-
   setFocus (text) {
     const focus = String(text || '').slice(0, 500)
     // The stitching clock starts with something new (or again after done) and stops with no focus.
@@ -7835,7 +4483,6 @@ export class Session extends EventEmitter {
 
   releaseQuietAutoClaims () {
     if (!this.ready || this.stopped) return
-    this.settleBoxesSoon()
     this.handOnForgotten().catch(() => {})
     const cutoff = Date.now() - this.autoClaimQuietMs
     this.releaseAutoClaims((rel, ts) => ts <= cutoff).then(() => {
@@ -7850,95 +4497,6 @@ export class Session extends EventEmitter {
     return c && c.box && this.ownClaim(c) ? c : null
   }
 
-  /** settleBoxes in a moment: after a commit, a file put back, or an edit to one of our boxed files. */
-  settleBoxesSoon (ms = SETTLE_BOXES_MS) {
-    if (this.stopped || !this.git || this.settleBoxesTimer || this.inSquare || this.syncStopped) return
-    this.settleBoxesTimer = setTimeout(() => {
-      this.settleBoxesTimer = null
-      this.settleBoxes().catch((err) => this.log(`could not look at your boxes: ${err.message}`))
-    }, ms)
-    if (this.settleBoxesTimer.unref) this.settleBoxesTimer.unref()
-  }
-
-  /**
-   * Our boxes whose file this folder's git has exactly as the session has it (committed, or put back to what
-   * was committed) open, and their claims go: the work is no longer unfinished. A box with edits since stays.
-   * Resolves to how many opened.
-   */
-  async settleBoxes () {
-    if (!this.git || !this.conn || !this.conn.connected || this.stopped) return 0
-    if (this.settlingBoxes) { this.settleBoxesAgain = true; return 0 }
-    this.settlingBoxes = true
-    let n = 0
-    try {
-      do {
-        this.settleBoxesAgain = false
-        n += await this.settleBoxesOnce()
-      } while (this.settleBoxesAgain && !this.stopped)
-    } finally { this.settlingBoxes = false }
-    if (n) this.log(`📦 ${n} boxed file${n === 1 ? '' : 's'} committed: in everyone's folder now`)
-    return n
-  }
-
-  async settleBoxesOnce () {
-    const ours = [...this.claims.values()].filter((c) => c.box && this.ownClaim(c))
-    if (!ours.length) return 0
-    // A file the session no longer shares (ignored since, say in .gitignore) is never committed here, so its
-    // box would stay forever: it lets go. Nothing goes out: the file isn't synced.
-    for (const c of ours.filter((x) => !this.syncable(x.pattern))) {
-      this.autoClaims.delete(c.pattern)
-      this.autoVia.delete(c.pattern)
-      try {
-        await this.conn.claimRequest({ op: 'unbox', pattern: c.pattern, release: true })
-        this.boxFrom.delete(c.pattern)
-        this.log(`📦 ${c.pattern} isn't shared any more (ignored): let go of its box`)
-      } catch (err) { this.log(`could not let go of the box on ${c.pattern}: ${err.message}`) }
-    }
-    const mine = ours.filter((c) => this.syncable(c.pattern))
-    if (!mine.length) return 0
-    const head = await headKey(this.root)
-    if (!head || !head.sha) return 0
-    const rels = mine.map((c) => c.pattern)
-    const at = await filesAt(this.root, head.sha, rels)
-    if (!at) return 0
-    // What git couldn't read (a large file, one behind a filter such as Git LFS): committed when the folder
-    // has the session's version and git has nothing to commit there.
-    const unread = rels.filter((rel) => at.get(rel) === undefined)
-    const dirty = unread.length ? await this.gitOut(['status', '--porcelain', '-z', '--', ...unread]) : ''
-    let n = 0
-    const asks = []
-    for (const c of mine) {
-      const rel = c.pattern
-      const shared = this.sharedKey(rel) ?? null
-      let committed = at.get(rel) // a key, null (not in the commit) or undefined (git couldn't say)
-      if (committed === undefined) {
-        if (dirty === null || dirty.split('\0').some((l) => toPosix(l.replace(/^[ MADRCTU?!]{1,2} /, '')) === rel)) continue
-        const d = this.readDisk(rel)
-        committed = d && !d.skip && !d.tooLarge ? d.key : d ? undefined : null
-        if (committed === undefined) continue
-      }
-      // Committed (or put back), or back to what the session had before the box: nothing unfinished of ours in it.
-      // Where git converts line endings (core.autocrlf, as Git for Windows sets it), the commit as checkout
-      // writes it (CRLF) and an AI's LF copy differ only in carriage returns, though git calls it committed:
-      // git itself decides (committedAs), or such a box would never open.
-      if (committed !== shared && !(this.boxFrom.has(rel) && this.boxFrom.get(rel) === shared) &&
-        !(typeof committed === 'string' && typeof shared === 'string' && !shared.startsWith('bin:') &&
-          committed.replace(/\r/g, '') === shared.replace(/\r/g, '') && await committedAs(this.root, head.sha, rel, shared))) continue
-      // Not on the list from here (in this tick, with the request sent): an edit landing next opens a new box,
-      // never one that goes out without a box.
-      const was = this.autoClaims.get(rel)
-      const via = this.autoVia.get(rel)
-      this.autoClaims.delete(rel)
-      this.autoVia.delete(rel)
-      asks.push(this.conn.claimRequest({ op: 'unbox', pattern: rel, release: true }).then((r) => { if (r.unboxed) n++; this.boxFrom.delete(rel) }, (err) => {
-        if (was !== undefined && !this.autoClaims.has(rel)) { this.autoClaims.set(rel, was); if (via) this.autoVia.set(rel, via) }
-        this.log(`could not open the box on ${rel}: ${err.message}`)
-      }))
-    }
-    await Promise.all(asks)
-    return n
-  }
-
   /**
    * The check every agent makes before it changes files, whatever tool it runs in (the local
    * MCP's quilt_before_edit, or a Claude Code hook): for each path, whether it is ours to edit
@@ -8103,12 +4661,6 @@ export class Session extends EventEmitter {
    */
   forPerson (via = null) { return this.kind !== 'agent' && !this.persona(via) }
 
-  /** Whether Quilt pushes this person's local commits for them (Settings, off unless they turn it on; read fresh so a change applies at once). */
-  pushesLocalCommits () {
-    if (this.pushLocalCommits != null) return this.pushLocalCommits === true
-    try { return getSettings().pushLocalCommits === true } catch { return false }
-  }
-
   /** Whether our AI picks up tasks by itself: "off", "mine" or "any" (Settings, read fresh so a change applies at once). */
   pickupMode () {
     if (this.aiTasks != null) return pickupMode(this.aiTasks)
@@ -8201,7 +4753,6 @@ export class Session extends EventEmitter {
     const released = await this.releaseAutoClaims(this.persona(via) ? (rel) => this.autoVia.get(rel) === via : () => true)
     if (this.work?.state === 'working') this.setWork('done')
     this.workFromEdits = false
-    await this.settleBoxes().catch(() => 0) // a box committed meanwhile opens now
     return { released }
   }
 
@@ -8252,7 +4803,6 @@ export class Session extends EventEmitter {
    */
   async boxes () {
     const text = (d) => (!d || d.skip || d.tooLarge ? null : d.binary ? { binary: true } : d.text)
-    let head
     const out = []
     for (const c of this.claims.values()) {
       if (!c || !c.box || /[*?[]/.test(c.pattern) || !isSafeRelPath(c.pattern)) continue
@@ -8262,9 +4812,8 @@ export class Session extends EventEmitter {
       const mine = this.ownClaim(c)
       let before = null
       if (mine) {
-        if (head === undefined) head = this.git ? await headKey(this.root).catch(() => null) : null
-        const buf = head && head.sha ? await blobAt(this.root, head.sha, rel).catch(() => null) : null
-        before = buf === null ? null : looksBinary(buf) ? { binary: true } : buf.toString('utf8')
+        const base = this.boxBase.has(rel) ? this.boxBase.get(rel) : null
+        before = base === null ? null : typeof base.text === 'string' ? base.text : { binary: true }
       } else if (this.boxBase.has(rel)) {
         const base = this.boxBase.get(rel)
         before = base === null ? null : typeof base.text === 'string' ? base.text : { binary: true }
@@ -8326,7 +4875,7 @@ export class Session extends EventEmitter {
     // A box someone else held opened (committed, unpacked, handed on or released): its file reaches this folder now.
     // (Also one that opened while this folder was away: its ghost is still on record.)
     // A box handed to us (our cloud AI stopped with it, server.js handBackCloudBoxes): our git may have it already.
-    if (this.ready && [...next].some(([p, c]) => c.box && c.handedFrom && this.ownClaim(c) && !(was.get(p) && this.ownClaim(was.get(p))))) this.settleBoxesSoon()
+    if (this.ready && [...next].some(([p, c]) => c.box && c.handedFrom && this.ownClaim(c) && !(was.get(p) && this.ownClaim(was.get(p))))) this.scheduleStatusWrite()
     if (this.ready) {
       const opened = new Set([...was].filter(([, c]) => c.box && !this.ownClaim(c)).map(([p]) => p))
       for (const p of this.boxBase.keys()) opened.add(p)
@@ -8791,7 +5340,6 @@ export class Session extends EventEmitter {
     for (const [n, v] of Object.entries(this.typing)) if (n !== this.name && now - v.ts < v.ms) typing.set(n, { to: v.to || null })
     for (const [id, s] of states) {
       if (id === this.doc.clientID || !s || !s.name) continue
-      const git = cleanGit(s.git)
       peers.push({
         name: s.name,
         // An older app keeps its person's stale tool after their AI connects: show the AI that did.
@@ -8806,10 +5354,8 @@ export class Session extends EventEmitter {
         focus: s.focus || '',
         ...(s.focusAt > 0 ? { focusAt: Number(s.focusAt) } : {}),
         editing: recentEdits(s.editing, now),
-        git,
-        // The branch document their folder is on: from their git presence (mid-switch, where they're headed),
-        // or, for a folder without git (cleanGit(s.git) is then null), the plain `branch` field announceBranch sets.
-        branch: (git && (git.on || git.key)) || (typeof s.branch === 'string' ? s.branch : null)
+        // The branch document their folder is on (the `branch` field of their presence).
+        branch: typeof s.branch === 'string' ? s.branch : null
       })
     }
     // AI sessions working through someone's app (an older app still lists them in its presence)
@@ -8878,12 +5424,6 @@ export class Session extends EventEmitter {
       voice: { transcribe: transcribeSetting(this.doc, this.members).on },
       peers,
       claims: [...this.claims.values()].sort((a, b) => a.ts - b.ts),
-      commits: [...this.commitRequests.values()].sort((a, b) => a.ts - b.ts),
-      canCommit: this.canCommit(),
-      agentCommits: (this.access && this.access.agentCommits) || 'branches',
-      gitForEveryone: this.gitForEveryone(),
-      // A rule over the session (its org's, a team's, its workspace's: server.js refreshPolicy): a ceiling for the owner's own choice.
-      ...(this.access && this.access.agentCommitsBy ? { agentCommitsBy: this.access.agentCommitsBy } : {}),
       tasks: this.taskList(),
       // Without the texts (up to 400 KB a record): status goes out on every
       // change. The full records are at GET /merges and the app's merges route.
@@ -8893,9 +5433,7 @@ export class Session extends EventEmitter {
       changes: this.changes().people.map((p) => ({ ...p, files: p.files.slice(0, 10), pulled: p.pulled && { ...p.pulled, files: p.pulled.files.slice(0, 10) } })),
       chat: this.messages({ limit: 20, markRead: false }),
       unread: this.unreadCount(),
-      fileCount: this.files.size + this.blobs.size,
-      git: this.git ? { branch: this.git.branch, key: this.git.key, full: !!this.branchList.find((b) => b.key === this.branch)?.full, hold: this.hold ? { kind: this.hold.kind, since: this.hold.since, to: this.hold.to || null, conflict: this.hold.conflict || null, waiting: this.hold.waiting || null } : null, pull: this.pull, upstream: this.upstream, repo: this.repo, others: (this.repo ? this.repo.branches.map((b) => b.name) : []).filter((b) => !this.branchList.some((x) => x.key === b)) } : null,
-      branches: branchBoard([{ name: this.name, git: this.gitSummary() }, ...peers.map((p) => ({ name: p.name, git: p.git, persona: !!p.persona }))], this.branchList)
+      fileCount: this.files.size + this.blobs.size
     }
   }
 
@@ -8908,15 +5446,9 @@ export class Session extends EventEmitter {
   }
 
   async stop () {
-    for (const w of this.pullWait.values()) clearTimeout(w.timer)
     this.ready = false
-    // Leaving: a person's git is as it was before Quilt (no helper, no hook of Quilt's).
-    if (this.kind !== 'agent' && !this.stopped) await this.syncPersonGit({ leaving: true }).catch(() => {})
-    clearTimeout(this.pushTimer)
     clearInterval(this.autoClaimTimer)
     clearInterval(this.personaTimer)
-    clearInterval(this.reviewCommitsTimer2)
-    clearTimeout(this.reviewCommitsTimer)
     if (this.autoClaims.size && this.conn && !this.stopped) {
       await Promise.race([this.releaseAutoClaims(), new Promise((r) => setTimeout(r, 2000))])
     }