heyquilt 0.3.138 → 0.3.141

package/src/server.js

@@ -14,7 +14,7 @@
 // editors change files, viewers only watch and chat, and agents can be
 // limited to some folders. The relay enforces it by undoing file changes a
 // member isn't allowed to make, before anyone else sees them.
-import { quiltOf, gitTokenRefusal } from './session-seam.js'
+import { quiltOf } from './session-seam.js'
 import http from 'node:http'
 import { makeChatLink, extendChatLink, pruneChatLinks, handleChatLink, fetchPublicFile } from './chat-links.js'
 import fs from 'node:fs'
@@ -45,7 +45,7 @@ import { githubRepoOf, installationFor, remoteStage, mainGuarded, rulesetSteps,
 import { syncStoppedWords } from './ui/force-words.js'
 import { historyQuilt, linkedHistory } from './quilt-history.js'
 import { MAX_DIFF_CHARS } from './history.js'
-import { LAYOUT_QUILT, copiedHead, treeIds, treeModes, branchFiles, binariesToUpload, bringsNew, forwardIntoLive, applyChecked, foldBack, writeFold, overlayFor, checkOverlay, copyIntoLive, carryLive, takeGitMeta, restoreGitMeta, squareBase, shareWithPeople, changedGitIds, dropOldCopies, boxOntoHead, writeIntoLive } from './session-layout3.js'
+import { LAYOUT_QUILT, copiedHead, treeIds, treeModes, branchFiles, binariesToUpload, bringsNew, forwardIntoLive, applyChecked, foldBack, writeFold, overlayFor, checkOverlay, copyIntoLive, carryLive, takeGitMeta, restoreGitMeta, squareBase, shareWithPeople, boxOntoHead, writeIntoLive } from './session-layout3.js'
 import { readMerges } from './merges.js'
 import { readTasks, updateTask } from './tasks.js'
 import { addComment } from './task-comments.js'
@@ -69,27 +69,14 @@ import { makeSubscription, publicWebhookHost } from './webhooks.js'
 import { noteCloudAi, cloudAiWaker } from './relay-ai-vm.js'
 import { normalizeHosted, hostedIn, newHosted } from './hosted-agents.js'
 import { ChatArchive } from './chat-archive.js'
-import { asksRelay, relayAnswer, mergedBranches } from './relay-ask.js'
-import { DIFF, markDiff, isDiff, hasEntry, cutOf, notePresent, removePath, gitOf, cachedTree, baseOf, ensureCommit, mirrorFor } from './branch-view.js'
-import { inactiveBranches, mergedByAncestry, mergedByPull, samePatches, deleteOnGithub, pruneNotice, ARCHIVE_KEEP_MS, ANCESTRY_EVERY_MS } from './relay-prune.js'
-import { githubReader } from './relay-upstream.js'
-import { RELAY_BY, isRelay } from './branches.js'
-import { commitForMember, agentCommitsOf, POLICY_RANK, ruleSetter, agentsCanCommit, pullRequestsFor, mergeForMember, unpublishedFor, remindUnpublished, notePushedFor, repoRecordFor, finishTaskFor, reviewPulls } from './relay-commit.js'
-import { appCredentials, revokeGitHubToken, noteMemberLogins } from './relay-github.js'
-import { mirrorManager, syncStateOf, runGit, fetchBranch } from './relay-git.js'
+import { asksRelay, relayAnswer } from './relay-ask.js'
+import { DIFF, isDiff, hasEntry } from './branch-view.js'
+import { inactiveBranches, pruneNotice, ARCHIVE_KEEP_MS } from './relay-prune.js'
+import { RELAY_NAME as RELAY_BY, isRelay } from './ui/chat.js'
 import { leaseKeeper, LEASE_HEARTBEAT_MS } from './relay-lease.js'
-import { bringInBranch, BACKSTOP_MS, ACTIVE_BACKSTOP_MS, syncStatus, markFolderBrought } from './relay-sync.js'
-import { noteCiResult } from './relay-ci.js'
-import { outboundFor, replayBundle, liveSyncOn, adoptBranch, receiveAgentPush } from './relay-outbound.js'
-import { ensureView, syncViewRefs, serveGit, parseUpdates, viewRepoOf, viewDir, gitHttpBackendWorks } from './relay-githttp.js'
-import { relayFileKey } from './relay-filekey.js'
 import { RoomMeter, roomDiskBytes, MachineMeter, machineLoad } from './relay-metrics.js'
 import { clusterConfig, clusterProblems, Cluster, NOT_ROOMS, roomOfPath, replaySource, canReplay, displaceRoom, packRoom, unpackRoom, placeStaged, removeLocalRoom, MOVING, ELSEWHERE } from './relay-cluster.js'
 import { joiningRoom, sessionArg } from './mcp-room.js'
-import { clashAction, noteMergeChecks } from './relay-clash.js'
-import { AGENT_COMMITS } from './github-commit.js'
-import { repoMoves } from './relay-repo-moves.js'
-import { UPSTREAM_CHECK_MS, SYNC_EVERY_MS, SYNC_EVERY_GIT_MS, upstreamsOf, noteFolders, applyRepoMove, relayEntry, relayLooks, dueBranches, checkBranch, folderOn, connectedOn, hostedOn, validToken, folderAble, catcherAble, noteHolds, connectedAs, describeRelayCheck, loadBranch, parseRepo, configureGithubBudget, CLASH_IDLE_MS, noteConnection } from './relay-upstream.js'
 import { nowSummary } from './now-summary.js'
 import { squareShort } from '@heyquilt/seam/lib/quilts/errors.js'
 
@@ -108,7 +95,6 @@ const MAX_PATTERN = 500
 const CONTROL_CHARS = /[\u0000-\u001f\u007f]/ // never in a claim: branch claims are keyed `<branch>\0<pattern>`
 // A room's documents together (the room's and every branch's) may take this many times the size limit before new branches are refused.
 const MAX_TOTAL_FACTOR = 10
-const GITHUB_REPO = /^github\.com\/[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}$/i
 const newEpoch = () => crypto.randomBytes(8).toString('hex')
 // The file queue: requests for a claimed file (a title, and a summary of the plan), and handoffs.
 const MAX_REQUEST_TITLE = 120
@@ -146,8 +132,6 @@ const hash = (s) => crypto.createHash('sha256').update(String(s)).digest()
 const sameSecret = (a, b) => a.length === b.length && crypto.timingSafeEqual(a, b)
 
 /** Relay settings, from options or environment variables. */
-// How often a room asks the accounts API what agents may commit (its org's or workspace's choice), besides being told.
-const POLICY_EVERY_MS = 10 * 60 * 1000
 
 export function relayConfig (opts = {}) {
   const env = adoptLegacyEnv({ ...process.env })
@@ -171,40 +155,10 @@ export function relayConfig (opts = {}) {
     idleUnloadMs: num(opts.idleUnloadMs, 60 * 1000),
     // A branch document nobody is on leaves memory this long after its last use (the room may stay).
     branchIdleMs: num(opts.branchIdleMs, BRANCH_IDLE_MS),
-    // How often the relay asks GitHub about a branch only hosted agents are working on (relay-upstream.js),
-    // and whether it does by itself (tests turn that off and ask with checkUpstreams).
-    upstreamCheckMs: num(opts.upstreamCheckMs, UPSTREAM_CHECK_MS),
-    upstreamAuto: opts.upstreamAuto !== false,
-    // A read-only GitHub token of the relay's own (a Fly secret, public repositories only), used when
-    // a session has none: GitHub allows 60 requests an hour per IP without one, 5000 with.
-    githubToken: opts.githubToken ?? env.QUILT_GITHUB_TOKEN ?? '',
-    // GitHub as a node (relay-sync.js): commits come in through the relay's git mirror, on by default; QUILT_GIT_SYNC=0 keeps the REST path.
-    gitSync: opts.gitSync ?? env.QUILT_GIT_SYNC !== '0',
-    gitRemote: typeof opts.gitRemote === 'function' ? opts.gitRemote : null, // tests: a repository slug -> where its git is
-    // Agents' folders use git through the relay (relay-githttp.js); off when this machine's git has no http-backend.
-    gitHttp: opts.gitHttp !== false,
-    gitHttpCommand: typeof opts.gitHttpCommand === 'string' ? opts.gitHttpCommand : 'git', // tests: a git without http-backend
-    syncAuto: opts.syncAuto === true, // the relay's own commit timer: off; commits happen when someone asks for one (quilt_git_commit, a git push)
-    crashAt: typeof opts.crashAt === 'string' ? opts.crashAt : null, // tests: where to inject a crash (relay-sync.js crashPoint)
+    // The relay's leases (relay-lease.js: a layout move holds one per room); tests shorten them.
     leaseTtlMs: num(opts.leaseTtlMs, undefined),
-    pushGapMs: num(opts.pushGapMs ?? env.QUILT_PUSH_GAP_MS, undefined),
-    pushesPerHour: num(opts.pushesPerHour, undefined),
-    activeBackstopMs: num(opts.activeBackstopMs, undefined),
-    backoffStartMs: num(opts.backoffStartMs, undefined),
-    backoffMaxMs: num(opts.backoffMaxMs, undefined),
     leaseMarginMs: num(opts.leaseMarginMs, undefined),
     leaseHeartbeatMs: num(opts.leaseHeartbeatMs, undefined),
-    atPoint: typeof opts.atPoint === 'function' ? opts.atPoint : null,
-    folderAheadWaitMs: num(opts.folderAheadWaitMs, undefined),
-    syncQuietMs: num(opts.syncQuietMs, undefined),
-    syncMaxMs: num(opts.syncMaxMs, undefined),
-    // How many GitHub API requests an hour the relay makes without a token, for every session together.
-    githubAnonPerHour: num(opts.githubAnonPerHour ?? env.QUILT_GITHUB_ANON_PER_HOUR, 50),
-    // A clash assignee with no progress this long is handed on to the next agent (relay-upstream.js).
-    clashIdleMs: num(opts.clashIdleMs, CLASH_IDLE_MS),
-    // Whether a write to a file in an open relay clash (or its task moved to QA or Done by its
-    // assignee) makes the relay look again at once; on with upstreamAuto unless set.
-    upstreamOnChange: opts.upstreamOnChange ?? opts.upstreamAuto !== false,
     // A claim whose holder has done nothing in the session this long is let go (see sweepClaims):
     // handed to the first one waiting in its file queue, or released.
     claimIdleMs: num(opts.claimIdleMs, 20 * 60 * 1000),
@@ -219,20 +173,6 @@ export function relayConfig (opts = {}) {
   }
 }
 
-/** The files a transaction changed in a branch document (entries in files or blobs, or text inside one, or a diff branch's deletions). */
-function changedPaths (tr, e) {
-  const out = new Set()
-  for (const [type, events] of tr.changedParentTypes) {
-    if (type !== e.files && type !== e.blobs && type !== e.gone) continue
-    for (const ev of events) {
-      if (ev.target === type) { for (const k of ev.changes.keys.keys()) out.add(k); continue }
-      let t = ev.target
-      while (t && t._item && t._item.parent !== type) t = t._item.parent
-      if (t && t._item && t._item.parentSub) out.add(t._item.parentSub)
-    }
-  }
-  return out
-}
 
 
 /** Who loaded a branch document, from the stack: the first two callers outside the branch store. */
@@ -284,10 +224,6 @@ class Room {
     // Each branch's files live in a document of their own (branchdocs.js); the session's
     // branches are key -> { by, at, base, seen, stored }, and the default is the first one joined.
     this.meta.branches = this.meta.branches || {}
-    // With the mirror on, every synced branch is fetched again as soon as someone is on it: a webhook may have been missed while the relay was down (plan §5.1).
-    if (cfg.gitSync && this.meta.upstreams && typeof this.meta.upstreams === 'object') for (const rec of Object.values(this.meta.upstreams)) if (rec && rec.repo) { rec.checkedAt = 0; delete rec.webhookAt }
-    // CI results the relay hadn't noted when it last stopped (noteChecks): noted now, in the order they came.
-    if (Array.isArray(this.meta.ciPending) && this.meta.ciPending.length) setTimeout(() => { if (!this.destroyed) for (const ev of this.meta.ciPending.slice()) this.runCi(ev) }, 500).unref?.()
     // Branches taken out of the session with work that may be nowhere else (relay-prune.js): kept here a while, out of the session's size.
     this.archiveDir = dataDir && path.join(dataDir, 'branches-archive', name)
     this.store = new BranchStore({
@@ -398,25 +334,6 @@ class Room {
       }
       const msg = awarenessMessage(this.awareness, changed)
       for (const ws of this.conns.keys()) if (!ws.roomless) send(ws, msg)
-      // Which upstream each branch follows, and where its folders are (relay-upstream.js).
-      if (origin && this.conns.has(origin)) this.noteUpstreams()
-    })
-    this.githubFetch = globalThis.fetch // set by startServer (tests give their own: never the network)
-    this.upstreamRun = null // the relay's look at GitHub under way (checkUpstreams)
-    this.syncAsked = new Map() // branch -> when quilt_sync_branch last made the relay ask GitHub (syncUpstreamNow)
-    this.upstreamSoonKeys = new Set() // branches to look at again at once (upstreamSoon)
-    this.lookedFor = new WeakSet() // connections whose arrival made their branch due a look (reconnect reconciliation)
-    // A relay clash's task moved to QA or Done by its assignee: the files count as merged (relay-upstream.js).
-    this.tasks.observe((ev, tr) => {
-      for (const [id, c] of ev.changes.keys) {
-        const t = this.tasks.get(id)
-        // A clash task done or gone: its files are let go of, whoever held them for it (online or not).
-        if (!t || t.column === 'done') this.dropClashClaims(id)
-        if (tr.origin === 'relay-upstream') continue
-        // Moved (or moved again, after someone else did) to QA or Done: whose move it was decides.
-        if (c.action !== 'update' || !t || (t.column !== 'qa' && t.column !== 'done')) continue
-        this.noteClashMoved(id, t, tr.origin)
-      }
     })
   }
 
@@ -721,7 +638,6 @@ class Room {
   hostedActive (id) {
     const was = this.hostedSeen.get(id) || 0
     this.hostedSeen.set(id, Date.now())
-    this.noteHostedUpstream(id)
     this.noteActivity([id])
     for (const [k, p] of this.pending) if (k.hosted && p.id === id) this.pending.delete(k)
     // Newly online, or a newer check-in time: everyone's member list shows it (once a minute at most).
@@ -752,27 +668,6 @@ class Room {
   broadcastClaims () {
     this.saveMeta()
     for (const other of this.conns.keys()) send(other, jsonMessage(MSG_CLAIMS, { claims: this.claimList(other.branch) }))
-    this.noteClaimsChanged()
-  }
-
-  /** A claim the relay's bring-in waits on (rec.waitingOn) was let go of, handed on or swept: that branch is looked at again at once. */
-  noteClaimsChanged () {
-    if (this.cfg.gitSync && this.mirrors) for (const key of Object.keys(this.meta.sync || {})) if (Object.keys((this.meta.sync[key] || {}).pending || {}).length) this.outbound.schedule(key)
-    for (const [key, rec] of Object.entries(this.meta.upstreams || {})) {
-      const w = rec && rec.waitingOn
-      if (!w) continue
-      const c = this.meta.branches[key] ? this.claimFor(w.path, key) : null
-      if (c && c.by === w.by && c.pattern === w.pattern) continue
-      delete rec.waitingOn
-      this.upstreamSoon(key)
-    }
-    // A file held for a claim that is gone now (its note above may have been cleared by a later look): looked at again.
-    if (this.cfg.gitSync && this.mirrors) {
-      for (const [key, st] of Object.entries(this.meta.sync || {})) {
-        if (!st || !this.meta.branches[key]) continue
-        if ((st.held || []).some((h) => h.why === 'claimed' && !this.claimFor(h.path, key))) this.upstreamSoon(key)
-      }
-    }
   }
 
   /** May this connection change this file? */
@@ -982,23 +877,12 @@ class Room {
     e.doc.on('update', (update, origin, doc, tr) => {
       if (origin === e.guard && e.undoing) { e.undoing.push(update); return } // sent merged, by checkChange
       if (origin && origin !== e.guard && this.guard.trackedOrigins.has(origin) && !this.checkChange(origin, update, tr, e)) return
-      // Written on in the session (not the relay bringing GitHub in): a merged branch with this after its merge keeps its work (trimMergedBranches).
-      if (origin && origin !== 'relay-upstream' && this.meta.branches[e.key]) this.meta.branches[e.key].changed = Date.now()
+      // Written on in the session: an idle branch counts from its last change (relay-prune.js).
+      if (origin && this.meta.branches[e.key]) this.meta.branches[e.key].changed = Date.now()
       if (origin && this.conns.has(origin)) {
         this.noteActivity(this.holderKeys(origin))
         if (this.cloudAiWaker) this.cloudAiWaker.personActive(this, origin).catch(() => {})
       }
-      // A member (hosted or connected) wrote a file in the relay's open clash on this branch: it looks again at once.
-      const rec = origin !== 'relay-upstream' && this.meta.upstreams ? this.meta.upstreams[e.key] : null
-      if (rec && rec.clash) for (const rel of changedPaths(tr, e)) this.noteClashWrite(e.key, rel)
-      // GitHub as a node: a member's change on a synced branch is pending for the next commit (relay-outbound.js).
-      if (origin !== 'relay-upstream' && this.cfg.gitSync && this.mirrors && rec) for (const rel of changedPaths(tr, e)) this.outbound.note(e.key, rel)
-      // A file edited in the session is no longer GitHub's version: its "from GitHub" mark goes (relay-sync.js markFromGithub).
-      if (origin !== 'relay-upstream') {
-        const gh = e.doc.getMap('fromGithub')
-        const gone = gh.size ? [...changedPaths(tr, e)].filter((rel) => gh.has(rel)) : []
-        if (gone.length) e.doc.transact(() => { for (const rel of gone) gh.delete(rel) }, 'relay-upstream')
-      }
       for (const ws of e.conns) if (ws !== origin) send(ws, updateMessage(update, ws.branchAs))
       const was = e.bytes > this.cfg.maxRoomBytes
       e.bytes += update.length
@@ -1022,31 +906,6 @@ class Room {
     return !!sq && (sq.files.has(rel) || sq.blobs.has(rel))
   }
 
-  /** Whether a new branch here may be a diff one: the relay keeps a git mirror of the session's GitHub repository. */
-  diffCapable (repo = '') {
-    if (!this.cfg.gitSync || !this.mirrors) return false
-    // A new session knows its repository once a folder reports it; until then, the folder joining says which (`repo`).
-    if (typeof repo === 'string' && GITHUB_REPO.test(repo)) return true
-    return Object.values(upstreamsOf(this)).some((rec) => rec && typeof rec.repo === 'string' && /^github\.com\//i.test(rec.repo))
-  }
-
-  /**
-   * Whether a branch a hosted agent starts may be a diff one: the relay can, and every app connected
-   * here can open one (an older app would be sent to update the moment it checked the branch out).
-   */
-  diffForHosted () {
-    if (!this.diffCapable()) return false
-    for (const ws of this.conns.keys()) if (!ws.hosted && !(ws.features || []).includes('branch-diffs')) return false
-    return true
-  }
-
-  /** Makes branch `k`'s new, empty document a diff one from commit `base` (its meta and the document say so). */
-  startDiff (k, e, base, repo = '') {
-    markDiff(e, { base, origin: 'relay-upstream' })
-    const b = this.meta.branches[k]
-    if (b) { b.form = DIFF; b.diffBase = base; if (typeof repo === 'string' && GITHUB_REPO.test(repo)) b.repo = repo.toLowerCase() }
-  }
-
   /** A branch document was saved: records it was used just now (see noteBranchSeen), and the
    * stored files it points at are remembered for when it is unloaded (storedIds). */
   noteBranchSaved (e) {
@@ -1164,66 +1023,6 @@ class Room {
     }
   }
 
-  /**
-   * Merges the webhook never told (relay-prune.js mergedByPull: a branch's merged pull request,
-   * asked hourly) and merges made without a pull request (mergedByAncestry: asks GitHub at most every
-   * ANCESTRY_EVERY_MS whether each branch's commits are all in its base), then trims what merged.
-   */
-  async findMergedBranches (now = Date.now()) {
-    if (this.destroyed || this.ended || this.findingMerges || now - (this.mergesLookedAt || 0) < ANCESTRY_EVERY_MS) return []
-    this.findingMerges = true
-    this.mergesLookedAt = now
-    try {
-      const readers = new Map()
-      const readerWith = (access) => async (repo) => {
-        if (!readers.has(`${access} ${repo}`)) readers.set(`${access} ${repo}`, await githubReader(this, repo, { fetch: this.githubFetch, fallbackToken: this.cfg.githubToken, access }))
-        return readers.get(`${access} ${repo}`)
-      }
-      this.pullsLookedAt = this.pullsLookedAt || new Map()
-      // Pull requests are only seen with the app's write token (the one that deletes merged branches).
-      const marked = [...await mergedByPull(this, { reader: readerWith('write'), now, lookedAt: this.pullsLookedAt, log: this.log }), ...await mergedByAncestry(this, { reader: readerWith('read'), now, patchesIn: (repo, base, head) => this.patchesIn(repo, base, head) })]
-      return marked.length ? this.trimMergedBranches() : []
-    } catch (err) {
-      this.log(`[${this.name}] could not look for merged branches on GitHub: ${err.message}`)
-      return []
-    } finally { this.findingMerges = false }
-  }
-
-  /**
-   * Branches whose work is merged leave the session (relay-ask.js mergedBranches): never the
-   * default branch or main, nor one someone is on or wrote on since the merge. Run when a pull
-   * request merges, on the relay's sweep, and before a new branch is refused at MAX_BRANCHES,
-   * so finished task branches never fill the session. Git keeps them. Returns the keys removed.
-   */
-  trimMergedBranches () {
-    if (this.destroyed || this.ended || !this.store) return []
-    let gone
-    try { gone = mergedBranches(this) } catch (err) { this.log(`[${this.name}] could not look for merged branches: ${err.message}`); return [] }
-    if (!gone.length) return []
-    const ups = this.meta.upstreams || {}
-    // Archived like an idle branch: an edit made after the merge from before the relay kept `changed` is not lost.
-    for (const k of gone) this.removeBranch(k, { save: false, archive: true })
-    this.log(`[${this.name}] removed ${gone.length} merged branch(es): ${gone.join(', ')}`)
-    this.saveMeta()
-    this.broadcastBranches()
-    if (this.postChat) this.postChat({ by: RELAY_BY, text: pruneNotice({ merged: gone }), kind: 'commit' })
-    // Their work is in the branch they merged into: their branches on GitHub go too (not one with an open pull request).
-    for (const k of gone) {
-      const rec = ups[k]
-      const repo = rec && (rec.repo || (rec.merged && rec.merged.repo))
-      const ref = rec && (rec.ref || (rec.merged && rec.merged.ref))
-      if (repo && ref && !rec.gone) {
-        deleteOnGithub(this, repo, ref, { fetch: this.githubFetch, log: this.log }).then((ok) => {
-          if (!ok) return
-          rec.gone = Date.now()
-          this.log(`[${this.name}] deleted merged branch ${ref} on GitHub`)
-          this.saveMeta()
-        })
-      }
-    }
-    return gone
-  }
-
   /**
    * The branch with the most members on it (connected apps, and hosted agents that chose
    * one); ties go to the owner's, then the default. Hosted agents and chat links work here
@@ -1275,32 +1074,14 @@ class Room {
    * `create`: a new branch in the session, started from a copy of the files on the branch it
    * is on (as `git switch -c` carries a folder's work). Returns { branch, created, from }.
    */
-  setHostedBranch (id, key, { create = false, by = '', editor = true, github = null } = {}) {
+  setHostedBranch (id, key, { create = false, by = '', editor = true } = {}) {
     if (!validBranchKey(key) || key === DEFAULT_KEY) throw new Error(`"${String(key).slice(0, 60)}" isn't a branch name.`)
     const to = this.resolveKey(key)
     const from = this.hostedBranch(id)
     const exists = !!this.meta.branches[to]
-    if (!exists && !create) throw new Error(`${key} isn't in this session. Pass create: true to start it: from GitHub when the branch is there, otherwise from a copy of the files on ${from}.`)
+    if (!exists && !create) throw new Error(`${key} isn't in this session. Pass create: true to start it from a copy of the files on ${from}.`)
     if (exists && create) throw new Error(`${key} is already in this session: switch to it without create.`)
-    if (!exists && github) {
-      // The branch as it is on GitHub (branchFromGitHub): its files at its head, and the commit
-      // they are, so the relay brings later commits on it in (relay-upstream.js). Read through the
-      // relay's mirror (github.diff): nothing to copy, its files follow git at that commit.
-      this.assertMigrated()
-      this.assertBranchRoom(editor, github.bytes || 0)
-      const e = this.branchDoc(to, { by, base: null, editor })
-      if (github.diff) this.startDiff(to, e, github.upstream.sha)
-      else {
-        e.doc.transact(() => {
-          for (const [rel, t] of github.texts) { const y = new Y.Text(); y.insert(0, t); e.files.set(rel, y) }
-          for (const [rel, b] of github.blobs) e.blobs.set(rel, b)
-        }, 'hosted-branch')
-      }
-      upstreamsOf(this)[to] = { ...github.upstream, head: github.upstream.sha, checkedAt: Date.now(), hostedAt: Date.now() }
-      if (github.diff) syncStateOf(this, to).base = github.upstream.sha
-    } else if (!exists && this.diffForHosted() && this.cutAsDiff(id, to, from, { by, editor })) {
-      // Cut as a diff branch: only what `from` changed relative to git came along (cutAsDiff).
-    } else if (!exists) {
+    if (!exists) {    } else if (!exists) {
       this.assertMigrated()
       this.assertBranchRoom(editor, this.store.size(from)) // a copy of `from`'s files
       const src = this.branchDoc(from, { by })
@@ -1311,7 +1092,6 @@ class Room {
         for (const [k, v] of src.fileKeys) e.fileKeys.set(k, v)
         for (const [k, v] of src.relayKeys) e.relayKeys.set(k, v)
       }, 'hosted-branch')
-      this.noteBranchCut(to, from)
     }
     this.meta.hostedBranch = { ...(this.meta.hostedBranch || {}), [id]: to }
     if (this.meta.remoteBranches && this.meta.remoteBranches[to]) delete this.meta.remoteBranches[to]
@@ -1320,83 +1100,6 @@ class Room {
     return { branch: to, created: !exists, from }
   }
 
-  /**
-   * GitHub as a node: a branch cut in the session from a live-synced branch is mirrored to the
-   * GitHub branch of the same name (plan §0, §2): its record follows the same repository, and it
-   * is measured from where it was cut, so its first push creates it on GitHub on that commit.
-   */
-  noteBranchCut (to, from) {
-    if (!this.cfg.gitSync || !this.mirrors) return false
-    const recs = upstreamsOf(this)
-    const src = recs[from]
-    if (!src || !src.repo || !src.ref || recs[to]) return false
-    const base = (this.meta.sync && this.meta.sync[from] && this.meta.sync[from].base) || src.sha
-    if (!base) return false
-    const remote = src.name && src.name.endsWith(`/${src.ref}`) ? src.name.slice(0, -(src.ref.length + 1)) : 'origin'
-    recs[to] = { repo: src.repo, name: `${remote}/${to}`, ref: to, sha: base, head: null, cutFrom: from, cutAt: base, checkedAt: 0, ...(src.github ? { github: { ...src.github } } : {}) }
-    syncStateOf(this, to).base = base
-    this.saveMeta()
-    return true
-  }
-
-  /**
-   * A hosted agent's new branch `to`, cut from `from` as a diff branch (branch-view.js cutOf): the
-   * files `from` changed relative to git, its deletions, and where each started. False (nothing
-   * made) when it has to be a full copy: git's tree at `from`'s base isn't read yet.
-   */
-  cutAsDiff (id, to, from, { by = '', editor = true } = {}) {
-    this.assertMigrated()
-    const src = this.branchDoc(from, { by })
-    const cut = cutOf(this, from, src)
-    if (!cut) return false
-    this.assertBranchRoom(editor, cut.bytes)
-    const e = this.branchDoc(to, { by, base: this.meta.branches[from] ? this.meta.branches[from].base : null, editor })
-    this.startDiff(to, e, cut.base)
-    e.doc.transact(() => {
-      for (const rel of cut.paths) {
-        const t = src.files.get(rel)
-        if (t) { const y = new Y.Text(); y.insert(0, t.toString()); e.files.set(rel, y) } else e.blobs.set(rel, src.blobs.get(rel))
-        if (src.modes.has(rel)) e.modes.set(rel, src.modes.get(rel))
-        notePresent(e, rel, { base: cut.fileBases.get(rel) })
-      }
-      for (const rel of cut.gone) removePath(e, rel, { by, base: cut.fileBases.get(rel) })
-      for (const [k, v] of src.fileKeys) e.fileKeys.set(k, v)
-      for (const [k, v] of src.relayKeys) e.relayKeys.set(k, v)
-    }, 'hosted-branch')
-    this.noteBranchCut(to, from)
-    return true
-  }
-
-  /** Before a hosted agent cuts a branch from the one it is on: git's tree there is read, so the cut can be a diff branch. Never throws. */
-  async readyToCut (id) {
-    if (!this.diffForHosted()) return
-    const from = this.hostedBranch(id)
-    const e = this.store.get(from) || this.branchDoc(from)
-    try { await gitOf(this, from, e) } catch {}
-  }
-
-  /**
-   * Whether every commit of `head` not in `base` is already in `base` as the same change (`git cherry`
-   * in the relay's mirror of `repo`: a branch cherry-picked or rebased into its base). False when the
-   * mirror can't tell (no mirror, a commit it can't get).
-   */
-  async patchesIn (repo, base, head) {
-    if (!this.mirrors || !this.cfg.gitSync) return false
-    const r = parseRepo(`https://${repo}`)
-    if (!r || !r.github) return false
-    const token = await this.gitToken(r)
-    const { dir } = await this.mirrors.ensure(r, { url: this.gitRemoteUrl(r) })
-    for (const sha of [base, head]) if (!(await ensureCommit(dir, sha, { token }))) return false
-    return samePatches(dir, base, head)
-  }
-
-  /** Reads git's tree at branch `key`'s base into the cache (a cut from it can then be a diff branch). Never throws. */
-  warmTree (key) {
-    const e = this.store.get(key)
-    if (!e || this.destroyed) return
-    gitOf(this, key, e).catch(() => {})
-  }
-
   /** A hosted agent's branch choice, forgotten once its membership here ends (it left, or the owner removed it). */
   forgetHostedBranch (id, { save = true } = {}) {
     if (!this.meta.hostedBranch || !(id in this.meta.hostedBranch)) return
@@ -1415,9 +1118,9 @@ class Room {
   assertBranchRoom (editor = true, adding = 0) {
     if (this.unsavable) throw new Error("The relay can't save this session right now, so it can't take another branch.")
     // Merged and week-idle branches make room first (relay-prune.js), then the limits are checked.
-    if (this.totalBytes() + adding > this.cfg.maxRoomBytes * MAX_TOTAL_FACTOR) { this.trimMergedBranches(); this.pruneBranches() }
+    if (this.totalBytes() + adding > this.cfg.maxRoomBytes * MAX_TOTAL_FACTOR) this.pruneBranches()
     if (this.totalBytes() + adding > this.cfg.maxRoomBytes * MAX_TOTAL_FACTOR) throw new Error("This session is at its size limit across all its branches, so it can't take another branch. Merged branches, and branches nobody worked on for a week, leave the session by themselves.")
-    if (Object.keys(this.meta.branches).length >= MAX_BRANCHES) { this.trimMergedBranches(); this.pruneBranches() } // merged and idle branches make room first
+    if (Object.keys(this.meta.branches).length >= MAX_BRANCHES) this.pruneBranches() // idle branches make room first
     if (Object.keys(this.meta.branches).length >= MAX_BRANCHES) throw new Error(`This session already has ${MAX_BRANCHES} branches, its limit; an existing one has to go before another can start.`)
     if (!editor) throw new Error('you can only view this session, so you cannot start a new branch')
   }
@@ -1435,424 +1138,12 @@ class Room {
       const k = this.hostedBranch(h.id)
       hosted.set(k, [...(hosted.get(k) || []), h.name])
     }
-    const ups = this.meta.upstreams || {}
-    const list = Object.entries(this.meta.branches).map(([key, b]) => {
-      const relay0 = relayEntry(ups[key])
-      const live = relay0 && this.cfg.gitSync && this.mirrors ? liveSyncOn(this, key) : false
-      const sync = relay0 && this.cfg.gitSync && this.mirrors ? syncStatus(this, key, { live }) : null
-      const st = this.meta.sync && this.meta.sync[key]
-      // `git`: this relay serves the session's branches over git (relay-githttp.js): agents' folders use it as their origin.
-      const relay = relay0 ? { ...relay0, ...(sync ? { sync } : {}), ...(live ? { live: true } : {}), ...(this.cfg.gitSync && this.cfg.gitHttp !== false && this.cfg.passPublicKey && this.mirrors && this.dataDirOf && /^github\.com\//.test(String(relay0.repo || '')) ? { git: true } : {}), ...(live && this.meta.largeToRelay === true && this.relayFileKey ? { fileKey: this.relayFileKey.publicKey } : {}), ...(live && st && st.protected && !st.protected.leased ? { protected: true } : {}), ...(live && st && st.protected && st.protected.leased ? { leased: true, ...(this.sameOwner(ups[key].leasedBy) ? { liveIn: ups[key].leasedBy } : {}) } : {}), ...(st && st.pr && st.pr.number ? { pr: { number: st.pr.number, url: st.pr.url || '' } } : {}) } : null
-      const merged = ups[key] && ups[key].merged ? { into: ups[key].merged.into, number: ups[key].merged.number, at: ups[key].merged.at } : null
-      return { key, by: b.by || '', at: b.at || 0, base: b.base || null, default: key === this.defaultKey, hosted: hosted.get(key) || [], ...(this.branchFull(key) ? { full: true } : {}), ...(relay ? { relay } : {}), ...(merged ? { merged } : {}) }
-    })
-    // Branches on GitHub the session doesn't have yet (a create webhook, §5.4): in the menu, synced once someone opens them.
-    for (const [key, r] of Object.entries(this.meta.remoteBranches || {})) if (!this.meta.branches[key]) list.push({ key, by: '', at: (r && r.at) || 0, base: null, default: false, hosted: [], onGitHub: true })
-    return list
-  }
-
-  // ------------------------------------------------------- upstream (relay-upstream.js) --
-  // Commits pushed to GitHub come into a branch through a member's folder. A branch only hosted
-  // agents are working on, with no folder online, is brought up to date by the relay instead.
-
-  /** Members' presence says which upstream each branch follows, and the commit its folders are at. */
-  noteUpstreams () {
-    if (!this.exists || this.ended || this.destroyed) return
-    noteHolds(this)
-    const was = new Map(Object.entries(upstreamsOf(this)).map(([key, rec]) => [key, rec && rec.sha]))
-    if (noteFolders(this, this.log)) {
-      this.saveMeta(); this.broadcastBranches(); this.noteConnections()
-      // A folder brought GitHub's commits in itself (an older app): their files are marked as from GitHub too.
-      if (this.cfg.gitSync && this.mirrors) {
-        for (const [key, rec] of Object.entries(upstreamsOf(this))) {
-          const from = was.get(key)
-          if (rec && rec.sha && from && rec.sha !== from && rec.relayHead !== rec.sha) markFolderBrought(this, key, from, rec.sha, { log: this.log })
-        }
-      }
-    }
-    // With the mirror on, a branch due a look (at start, after a member connects, or when the backstop is up) is looked at as soon as someone is on it.
-    if (this.cfg.gitSync && this.mirrors) {
-      for (const ws of this.conns.keys()) if (ws.branch && !this.lookedFor.has(ws)) { this.lookedFor.add(ws); const rec = upstreamsOf(this)[ws.branch]; if (rec) { rec.checkedAt = 0; delete rec.webhookAt } }
-      this.lookSoon()
-    }
-  }
-
-  /**
-   * What agents may commit, when the session's org or workspace sets it for all its sessions (the accounts API's
-   * /v1/relay/session-policy): kept in meta.agentCommitsSet ({ mode, by, name }) and put before the owner's own.
-   * Asked when the room loads, about every ten minutes, and at once when the API says it changed (/github/policy).
-   */
-  async refreshPolicy () {
-    if (!this.cfg.apiUrl || !this.cfg.relayApiSecret || this.destroyed || !this.exists) return
-    this.policyAt = Date.now()
-    try {
-      const res = await (this.apiFetch || globalThis.fetch)(`${String(this.cfg.apiUrl).replace(/\/+$/, '')}/v1/relay/session-policy`, { method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${this.cfg.relayApiSecret}` }, body: JSON.stringify({ room: this.name }) })
-      if (!res.ok || this.destroyed) return
-      const b = await res.json()
-      const next = AGENT_COMMITS.includes(b.agentCommits) ? { mode: b.agentCommits, by: ['org', 'team'].includes(b.by) ? b.by : 'workspace', name: String(b.name || '').slice(0, 100) } : null
-      if (JSON.stringify(next) === JSON.stringify(this.meta.agentCommitsSet || null)) return
-      const was = agentCommitsOf(this)
-      if (next) this.meta.agentCommitsSet = next; else delete this.meta.agentCommitsSet
-      this.saveMeta()
-      if (agentCommitsOf(this) === 'off' && was !== 'off') this.revokeAgentTokens({ access: 'write' })
-      this.broadcastAccess()
-      this.log(`[${this.name}] what agents may commit: ${next ? `${next.mode}, set by the ${next.by}${next.name ? ` ${next.name}` : ''}` : 'the session owner decides'}`)
-    } catch (err) { this.log(`[${this.name}] could not ask the accounts API what agents may commit: ${err.message}`) }
-  }
-
-  /** Each branch that follows a GitHub repository learns whether a member's connection lets agents commit there (relay-upstream.js noteConnection). */
-  noteConnections ({ keys = null, force = false } = {}) {
-    if (force || Date.now() - (this.policyAt || 0) > POLICY_EVERY_MS) this.refreshPolicy()
-    // Which GitHub account each person linked, for commit authorship (relay-github.js); about once an hour.
-    if (this.cfg.gitSync && this.mirrors) noteMemberLogins(this, { force, fetch: this.apiFetch }).catch(() => {})
-    for (const [key, rec] of Object.entries(upstreamsOf(this))) {
-      if (!rec || !rec.repo || (keys && !keys.includes(key))) continue
-      // A "yes" stands an hour; a "no" is asked again every ten minutes (someone may have connected
-      // from an app that couldn't say so), unless forced.
-      if (!force && rec.github && Date.now() - (rec.github.at || 0) < (rec.github.state === 'ok' ? 60 : 10) * 60 * 1000) continue
-      noteConnection(this, key, { force }).then((changed) => { if (changed && !this.destroyed) { this.saveMeta(); this.broadcastBranches(); this.broadcastAccess() } }).catch((err) => this.log(`[${this.name}] ${key}: could not check the GitHub connection: ${err.message}`))
-    }
-  }
-
-  /** A hosted agent just called a tool: its branch counts as worked on (kept, so it outlasts the room leaving memory), and is looked at if due. */
-  noteHostedUpstream (id) {
-    const key = this.meta.layout === 2 ? this.hostedBranch(id) : null
-    const rec = key && (this.meta.upstreams || {})[key]
-    if (rec && Date.now() - (rec.hostedAt || 0) >= 60 * 1000) { rec.hostedAt = Date.now(); this.saveMeta() }
-    this.lookSoon()
-  }
-
-  /** The relay's next look at the branches due (not forced), as soon as the current turn is over. */
-  lookSoon () {
-    if (!this.cfg.upstreamAuto || this.upstreamSoonTimer) return
-    this.upstreamSoonTimer = setTimeout(() => {
-      this.upstreamSoonTimer = null
-      this.checkUpstreams().catch((err) => this.log(`[${this.name}] could not look for new commits: ${err.message}`))
-    }, 0)
-    this.upstreamSoonTimer.unref?.()
-  }
-
-  /**
-   * Looks at GitHub for the branches due (or, with `force`, every branch the relay looks after,
-   * except those GitHub told to wait), one at a time; only `keys` when given. One run at a time:
-   * an ask meanwhile gets that run.
-   */
-  checkUpstreams ({ force = false, keys = null } = {}) {
-    // A look asked for (force) waits for one under way, then has its own: the one under way may not include its branches.
-    if (this.upstreamRun) return force ? this.upstreamRun.catch(() => {}).then(() => this.checkUpstreams({ force, keys })) : this.upstreamRun
-    this.checkForcedDate()
-    if (!this.exists || this.ended || this.destroyed || this.meta.layout !== 2 || this.meta.syncStopped) return Promise.resolve([])
-    this.noteConnections({ keys }) // the connections, about once an hour per branch, with the relay's own looks
-    const now = Date.now()
-    // With the mirror on: about every minute (git ls-remote, no API quota); webhooks in between (addendum 16.13).
-    const live = this.cfg.gitSync && this.mirrors
-    const activeMs = Number.isFinite(this.cfg.activeBackstopMs) ? this.cfg.activeBackstopMs : ACTIVE_BACKSTOP_MS
-    const due = live && !force
-      ? [...new Set([...dueBranches(this, { now, everyMs: activeMs, keys }).filter((k) => relayLooksActive(this, k)), ...dueBranches(this, { now, everyMs: BACKSTOP_MS, keys })])]
-      : dueBranches(this, { now, everyMs: force ? 0 : this.cfg.upstreamCheckMs, keys })
-    if (!due.length) return Promise.resolve([])
-    this.upstreamRun = (async () => {
-      const out = []
-      for (const key of due) {
-        if (this.destroyed || !relayLooks(this, key)) continue
-        try {
-          // Through the relay's git mirror (GitHub as a node), or the older REST path.
-          const r = this.cfg.gitSync && this.mirrors ? await bringInBranch(this, key, { log: this.log }) : await checkBranch(this, key, { fetch: this.githubFetch, log: this.log, fallbackToken: this.cfg.githubToken })
-          out.push({ branch: key, ...r })
-          // GitHub out of reach for a look: the branch says so (offline), until a look gets through.
-          const sync = this.cfg.gitSync && this.meta.sync && this.meta.sync[key]
-          if (sync && r.unreachable && !sync.paused) {
-            sync.paused = { why: 'unreachable', at: Date.now(), text: 'a look at GitHub failed', backoffMs: 0, until: 0 }
-            const rec = upstreamsOf(this)[key]
-            if (rec) rec.problem = `GitHub unreachable since ${new Date(sync.paused.at).toISOString().slice(11, 16)} UTC: the session keeps working, and GitHub's changes come in when it answers`
-            this.saveMeta(); this.broadcastBranches()
-          }
-          // GitHub answered: an outage is over. Commits asked for meanwhile go now; otherwise the branch just says it is reachable again.
-          if (sync && sync.paused && sync.paused.why === 'unreachable' && ['brought', 'up-to-date', 'recovered', 'rewrite'].includes(r.state)) {
-            if (Array.isArray(sync.asked) && sync.asked.length) this.outbound.recover(key).catch((err) => this.log(`[${this.name}] ${key}: could not make the commits asked for: ${err.message}`))
-            else {
-              delete sync.paused
-              const rec = upstreamsOf(this)[key]
-              if (rec && /^GitHub unreachable since/.test(rec.problem || '')) delete rec.problem
-              this.saveMeta(); this.broadcastBranches()
-            }
-          }
-        } catch (err) {
-          this.log(`[${this.name}] ${key}: could not look for new commits: ${err.message}`)
-          out.push({ branch: key, state: 'error' })
-        }
-      }
-      return out
-    })().finally(() => { this.upstreamRun = null })
-    return this.upstreamRun
-  }
-
-  /** Looks at branches `keys` now, after any look under way (not the one under way: it may not include them). */
-  async checkUpstreamsNow (keys) {
-    while (this.upstreamRun) { try { await this.upstreamRun } catch {} }
-    return this.checkUpstreams({ force: true, keys })
-  }
-
-  /** The claims held for clash task `id` (and its holder's requests for its files) let go of: the merge is done. */
-  dropClashClaims (id) {
-    const held = Object.values(this.meta.claims || {}).some((c) => c.clash === id || (c.queue || []).some((r) => r.clash === id))
-    if (!held) return
-    this.dropRequests((r) => r.clash === id)
-    this.dropClaims((c) => c.clash === id, (c) => `the merge ${c.by} held it for (task ${id}) is done.`)
-    this.broadcastClaims()
-  }
-
-  /**
-   * Claims the files of clash task `id` for its assignee `who` (a claimant: { name, id, talk, branch })
-   * on that branch, taking them over from whoever held them for the task before. A file someone else
-   * holds is asked for in its file queue instead. Returns { claimed: [path], asked: [{ path, holder }] }.
-   */
-  claimClashFiles (who, id, paths, { upstream = 'upstream' } = {}) {
-    const claimed = []
-    const asked = []
-    for (const rel of paths) {
-      try {
-        this.claimRequest(who, { op: 'claim', pattern: rel, note: `Merging commits from ${upstream} (task ${id})`, clash: id })
-        claimed.push(rel)
-      } catch {
-        const c = this.claimFor(rel, who.branch)
-        if (!c) continue
-        try {
-          this.claimRequest(who, { op: 'request', path: rel, title: `Merging commits from ${upstream}`, description: `Task ${id}: the commits clash with the session's work in this file. I merge it once you hand it over.`, task: id, clash: id })
-          asked.push({ path: rel, holder: c.by })
-        } catch {}
-      }
-    }
-    if (claimed.length || asked.length) this.broadcastClaims()
-    return { claimed, asked }
-  }
-
-  /** Branch `key` is looked at again at once, a moment from now (several asks make one look). */
-  upstreamSoon (key) {
-    if (!this.cfg.upstreamOnChange || !key) return
-    this.upstreamSoonKeys.add(key)
-    if (this.upstreamAgainTimer) return
-    this.upstreamAgainTimer = setTimeout(() => {
-      this.upstreamAgainTimer = null
-      const keys = [...this.upstreamSoonKeys]
-      this.upstreamSoonKeys.clear()
-      this.checkUpstreamsNow(keys).catch((err) => this.log(`[${this.name}] could not look for new commits: ${err.message}`))
-    }, 50)
-    this.upstreamAgainTimer.unref?.()
-  }
-
-  /** A file on branch `key` changed by a member: when it is in the relay's open clash there, the relay looks again at once. */
-  noteClashWrite (key, rel) {
-    const rec = (this.meta.upstreams || {})[key]
-    if (rec && rec.clash && rec.clash.files && rel in rec.clash.files) this.upstreamSoon(key)
+    return Object.entries(this.meta.branches).map(([key, b]) => ({ key, by: b.by || '', at: b.at || 0, base: b.base || null, default: key === this.defaultKey, hosted: hosted.get(key) || [], ...(this.branchFull(key) ? { full: true } : {}) }))
   }
 
-  /**
-   * A task moved to QA or Done: when it is a relay clash's and its assignee moved it, the files it
-   * lists count as merged as they are (for that commit), and the relay looks again at once.
-   * Who moved it: the connection's member (or one of its AI sessions), or the hosted agent whose tool ran.
-   */
-  noteClashMoved (id, task, origin) {
-    const recs = this.meta.upstreams || {}
-    const key = Object.keys(recs).find((k) => recs[k] && recs[k].clash && recs[k].clash.task === id)
-    if (!key || !task.assignee) return
-    const names = []
-    if (origin && this.conns.has(origin)) {
-      names.push(this.names.get(origin))
-      const states = this.awareness.getStates()
-      for (const cid of this.conns.get(origin)) for (const p of (states.get(cid)?.personas || [])) if (p && p.name) names.push(p.name)
-    } else if (this.auditAs && this.meta.members[this.auditAs]) names.push(this.meta.members[this.auditAs].name)
-    if (!names.includes(task.assignee)) return
-    const rec = recs[key]
-    rec.clash.settled = { by: task.assignee, at: Date.now() }
-    this.saveMeta()
-    this.log(`[${this.name}] ${key}: ${task.assignee} moved the clash task ${id} to ${task.column}: its files count as merged`)
-    this.upstreamSoon(key)
-  }
-
-  /**
-   * quilt_sync_branch where no folder can do it: the relay asks GitHub about branch `key` now
-   * (at most once a minute per branch) and brings commits in as on its own looks.
-   * Returns { state, said } (said: for the AI that asked).
-   */
-  async syncUpstreamNow (key) {
-    key = this.resolveKey ? this.resolveKey(key) : key
-    const rec = upstreamsOf(this)[key]
-    if (!rec || !rec.repo || !rec.ref) return { state: 'unknown-repo', said: `The relay doesn't know which GitHub repository \`${key}\` follows yet: a member's folder on it (a git clone) tells it once it is online.` }
-    if (!rec.sha) return { state: 'unknown-commit', said: `The relay doesn't know which commit of ${rec.name || 'the upstream'} the session's files on \`${key}\` are at yet: a member's folder on it, in step with the session, tells it.` }
-    // With the mirror on, folders follow the relay's commits: only an older app's folder brings them in itself.
-    const folder = this.cfg.gitSync && this.mirrors ? catcherAble(this, key) : folderAble(this, key)
-    if (folder) return { state: 'folder', said: `${folder}'s folder on \`${key}\` brings commits in itself (it fetches ${rec.name} about once a minute), so the relay leaves it to that folder.` }
-    if (!relayLooks(this, key)) return { state: 'not-looking', said: `The relay isn't looking after \`${key}\` right now.` }
-    const now = Date.now()
-    const last = this.syncAsked.get(key) || 0
-    // Through the mirror a look is a git ls-remote, no API quota: folders waiting for a commit ask too (session.js bringIn).
-    const mirror = this.cfg.gitSync && this.mirrors
-    if (now - last < (mirror ? SYNC_EVERY_GIT_MS : SYNC_EVERY_MS)) {
-      const ago = Math.max(1, Math.round((now - (rec.checkedAt || last)) / 1000))
-      return { state: 'recent', said: `The relay asked GitHub about ${rec.name} for \`${key}\` ${ago}s ago, and asks at most once ${mirror ? `every ${SYNC_EVERY_GIT_MS / 1000} seconds` : 'a minute'} per branch. ${rec.clash ? `Its clash is task ${rec.clash.task} on the board.` : rec.problem ? `Note: ${rec.problem}.` : rec.sha === rec.head ? `\`${key}\` was up to date with ${rec.name} then.` : ''}`.trim() }
-    }
-    this.syncAsked.set(key, now)
-    if (rec.backoffUntil > now) return { state: 'backoff', said: `Not now: ${rec.problem || 'GitHub asked the relay to slow down'}.` }
-    const out = await this.checkUpstreamsNow([key])
-    const r = out.find((x) => x.branch === key)
-    return { state: r ? r.state : 'not-looking', said: describeRelayCheck(r, upstreamsOf(this)[key] || rec, key, this) }
-  }
-
-  /**
-   * A member's commit to GitHub from the session's copy of the files on branch `key`
-   * (relay-commit.js): who is { name, kind, access }; `req` says files, message, branch,
-   * pullRequest, withOthers, task. One at a time per session.
-   */
-  async commitFor (who, key, req = {}) {
-    const run = () => commitForMember(this, {
-      who,
-      key,
-      files: Array.isArray(req.files) ? req.files.slice(0, 1000).map(String) : null,
-      message: typeof req.message === 'string' ? req.message : '',
-      branch: typeof req.branch === 'string' ? req.branch : '',
-      pullRequest: req.pullRequest === true,
-      withOthers: req.withOthers === true,
-      task: typeof req.task === 'string' ? req.task : null
-    }, { fetch: this.githubFetch, log: this.log })
-    const next = (this.committing || Promise.resolve()).then(run, run)
-    this.committing = next.catch(() => {})
-    return next
-  }
-
-  /**
-   * A token for the repository branch `key` follows, for a member's folder (relay-github.js): read,
-   * to fetch or clone; write (`access`), to push with, while git is on for everyone here (git for
-   * everyone: agentCommitsOf isn't 'off'; an agent's pre-push hook holds its pushes to the policy's
-   * branches). An agent's or a person's write token is their own (minted for them alone, `actingFor`
-   * their account, so the org's Require GitHub and the workspace's repositories apply as for anyone),
-   * kept here so it can be taken back at GitHub when they are removed or git turns off. `who`:
-   * { name, kind, id } (id: their account, person:<id>). { token, expiresAt, repo, access } or
-   * { state } when there is none. A token the owner pasted by hand is never handed out.
-   */
-  async gitTokenFor (key, { access = 'read', who = null, repo: asked = null } = {}) {
-    key = this.resolveKey(key)
-    // The repository: the one the folder's git names (`asked`, owner/name), when a branch here follows
-    // it; else the branch's own record, else the default branch's (a new feature branch has no record yet).
-    let rec = null
-    if (typeof asked === 'string' && /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/.test(asked)) {
-      rec = Object.values(upstreamsOf(this)).find((r) => r && r.repo && String(r.repo).toLowerCase() === `github.com/${asked}`.toLowerCase()) || null
-    }
-    if (!rec) rec = (repoRecordFor(this, key) || {}).rec || null
-    const repo = rec && rec.repo ? parseRepo(`https://${rec.repo}`) : null
-    if (!repo || !repo.github) return { state: 'not-github' }
-    const full = `${repo.owner}/${repo.name}`
-    const agent = !!who && who.kind === 'agent' && !!who.name
-    const person = !!who && who.kind !== 'agent' && /^person:[A-Za-z0-9_-]{1,64}$/.test(who.id || '')
-    const on = agentCommitsOf(this) !== 'off'
-    const level = access === 'write' && on && (agent || person) ? 'write' : 'read'
-    // A person reading: the relay's own read token, as before. Everyone writing, and agents always, get one of their own.
-    if (!agent && level === 'read') {
-      const r = await appCredentials(this, full, { access: level })
-      return r.token ? { token: r.token, expiresAt: r.expiresAt, repo: full, access: level } : { state: r.state }
-    }
-    if (!this.agentTokens) this.agentTokens = new Map()
-    const k = `${agent ? who.name : who.id}\0${full}\0${level}`.toLowerCase()
-    const hit = this.agentTokens.get(k)
-    if (hit && hit.expiresAt - Date.now() > 5 * 60 * 1000) return { token: hit.token, expiresAt: hit.expiresAt, repo: full, access: level }
-    // Who the token is for decides when the org requires GitHub (plan §2): an agent's member key is agent:<id>, a person's person:<id>.
-    const actor = agent ? (Object.entries(this.meta.members || {}).find(([k, m]) => k.startsWith('agent:') && m && m.name === who.name) || [])[0] : who.id
-    const r = await appCredentials(this, full, { access: level, share: false, ...(actor ? { actingFor: actor } : {}) })
-    if (!r.token) return { state: r.state, ...(r.why ? { why: r.why } : {}), ...(r.require ? { require: true } : {}) }
-    this.agentTokens.set(k, { token: r.token, expiresAt: r.expiresAt, name: who.name, account: agent ? actor || '' : who.id, access: level })
-    return { token: r.token, expiresAt: r.expiresAt, repo: full, access: level }
-  }
-
-  /** Takes back the tokens handed to members' folders: one agent's (`name`), one account's (`account`), or every write token (`access`). */
-  revokeAgentTokens ({ name = null, account = null, access = null } = {}) {
-    if (!this.agentTokens) return
-    for (const [k, t] of this.agentTokens) {
-      if ((name && t.name !== name) || (account && t.account !== account) || (access && t.access !== access)) continue
-      this.agentTokens.delete(k)
-      revokeGitHubToken(t.token, { fetch: this.githubFetch }).then((ok) => { if (ok) this.log(`[${this.name}] took back ${t.name}'s ${t.access} token for GitHub`) })
-    }
-  }
-
-  /** Everyone's access again: what agents may do with commits, and whether they can (the GitHub connection) changed. */
+  /** Everyone's access again. */
   broadcastAccess () { for (const [cws, a] of this.access) send(cws, jsonMessage(MSG_ACCESS, this.accessMessage(a))) }
 
-  /**
-   * Git for this session, the owner's call ('off', 'branches', 'any'; '' follows the rule over the session,
-   * or the default): within the rule over it (an org's, a team's, a workspace's), which is a ceiling: the
-   * owner may be stricter, never looser. Everyone's access says it.
-   */
-  setAgentCommits (mode) {
-    if (mode !== '' && !AGENT_COMMITS.includes(mode)) throw new Error(`pick one of ${AGENT_COMMITS.join(', ')}`)
-    const set = this.meta.agentCommitsSet
-    if (mode && set && POLICY_RANK[mode] > POLICY_RANK[set.mode]) {
-      const what = set.mode === 'off' ? 'turned git off for its sessions' : 'lets agents push only to branches of their own in its sessions'
-      throw new Error(`${ruleSetter(set)} ${what}: change it in its settings`)
-    }
-    if ((mode || undefined) !== this.meta.agentCommits) {
-      const was = agentCommitsOf(this)
-      if (mode) this.meta.agentCommits = mode; else delete this.meta.agentCommits
-      this.saveMeta()
-      if (agentCommitsOf(this) === 'off' && was !== 'off') this.revokeAgentTokens({ access: 'write' }) // nobody's folder can push any more, at once
-      for (const [cws, a] of this.access) send(cws, jsonMessage(MSG_ACCESS, this.accessMessage(a)))
-    }
-    return agentCommitsOf(this)
-  }
-
-  /** The owner sets (or clears, with '') the read-only GitHub token. Never echoed or logged. */
-  setGithubToken (token) {
-    const t = String(token ?? '').trim()
-    if (t && !validToken(t)) throw new Error("That doesn't look like a GitHub token (ghp_… or github_pat_…).")
-    if (t) this.meta.githubToken = t
-    else delete this.meta.githubToken
-    this.log(`[${this.name}] the owner ${t ? 'set' : 'cleared'} the GitHub token for bringing in commits`)
-    this.upstreamTokenChanged()
-    this.broadcastAccess() // the owner sees whether a token is set; everyone sees whether agents can commit now
-    return { ok: true, githubToken: !!t }
-  }
-
-  /**
-   * A branch on GitHub a hosted agent switches to with create (quilt_switch_branch): its files at
-   * the branch's head, from the repository the session follows (the agent's branch's, else any
-   * branch's). { state: 'loaded', texts, blobs, skipped, bytes, upstream: { repo, name, ref, sha } }
-   * or { state, repo } saying why not ('no-repo', 'not-github', 'no-branch', 'private', ...).
-   */
-  async branchFromGitHub (id, key) {
-    const recs = upstreamsOf(this)
-    const mine = recs[this.hostedBranch(id)]
-    const src = mine && mine.repo ? mine : Object.values(recs).find((r) => r && r.repo)
-    if (!src) return { state: 'no-repo' }
-    const repo = parseRepo(`https://${src.repo}`)
-    if (!repo || !repo.github) return { state: 'not-github', repo: src.repo }
-    const remote0 = src.name && src.ref && src.name.endsWith(`/${src.ref}`) ? src.name.slice(0, -(src.ref.length + 1)) : 'origin'
-    if (this.diffForHosted()) {
-      // Through the relay's mirror: only the branch's head, since a diff branch's files follow git (branch-view.js).
-      try {
-        const token = await this.gitToken(repo)
-        const { dir } = await this.mirrors.ensure(repo, { url: this.gitRemoteUrl(repo) })
-        const { sha } = await fetchBranch(dir, key, { token })
-        if (!sha) return { state: 'no-branch', repo: src.repo }
-        return { state: 'loaded', diff: true, head: sha, texts: new Map(), blobs: new Map(), skipped: [], bytes: 0, repo: src.repo, upstream: { repo: src.repo, name: `${remote0}/${key}`, ref: key, sha } }
-      } catch (err) {
-        if (err.kind === 'auth') return { state: 'private', repo: src.repo }
-        return { state: 'error', repo: src.repo, message: String(err.message).slice(0, 160) }
-      }
-    }
-    const own = validToken(this.meta.githubToken) ? this.meta.githubToken : null
-    const token = own || (validToken(this.cfg.githubToken) ? this.cfg.githubToken : null)
-    const r0 = await loadBranch({ repo: src.repo, ref: key, token, fetch: this.githubFetch })
-    const r = r0.state === 'token-refused' && !own ? { ...r0, state: 'private' } : r0
-    const remote = src.name && src.ref && src.name.endsWith(`/${src.ref}`) ? src.name.slice(0, -(src.ref.length + 1)) : 'origin'
-    return { ...r, repo: src.repo, ...(r.state === 'loaded' ? { upstream: { repo: src.repo, name: `${remote}/${key}`, ref: key, sha: r.head } } : {}) }
-  }
-
-  /** The owner set (or cleared) the read-only GitHub token: every branch is looked at afresh. */
-  upstreamTokenChanged () {
-    for (const rec of Object.values(upstreamsOf(this))) { delete rec.problem; delete rec.backoffUntil; delete rec.backoffMs; delete rec.etag; rec.checkedAt = 0 }
-    this.saveMeta()
-    this.broadcastBranches()
-    if (this.cfg.upstreamAuto) this.checkUpstreams().catch(() => {})
-  }
-
   /**
    * What every branch-list message carries: the list and, once the session is a quilt (behind
    * QUILT_SOURCE_URL), its link { id, slug, squares: { branch: square id } } so each member's
@@ -1910,200 +1201,6 @@ class Room {
     for (const ws of this.conns.keys()) send(ws, msg)
   }
 
-  /**
-   * GitHub said `repo` (owner/name) moved `ref` (a branch name) to `sha`. Every branch of this
-   * session that follows it looks now: folders on it are told to fetch (older apps ignore the
-   * field and find it on their next look), and the relay checks GitHub itself for a branch no
-   * folder can bring in. Returns whether any branch follows it.
-   */
-  /** Whether session `other` has this session's owner in it (its owner or a member): then the app may offer to open it ("Open the live session", plan §8). */
-  sameOwner (other) {
-    if (!other || !this.meta.ownerSub) return false
-    if (this.dataDirOf) {
-      try {
-        const m = JSON.parse(fs.readFileSync(path.join(this.dataDirOf, `${other}.json`), 'utf8'))
-        return m.ownerSub === this.meta.ownerSub || !!(m.members && m.members[this.meta.ownerSub])
-      } catch {}
-    }
-    // On another relay machine: the accounts API knows who owns it and who has been in it (asked once, then remembered).
-    if (this.cluster) return this.cluster.sameOwner(other, this.meta.ownerSub, () => { if (!this.destroyed) this.broadcastBranches() }) === true
-    return false
-  }
-
-  /** The relay pushed `sha` to branch `key`'s upstream: folders on it fetch now and follow it (no file is written: the session has it). */
-  tellPushed (key, sha) {
-    const msg = jsonMessage(MSG_BRANCHES, { ...this.branchesFields(), pushed: { branch: key, sha } })
-    for (const ws of this.conns.keys()) send(ws, msg)
-  }
-
-  /** Session → GitHub for this room (relay-outbound.js): batches per branch, the push. */
-  get outbound () {
-    if (!this._outbound) this._outbound = outboundFor(this)
-    return this._outbound
-  }
-
-  /** Where the git of `repo` ({ slug, host, owner, name }) is: GitHub, or wherever tests say. */
-  gitRemoteUrl (repo) {
-    return this.cfg.gitRemote ? this.cfg.gitRemote(repo.slug) : `https://${repo.slug}.git`
-  }
-
-  /** What signs the relay's git in to read `repo`: the owner's token, a member's GitHub connection, the relay's own token, or nothing (a public repository). */
-  async gitToken (repo, { access = 'read', actingFor = '' } = {}) {
-    return (await this.gitTokenState(repo, { access, actingFor })).token
-  }
-
-  /** { token } for the relay's git on `repo`, or { token: null, state, why? } saying why not (plan §2: the workspace's access mode, the org's Require GitHub). */
-  async gitTokenState (repo, { access = 'read', actingFor = '' } = {}) {
-    if (validToken(this.meta.githubToken)) return { token: this.meta.githubToken }
-    const r = await appCredentials(this, `${repo.owner}/${repo.name}`, { access, fresh: false, actingFor })
-    if (r.token) return { token: r.token }
-    if (r.state === 'not-allowed' || r.require) return { token: null, state: r.state, ...(r.why ? { why: r.why } : {}), ...(r.require ? { require: true } : {}) }
-    return { token: validToken(this.cfg.githubToken) ? this.cfg.githubToken : null, state: r.state }
-  }
-
-  /** A check suite finished on `repo`: the pull requests this room's tasks are in are looked at now (relay-commit.js reviewPulls). */
-  noteChecks ({ repo, sha = '', branch = '', conclusion = '' }) {
-    const want = String(repo).toLowerCase().replace(/^github\.com\//, '')
-    const follows = Object.values(upstreamsOf(this)).some((rec) => rec && rec.repo && String(rec.repo).toLowerCase().replace(/^github\.com\//, '') === want)
-    if (!follows) return false
-    // Checks on a commit the relay pushed with merged files in it (relay-clash.js): failing tells both parties; nothing is held.
-    if (this.cfg.gitSync && this.mirrors && /^[0-9a-f]{40}$/.test(sha)) {
-      for (const [key, rec] of Object.entries(upstreamsOf(this))) {
-        if (!rec || String(rec.repo).toLowerCase().replace(/^github\.com\//, '') !== want || (branch && rec.ref !== branch && !(rec.ref && branch === `quilt/live/${rec.ref}`))) continue
-        const repoObj = parseRepo(`https://${rec.repo}`)
-        this.mirrors.queue(repoObj.slug, rec.ref, () => noteMergeChecks(this, key, { sha, conclusion })).then((r) => { if (r.length) { this.saveMeta(); this.broadcastBranches() } }).catch((err) => this.log(`[${this.name}] ${key}: could not look at the checks on ${sha.slice(0, 7)}: ${err.message}`))
-      }
-    }
-    reviewPulls(this, { fetch: this.githubFetch, log: this.log }).catch((err) => this.log(`[${this.name}] could not look at the pull requests: ${err.message}`))
-    // CI failing on a branch the session follows is a task on the board until it passes again (relay-ci.js). Kept in
-    // the room's meta until noted, so a restart meanwhile (a deploy) notes it when the room is back.
-    if (branch && sha) {
-      const ev = { repo, sha, branch, conclusion, at: Date.now() }
-      this.meta.ciPending = [...(Array.isArray(this.meta.ciPending) ? this.meta.ciPending : []), ev].slice(-50)
-      this.saveMeta()
-      this.runCi(ev)
-    }
-    return true
-  }
-
-  /** Notes CI result `ev` on the board (relay-ci.js), then drops it from the room's pending ones: unless the room shut down first. */
-  runCi (ev) {
-    noteCiResult(this, ev, { fetch: this.githubFetch, log: this.log }).finally(() => {
-      if (this.destroyed) return
-      const same = (x) => x && x.sha === ev.sha && x.branch === ev.branch && x.conclusion === ev.conclusion && x.at === ev.at
-      this.meta.ciPending = (Array.isArray(this.meta.ciPending) ? this.meta.ciPending : []).filter((x) => !same(x))
-      this.saveMeta()
-    })
-  }
-
-  /** GitHub says pull request `number` on `repo` changed: looked at now when this room follows that repository (relay-commit.js reviewPulls). */
-  notePull ({ repo, number, action = '', merged = false, head = '', base = '', sha = '' }) {
-    const want = String(repo).toLowerCase().replace(/^github\.com\//, '')
-    const recs = upstreamsOf(this)
-    const follows = Object.values(recs).some((rec) => rec && rec.repo && String(rec.repo).toLowerCase().replace(/^github\.com\//, '') === want)
-    if (!follows) return false
-    // §5.6: the pull request's source branch, when the session has it, is marked merged (the branch list says so; a deletion on GitHub then moves its members to the base).
-    if (merged && head) {
-      const key = this.resolveKey ? this.resolveKey(head) : head
-      const rec = recs[key]
-      if (rec && String(rec.repo).toLowerCase().replace(/^github\.com\//, '') === want && rec.ref === head) {
-        rec.merged = { at: Date.now(), into: base || '', number, ...(sha ? { sha } : {}) }
-        this.saveMeta(); this.broadcastBranches()
-        this.trimMergedBranches() // gone now when nobody is on it; else the sweep takes it once they've left
-      }
-    }
-    // Addendum 16.5: the live pull request of a protected branch (or of a session without the branch's lease).
-    if (this.cfg.gitSync && this.meta.sync) {
-      for (const [key, rec] of Object.entries(recs)) {
-        const p = this.meta.sync[key] && this.meta.sync[key].protected
-        if (!rec || !p || !p.pr || p.pr.number !== number || String(rec.repo).toLowerCase().replace(/^github\.com\//, '') !== want) continue
-        if (merged) {
-          p.merged = { at: Date.now(), ...(sha ? { sha } : {}) }
-          rec.problem = `${rec.ref} is protected: the live pull request #${number} is merged; commits go through a new one (opened with the next commit)`
-          this.checkUpstreamsNow([key]).catch((err) => this.log(`[${this.name}] could not look for new commits: ${err.message}`))
-        } else if (action === 'closed') {
-          p.closed = Date.now()
-          rec.problem = `${rec.ref} is protected: pull request #${number} was closed without merging; the session keeps its work, and a new pull request opens with the next commit`
-        } else if (action === 'reopened') { delete p.closed; delete p.askedFor }
-        this.saveMeta(); this.broadcastBranches()
-      }
-    }
-    reviewPulls(this, { fetch: this.githubFetch, log: this.log, only: number }).catch((err) => this.log(`[${this.name}] could not look at pull request #${number}: ${err.message}`))
-    return true
-  }
-
-  /**
-   * GitHub said `repo` moved `ref` (a branch): `after` is its new head (`sha` from an older API),
-   * `before` the old one, `forced` a rewrite, `deleted` or `created` the branch itself. Every
-   * branch of this session that follows it looks now: folders on it are told, and the relay reads
-   * the truth from git (only the ref name is trusted). A push whose head is the one the relay
-   * itself pushed is an echo, and ignored. Returns 'echo', true (a branch follows it) or false.
-   */
-  notePush ({ repo, ref, sha = '', after = '', before = '', forced = false, deleted = false, created = false }) {
-    const want = String(repo).toLowerCase().replace(/^github\.com\//, '')
-    const head = typeof after === 'string' && after ? after : (typeof sha === 'string' ? sha : '')
-    let hit = false
-    let echo = false
-    for (const [key, rec] of Object.entries(upstreamsOf(this))) {
-      if (!rec || !rec.repo || rec.ref !== ref || String(rec.repo).toLowerCase().replace(/^github\.com\//, '') !== want) continue
-      hit = true
-      rec.webhookAt = Date.now()
-      if (deleted) { this.noteBranchDeleted(key, rec); continue } // §5.4
-      if (rec.gone && (head || created)) { delete rec.gone; delete rec.problem; this.saveMeta() } // pushed again: the branch is back on GitHub
-      if (created && !head) { this.saveMeta(); continue } // a branch made on GitHub: in the menu, nothing to bring in yet
-      const sync = this.cfg.gitSync && this.meta.sync && this.meta.sync[key]
-      if (head && sync && sync.pushed === head && sync.base === head) { echo = true; this.saveMeta(); continue } // our own push, come back round
-      const at = this.cfg.gitSync && this.mirrors && this.meta.sync && this.meta.sync[key] && this.meta.sync[key].base ? this.meta.sync[key].base : rec.sha
-      if (head && at === head) { this.saveMeta(); continue } // already there
-      const msg = jsonMessage(MSG_BRANCHES, { ...this.branchesFields(), pushed: { branch: key, sha: head, ...(forced ? { forced: true } : {}) } })
-      for (const ws of this.conns.keys()) send(ws, msg)
-      this.checkUpstreamsNow([key]).catch((err) => this.log(`[${this.name}] could not look for new commits: ${err.message}`))
-    }
-    // §5.4: a branch created on GitHub that the session doesn't have appears in the branch menu, not synced until someone opens it.
-    if (created && !hit && ref && validBranchKey(ref) && !this.meta.branches[this.resolveKey ? this.resolveKey(ref) : ref]) {
-      const follows = Object.values(upstreamsOf(this)).some((rec) => rec && rec.repo && String(rec.repo).toLowerCase().replace(/^github\.com\//, '') === want)
-      if (follows) {
-        if (!this.meta.remoteBranches || typeof this.meta.remoteBranches !== 'object') this.meta.remoteBranches = {}
-        this.meta.remoteBranches[ref] = { at: Date.now() }
-        this.saveMeta(); this.broadcastBranches()
-        return true
-      }
-    }
-    if (deleted && !hit && this.meta.remoteBranches && this.meta.remoteBranches[ref]) { delete this.meta.remoteBranches[ref]; this.saveMeta(); this.broadcastBranches(); return true }
-    return hit ? (echo ? 'echo' : true) : false
-  }
-
-  /**
-   * A synced branch was deleted on GitHub (§5.4). After its pull request merged, its members are moved to the
-   * branch it merged into (hosted agents are moved; people's folders are told) and told. Otherwise the session
-   * keeps the branch: it comes back with the next commit, unless the owner turned that off (recreateDeleted).
-   */
-  noteBranchDeleted (key, rec) {
-    const now = Date.now()
-    rec.gone = now
-    const merged = rec.merged && rec.merged.into ? rec.merged : null
-    if (merged) {
-      const into = this.resolveKey ? this.resolveKey(merged.into) : merged.into
-      const where = this.meta.branches[into] ? into : this.defaultKey
-      rec.problem = `${rec.ref} was merged into ${merged.into} (pull request #${merged.number}) and deleted on GitHub`
-      const moved = []
-      for (const [id, k] of Object.entries(this.meta.hostedBranch || {})) {
-        if (k !== key) continue
-        const m = this.meta.members[id]
-        try { this.setHostedBranch(id, where, {}); moved.push(m && m.name) } catch {}
-      }
-      for (const ws of this.conns.keys()) if (ws.branch === key && this.names && this.names.get(ws) && !moved.includes(this.names.get(ws))) moved.push(this.names.get(ws))
-      if (this.postChat) for (const name of [...new Set(moved.filter(Boolean))]) this.postChat({ by: RELAY_BY, to: name, kind: 'nudge', text: `${rec.ref} was merged into ${merged.into} and deleted on GitHub (pull request #${merged.number}): you are on ${where} now${this.meta.hostedBranch && Object.values(this.meta.hostedBranch).includes(where) ? '' : ' (a folder: git checkout ' + where + ')'}.` })
-    } else if (this.meta.recreateDeleted === true) {
-      rec.problem = `${rec.ref} was deleted on GitHub: the session keeps it, and it comes back with the next commit (the owner's choice)`
-    } else {
-      // Addendum 16.10: a deletion on GitHub is meant; publication pauses, the work stays in the session.
-      rec.problem = `${rec.ref} was deleted on GitHub: the session keeps it and its work, and nothing is pushed there unless the owner lets Quilt recreate deleted branches`
-    }
-    this.log(`[${this.name}] ${key}: ${rec.problem}`)
-    this.saveMeta(); this.broadcastBranches()
-  }
-
   /**
    * A connection's branch request; returns the reply fields. join: subscribe to a branch's
    * document (one at a time), adding the branch to the session when new. confirm: the relay
@@ -2151,8 +1248,6 @@ class Room {
         closeSoon(ws, CLOSE_NEEDS_UPDATE, NEEDS_UPDATE)
         throw new Error(NEEDS_UPDATE)
       }
-      // A new branch an app asks to keep as differences from its commit (`diffBase`, one GitHub has).
-      const diff = created && req.form === DIFF && /^[0-9a-f]{40,64}$/.test(String(req.diffBase || '')) && (ws.features || []).includes('branch-diffs') && this.diffCapable(req.repo)
       if (ws.branch && ws.branch !== k) {
         // Kept a moment longer: a sync message the app sent for it just before switching,
         // still in flight, is applied rather than silently dropped (handle, MSG_SYNC).
@@ -2163,7 +1258,6 @@ class Room {
       ws.branch = k // the document, as the relay keeps it
       ws.branchAs = key // as the app named it (∅ without git): its sync messages carry this
       this.noteBranch(k, { by: this.names.get(ws) || '', base: req.base })
-      if (diff) this.startDiff(k, e, req.diffBase, req.repo)
       this.noteBranchSeen(k, { force: true, used: true })
       // Everyone hears a new branch, and a default branch that just took its real name.
       return { ok: true, branch: k, created, base: this.meta.branches[k].base, epoch: this.branchEpoch(k), form: isDiff(e) ? DIFF : 'full', ...(isDiff(e) ? { diffBase: e.diffBase } : {}), listChanged: created || adopted }
@@ -2713,27 +1807,6 @@ class Room {
     return head === null ? null : { head, versions: [...ids].map(text).filter((x) => typeof x === 'string') }
   }
 
-  async mainHistoryOf (paths) {
-    if (!paths.length) return new Map()
-    const up = (this.meta.upstreams || {})[this.defaultKey]
-    if (!up || !/^[0-9a-f]{40,64}$/.test(String(up.sha || '')) || !this.mirrors || !this.cfg.gitSync) return null
-    let m = null
-    try { m = await mirrorFor(this, this.defaultKey) } catch {}
-    if (!m || !(await ensureCommit(m.dir, up.sha, { token: m.token }))) return null
-    const out = new Map()
-    for (let i = 0; i < paths.length; i += 500) {
-      const r = await runGit(m.dir, ['log', '--format=', '--raw', '--no-abbrev', '--no-renames', '--root', '-m', up.sha, '--', ...paths.slice(i, i + 500)])
-      if (!r.ok) return null
-      for (const line of r.out.split('\n')) {
-        const x = /^:\d+ \d+ ([0-9a-f]{40,64}) ([0-9a-f]{40,64}) \w+\t(.+)$/.exec(line)
-        if (!x) continue
-        if (!out.has(x[3])) out.set(x[3], new Set())
-        out.get(x[3]).add(x[1]).add(x[2])
-      }
-    }
-    return out
-  }
-
   /**
    * One layout move of this room at a time, here and on every relay machine (a lease per room,
    * relay-lease.js). With `seam` (the owner's), what a move stopped part way left in Seam
@@ -2985,14 +2058,12 @@ class Room {
 
   /**
    * GitHub's rules for `branch` of `repo` (owner/name): an array, or null when GitHub could not be
-   * asked. Read with Quilt's GitHub App through a member's connection, else without a token (public).
+   * asked. Read without a token: Quilt no longer holds GitHub credentials, so a private repository's are not read (null).
    */
   async githubRulesOf (repo, branch) {
     if (this.githubRules) return this.githubRules(repo, branch)
-    const cred = await appCredentials(this, repo, { access: 'read' }).catch(() => ({}))
-    const f = this.githubFetch || globalThis.fetch
     try {
-      const res = await f(`https://api.github.com/repos/${repo}/rules/branches/${encodeURIComponent(branch)}`, { headers: { accept: 'application/vnd.github+json', 'user-agent': 'quilt-relay', ...(cred && cred.token ? { authorization: `Bearer ${cred.token}` } : {}) } })
+      const res = await globalThis.fetch(`https://api.github.com/repos/${repo}/rules/branches/${encodeURIComponent(branch)}`, { headers: { accept: 'application/vnd.github+json', 'user-agent': 'quilt-relay' } })
       if (!res.ok) return null
       const rules = await res.json()
       return Array.isArray(rules) ? rules : null
@@ -3020,13 +2091,8 @@ class Room {
         const e = this.store.load(key)
         return e ? branchFiles(e.doc, tree, { diff: isDiff(e), unheld: atTip.has(key) }) : {}
       }
-      // ...nor does a full document there carry the branch's older copies of main's files (git's history of main says which).
-      const mainsOld = async (key, files, head) => {
-        const e = this.store.load(key)
-        if (!atTip.has(key) || !e || isDiff(e)) return files
-        const history = await this.mainHistoryOf([...changedGitIds(files, head).keys()])
-        return history ? dropOldCopies(files, head, history) : files
-      }
+      // A full document's older copies of main's files were told apart by git's history of main, which the relay no longer keeps.
+      const mainsOld = async (key, files) => files
       // Members keep writing their branch documents until layout 3 is written: an edit from now on
       // (before its files are read, or after) marks its branch, so the copy is made again from what
       // it holds then and checked with no wait between (the catch-up below). Watched from before any
@@ -3699,8 +2765,7 @@ class Room {
   personCanAdmit (a) { return canAdmit(a, this.admitBy) }
 
   accessMessage (a) {
-    // The owner learns whether a GitHub token is set (never the token itself); nobody else hears of it.
-    return { state: 'approved', role: a.role, scopes: a.scopes || [], scopesExcept: a.scopesExcept || [], talk: a.talk !== false, owner: !!a.owner, controlled: this.controlled, admitBy: this.admitBy, canAdmit: this.personCanAdmit(a), agentCommits: agentCommitsOf(this), ...(this.meta.agentCommitsSet ? { agentCommitsBy: { by: this.meta.agentCommitsSet.by, name: this.meta.agentCommitsSet.name, mode: this.meta.agentCommitsSet.mode } } : {}), agentsCanCommit: agentsCanCommit(this, this.defaultKey), ...(this.cfg.gitSync ? { githubSync: this.meta.githubSync !== false, largeToRelay: this.meta.largeToRelay === true } : {}), ...(a.owner ? { githubToken: !!this.meta.githubToken } : {}) }
+    return { state: 'approved', role: a.role, scopes: a.scopes || [], scopesExcept: a.scopesExcept || [], talk: a.talk !== false, owner: !!a.owner, controlled: this.controlled, admitBy: this.admitBy, canAdmit: this.personCanAdmit(a) }
   }
 
   /** Tracks restricted connections so their file changes are checked. */
@@ -3708,8 +2773,7 @@ class Room {
     this.access.set(ws, a)
     // An agent with a webhook, here from a computer: the relay delivers for it in this session too.
     if (this.webhookApi && !ws.hosted && a && a.state !== 'pending') { try { this.webhookApi.joined(this, ws, a) } catch {} }
-    // With live sync to GitHub, agents' changes are checked too: a file held for a clash is theirs to propose, not to write (relay-clash.js).
-    const restricted = a.role === 'viewer' || (a.scopes && a.scopes.length) || (a.scopesExcept && a.scopesExcept.length) || a.talk === false || (a.kind === 'agent' && !!this.cfg.gitSync)
+    const restricted = a.role === 'viewer' || (a.scopes && a.scopes.length) || (a.scopesExcept && a.scopesExcept.length) || a.talk === false
     if (restricted) this.guard.trackedOrigins.add(ws)
     else this.guard.trackedOrigins.delete(ws)
   }
@@ -3767,33 +2831,6 @@ class Room {
       }
       return { ok: true }
     }
-    if (['syncUpstream', 'commit', 'gitToken', 'pulls', 'merge', 'githubRecheck', 'unpublished', 'finishTask'].includes(req.op)) throw new Error(`${req.op} is answered by itself`) // see the MSG_ADMIN handler
-    // A folder's git pushed: what went up goes on record, and the chat hears it (relay-commit.js).
-    if (req.op === 'pushed') {
-      if (!ws.branch) throw new Error('not in this session')
-      return notePushedFor(this, { who: { name: me.name, kind: me.kind === 'agent' ? 'agent' : 'human', access: me }, key: ws.branch, branch: String(req.branch || ''), sha: String(req.sha || ''), count: req.count, files: req.files, subject: typeof req.subject === 'string' ? req.subject : '' }, { fetch: this.githubFetch, log: this.log })
-    }
-    if (req.op === 'githubSync') {
-      // The owner's "Sync with GitHub" switch (plan §15): on by default once a connection covers the repository.
-      if (!me.owner) throw new Error('only the session owner can do that')
-      this.meta.githubSync = req.on !== false
-      this.saveMeta(); this.broadcastBranches()
-      for (const [cws, acc] of this.access) send(cws, jsonMessage(MSG_ACCESS, this.accessMessage(acc)))
-      return { ok: true, githubSync: this.meta.githubSync }
-    }
-    if (req.op === 'largeToRelay') {
-      // Large files on branches that sync with GitHub (plan §10): the owner agrees that the relay may read them, so it can commit them.
-      if (!me.owner) throw new Error('only the session owner can do that')
-      this.meta.largeToRelay = req.on === true
-      this.saveMeta(); this.broadcastBranches()
-      for (const [cws, acc] of this.access) send(cws, jsonMessage(MSG_ACCESS, this.accessMessage(acc)))
-      return { ok: true, largeToRelay: this.meta.largeToRelay }
-    }
-    if (req.op === 'agentCommits') {
-      // What agents may do with commits (relay-commit.js): the owner's call.
-      if (!me.owner) throw new Error('only the session owner can do that')
-      return { ok: true, agentCommits: this.setAgentCommits(req.agentCommits) }
-    }
     if (req.op === 'workspace') {
       // Which workspace the session is in (the owner's app knows): webhook events say so, so an agent in several can tell them apart.
       if (!me.owner) throw new Error('only the session owner can do that')
@@ -3801,8 +2838,6 @@ class Room {
       if ((this.meta.workspace || '') !== id) {
         this.meta.workspace = id || undefined
         this.saveMeta()
-        // The app links the session to the workspace on the accounts API first: its git rule applies now.
-        this.refreshPolicy()
       }
       return { ok: true, workspace: this.meta.workspace || '' }
     }
@@ -3843,12 +2878,6 @@ class Room {
       const l = extendChatLink(this, String(req.key || ''), req.minutes)
       return { ok: true, name: l.name, expiresAt: l.expiresAt }
     }
-    if (req.op === 'githubToken') {
-      // A read-only token the relay uses to bring commits in from a private repository while no
-      // folder is online (relay-upstream.js). Kept on the relay only: never in presence, the
-      // branch list, a reply or the log. An empty token clears it.
-      return this.setGithubToken(req.token)
-    }
     if (req.op === 'end') {
       // Reply first; the relay then sends everyone away and deletes the room.
       setTimeout(() => this.onEnd && this.onEnd(), 50)
@@ -3924,8 +2953,6 @@ class Room {
       const theirs = (x) => x.byId ? gone.includes(x.byId) : names.includes(x.by)
       this.dropRequests(theirs)
       this.dropClaims(theirs, (c) => `${c.by} was removed from the session.`)
-      for (const n of names) this.revokeAgentTokens({ name: n }) // a removed agent's folder can't push or fetch any more
-      for (const id of gone) this.revokeAgentTokens({ account: id }) // nor a removed person's
       for (const id of gone) delete this.meta.members[id]
       // A pass issued before now can't bring them back by its grant (see passGrant). Removals
       // older than a pass lasts can match no valid pass, so they go; the newest are kept.
@@ -4028,13 +3055,7 @@ class Room {
   branchPaths (branch) {
     const k = this.resolveKey(branch || this.defaultKey)
     const e = this.store.load(k)
-    // A diff branch's unchanged files are git's (branch-view.js): its tree at the base, once read (read now for next time).
-    let git = []
-    if (isDiff(e)) {
-      const tree = cachedTree(this, baseOf(this, k, e))
-      if (tree) git = [...tree.keys()].filter((rel) => !e.gone.has(rel)); else this.warmTree(k)
-    }
-    return [...git, ...e.files.keys(), ...e.blobs.keys(), ...this.doc.getMap('files').keys(), ...this.doc.getMap('blobs').keys()]
+    return [...e.files.keys(), ...e.blobs.keys(), ...this.doc.getMap('files').keys(), ...this.doc.getMap('blobs').keys()]
   }
 
   /** Who holds a claim: their account with sign-in on, otherwise their name. */
@@ -4391,8 +3412,6 @@ class Room {
       if (!prev && c.queue.length >= MAX_QUEUE) throw new Error(`${c.queue.length} are already waiting for ${c.pattern}`)
       const r = prev || { id: crypto.randomBytes(6).toString('hex'), by: name, ...(id ? { byId: id } : {}), ...(who.persona ? { of: who.of } : {}), ts: Date.now() }
       Object.assign(r, { path: file, title, description, ...(task ? { task } : {}) })
-      // Asked for by a clash task's assignee for the merge: let go of when the task is done (dropClashClaims).
-      if (typeof req.clash === 'string' && /^[0-9a-f]{16}$/.test(req.clash) && this.tasks.get(req.clash)?.assignee === name) r.clash = req.clash
       if (!prev) c.queue.push(r)
       this.postChat({ by: name, to: c.by, kind: 'queue', path: file, text: `📥 File queue · ${file}: ${`${title}${description ? ` — ${description}` : ''}`.replace(/[.!?]+$/, '')}. When you're done with it, hand it off to me with your context.` })
       return { ok: true, request: r.id, position: c.queue.indexOf(r) + 1, holder: c.by, pattern: c.pattern }
@@ -4761,75 +3780,11 @@ class Room {
         const claims = this.claimList(other.branch)
         send(other, jsonMessage(MSG_CLAIMS, other === ws ? { claims, reply } : { claims }))
       }
-      this.noteClaimsChanged()
     } else if (type === MSG_ADMIN) {
       let req = {}
       let reply
       try {
         req = JSON.parse(decoding.readVarString(dec))
-        // quilt_sync_branch from a folder that can't bring commits in itself (no git, or its fetch
-        // fails): any member let in may ask the relay to look at GitHub for its branch now.
-        if (req.op === 'syncUpstream') {
-          const id = req.id
-          if (!this.access.get(ws) || !ws.branch) throw new Error('not in this session')
-          this.syncUpstreamNow(ws.branch).then((sync) => ({ id, ok: true, sync }), (err) => ({ id, ok: false, error: err.message }))
-            .then((r) => { if (this.conns.has(ws)) send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: this.personCanAdmit(this.access.get(ws)) ? this.pendingList() : [], reply: r })) })
-          return
-        }
-        // A folder's git asking for a token for the session's repository (Quilt's credential helper, in
-        // agents' and people's folders): read to fetch or clone, write to push while git is on for everyone here.
-        if (req.op === 'gitToken') {
-          const id = req.id
-          const a = this.access.get(ws)
-          if (!a || !ws.branch) throw new Error('not in this session')
-          // In a session that is a quilt, an agent's git gets no GitHub token: it uses Seam (session-seam.js).
-          const onSeam = gitTokenRefusal(quiltOf(this.meta), a.kind === 'agent' ? 'agent' : 'human')
-          ;(onSeam ? Promise.reject(new Error(onSeam)) : this.gitTokenFor(ws.branch, { access: req.access === 'write' ? 'write' : 'read', who: { name: a.name, kind: a.kind === 'agent' ? 'agent' : 'human', id: a.id }, repo: typeof req.repo === 'string' ? req.repo : null }))
-            .then((git) => ({ id, ok: true, git }), (err) => ({ id, ok: false, error: err.message }))
-            .then((r) => { if (this.conns.has(ws)) send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: this.personCanAdmit(this.access.get(ws)) ? this.pendingList() : [], reply: r })) })
-          return
-        }
-        // Someone just connected GitHub (or asks whether it is): the connection is checked again now.
-        if (req.op === 'githubRecheck') {
-          const id = req.id
-          if (!this.access.get(ws) || !ws.branch) throw new Error('not in this session')
-          const key = this.resolveKey(ws.branch)
-          noteConnection(this, key, { force: true }).then((changed) => { if (changed) { this.saveMeta(); this.broadcastBranches() } return { id, ok: true, github: relayEntry(upstreamsOf(this)[key])?.github || null } }, (err) => ({ id, ok: false, error: err.message }))
-            .then((r) => { if (this.conns.has(ws)) send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: this.personCanAdmit(this.access.get(ws)) ? this.pendingList() : [], reply: r })) })
-          return
-        }
-        // Which of a member's files (or a task's) aren't in git on GitHub yet (relay-commit.js).
-        if (req.op === 'unpublished') {
-          const id = req.id
-          const a = this.access.get(ws)
-          if (!a || !ws.branch) throw new Error('not in this session')
-          unpublishedFor(this, { key: ws.branch, who: a.name, files: Array.isArray(req.files) ? req.files : null, task: typeof req.task === 'string' ? req.task : null, column: typeof req.column === 'string' ? req.column : '' }, { fetch: this.githubFetch })
-            .then((u) => ({ id, ok: true, unpublished: u }), (err) => ({ id, ok: false, error: err.message }))
-            .then((r) => { if (this.conns.has(ws)) send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: this.personCanAdmit(this.access.get(ws)) ? this.pendingList() : [], reply: r })) })
-          return
-        }
-        // The branch's pull requests, merging one, and a task moved to Done (which merges its pull request) (relay-commit.js).
-        if (req.op === 'pulls' || req.op === 'merge' || req.op === 'finishTask') {
-          const id = req.id
-          const a = this.access.get(ws)
-          if (!a || !ws.branch) throw new Error('not in this session')
-          const who = { name: a.name, kind: a.kind === 'agent' ? 'agent' : 'human', access: a }
-          const run = req.op === 'pulls' ? pullRequestsFor(this, { key: ws.branch }, { fetch: this.githubFetch }) : req.op === 'finishTask' ? finishTaskFor(this, { who, key: ws.branch, task: String(req.task || '') }, { fetch: this.githubFetch, log: this.log }) : mergeForMember(this, { who, key: ws.branch, number: req.number, branch: req.branch, method: req.method, deleteBranch: req.deleteBranch, force: req.force === true }, { fetch: this.githubFetch, log: this.log })
-          run.then((out) => ({ id, ok: true, [req.op]: out }), (err) => ({ id, ok: false, error: err.message }))
-            .then((r) => { if (this.conns.has(ws)) send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: this.personCanAdmit(this.access.get(ws)) ? this.pendingList() : [], reply: r })) })
-          return
-        }
-        // A person's folder hands its local commits to the relay (plan §6; relay-outbound.js replayBundle).
-        if (req.op === 'bundle') {
-          const id = req.id
-          const a = this.access.get(ws)
-          if (!a || (a.state && a.state !== 'approved') || !ws.branch) throw new Error('not in this session')
-          if (a.role === 'viewer' || a.kind === 'agent') throw new Error('only people\'s folders hand commits to the relay')
-          replayBundle(this, ws.branch, { who: { name: a.name, kind: 'human' }, bundle: String(req.bundle || ''), head: String(req.head || ''), ref: String(req.ref || '') })
-            .then((out) => ({ id, ok: true, bundle: out }), (err) => ({ id, ok: false, error: err.message }))
-            .then((r) => { if (this.conns.has(ws)) send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: this.personCanAdmit(this.access.get(ws)) ? this.pendingList() : [], reply: r })) })
-          return
-        }
         // Sent by apps before 0.3.99 for offline edits that clashed with the session's: Quilt merges those on its own now
         // (session.js autoSettle), so there is nothing to hold. Answered ok so an older app doesn't retry.
         if (req.op === 'offlineClash') {
@@ -4837,27 +3792,6 @@ class Room {
           if (this.conns.has(ws)) send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: this.personCanAdmit(this.access.get(ws)) ? this.pendingList() : [], reply: r }))
           return
         }
-        // A person adopts an agent's branch into theirs (addendum 16.7; relay-outbound.js adoptBranch).
-        if (req.op === 'adopt') {
-          const id = req.id
-          const a = this.access.get(ws)
-          if (!a || (a.state && a.state !== 'approved') || !ws.branch || a.role === 'viewer') throw new Error('not in this session')
-          if (!this.cfg.gitSync || !this.mirrors) throw new Error('This session doesn\'t sync live with GitHub.')
-          adoptBranch(this, ws.branch, { who: { name: a.name, kind: a.kind === 'agent' ? 'agent' : 'human' }, from: String(req.from || '') })
-            .then((out) => ({ id, ok: true, adopt: out }), (err) => ({ id, ok: false, error: err.message }))
-            .then((r) => { if (this.conns.has(ws)) send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: this.personCanAdmit(this.access.get(ws)) ? this.pendingList() : [], reply: r })) })
-          return
-        }
-        // quilt_clash from a folder's AI or app (relay-clash.js): the member's own name and kind.
-        if (req.op === 'clash') {
-          const id = req.id
-          const a = this.access.get(ws)
-          if (!a || (a.state && a.state !== 'approved') || !ws.branch) throw new Error('not in this session')
-          clashAction(this, { who: { name: a.name, kind: a.kind === 'agent' ? 'agent' : 'human', access: a }, key: ws.branch, action: String(req.action || ''), path: String(req.path || ''), content: typeof req.content === 'string' ? req.content : null, checks: req.checks && typeof req.checks === 'object' ? req.checks : null, force: req.force === true })
-            .then((out) => out.ok ? { id, ok: true, clash: out, text: out.text } : { id, ok: false, error: out.text }, (err) => ({ id, ok: false, error: err.message }))
-            .then((r) => { if (this.conns.has(ws)) send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: this.personCanAdmit(this.access.get(ws)) ? this.pendingList() : [], reply: r })) })
-          return
-        }
         // quilt_webhook_subscribe from a folder: the agent's one webhook, kept and delivered by the relay
         // (relay-webhooks.js), as for a hosted agent. The secret and bearer go in and never come back out.
         if (req.op === 'webhook') {
@@ -4877,16 +3811,6 @@ class Room {
           send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: [], reply: { id: req.id, ok: true } }))
           return
         }
-        // quilt_commit from a folder: the relay commits the session's copy of the files to GitHub (relay-commit.js).
-        if (req.op === 'commit') {
-          const id = req.id
-          const a = this.access.get(ws)
-          if (!a || !ws.branch) throw new Error('not in this session')
-          this.commitFor({ name: a.name, kind: a.kind === 'agent' ? 'agent' : 'human', access: a }, ws.branch, req)
-            .then((commit) => ({ id, ok: true, commit }), (err) => ({ id, ok: false, error: err.message }))
-            .then((r) => { if (this.conns.has(ws)) send(ws, jsonMessage(MSG_MEMBERS, { members: this.memberList(), sessionName: this.meta.name || '', admitBy: this.admitBy, pending: this.personCanAdmit(this.access.get(ws)) ? this.pendingList() : [], reply: r })) })
-          return
-        }
         reply = { id: req.id, ...this.adminRequest(ws, req) }
       } catch (err) {
         reply = { id: req.id, ok: false, error: err.message }
@@ -4902,8 +3826,6 @@ class Room {
   destroy () {
     this.destroyed = true
     clearTimeout(this.unloadTimer)
-    clearTimeout(this.upstreamSoonTimer)
-    clearTimeout(this.upstreamAgainTimer)
     this.save()
     this.store.destroy()
     this.guard.destroy()
@@ -4991,21 +3913,13 @@ function closeSoon (ws, code, reason, ms = 2000) {
   ws.once('close', () => clearTimeout(t))
 }
 
-/** Whether anyone (a folder, a connected app or CLI, a hosted agent) is on branch `key` now. */
-function relayLooksActive (room, key) { return folderOn(room, key) || connectedOn(room, key) || hostedOn(room, key).length > 0 }
-
 export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, log = console.log, presenceOptions = {}, ...opts } = {}) {
   const cfg = relayConfig(opts)
   // Many machines (relay-cluster.js): each room on one of them, the accounts API says which.
   const cc = clusterConfig(opts)
-  configureGithubBudget({ anonPerHour: cfg.githubAnonPerHour })
   const passKey = cfg.passPublicKey ? parsePublicKey(cfg.passPublicKey) : null
   if (cfg.passPublicKey && !passKey) throw new Error('QUILT_PASS_PUBLIC_KEY is not an Ed25519 public key (spki, base64url)')
   /** With sign-in on: the request's valid pass, or null. With it off: an empty pass. */
-  // The relay's own key for large files on branches that sync with GitHub (relay-filekey.js).
-  const relayFileKeyPair = cfg.gitSync ? relayFileKey(dataDir, { pem: opts.relayFileKey ?? process.env.QUILT_RELAY_FILE_KEY ?? '', log }) : null
-  // Git's hooks on this machine ask the relay with this (relay-githttp.js): a secret of this process.
-  const hookToken = crypto.randomBytes(24).toString('base64url')
   const httpPass = (req, room = '') => {
     if (!passKey) return {}
     const p = verifyPass(String(req.headers['x-quilt-pass'] || ''), passKey)
@@ -5017,20 +3931,13 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
   // Without sign-in the limit is per address, and the message says so (as before).
   const TOO_MANY = passKey ? 'too many new sessions; try again later' : 'too many new sessions from this address; try again later'
   if (dataDir) fs.mkdirSync(dataDir, { recursive: true })
-  // Without git http-backend every agent's git request would fail with a 500: agents' folders use GitHub's git instead.
-  if (cfg.gitSync && cfg.gitHttp && passKey && !gitHttpBackendWorks(cfg.gitHttpCommand)) {
-    cfg.gitHttp = false
-    log('⚠️ this machine\'s git has no http-backend (on Alpine it comes with git-daemon): agents\' folders can\'t use git through the relay, so they use GitHub\'s')
-  }
-  // The relay's git mirrors (relay-git.js): one bare repository per GitHub repository, one writer per branch.
-  const mirrors = mirrorManager({ dataDir, log, ...(cfg.pushGapMs !== undefined ? { pushGapMs: cfg.pushGapMs } : {}), ...(cfg.pushesPerHour !== undefined ? { pushesPerHour: cfg.pushesPerHour } : {}) })
-  // One live session per repository and branch (relay-lease.js): in the accounts API when this relay has one, else in this process.
+  // The relay's leases (relay-lease.js: one layout move per room): in the accounts API when this relay has one, else in this process.
   const leases = leaseKeeper({ apiUrl: cfg.apiUrl, secret: cfg.relayApiSecret, fetch: opts.apiFetch || globalThis.fetch, dataDir, log, ...(cfg.leaseTtlMs ? { ttlMs: cfg.leaseTtlMs } : {}), ...(cfg.leaseMarginMs !== undefined ? { marginMs: cfg.leaseMarginMs } : {}), holder: `relay:${cc.machineId || os.hostname()}:${process.pid}`.slice(0, 100) })
   // Whether the accounts API has workspaces on, for hosted agents' library tools: asked in
   // the background (never holding up the start) and again every 10 minutes.
   const apiFetch = opts.apiFetch || globalThis.fetch
   {
-    const problems = clusterProblems(cc, cfg, { fileKey: relayFileKeyPair && relayFileKeyPair.shared ? 'shared' : '' })
+    const problems = clusterProblems(cc, cfg)
     if (problems.length) throw new Error(`QUILT_CLUSTER is on, but the relay is missing ${problems.join(', ')}`)
   }
   const cluster = cc.on ? new Cluster({ cc, apiUrl: cfg.apiUrl, secret: cfg.relayApiSecret, fetch: apiFetch, log, dataDir }) : null
@@ -5080,8 +3987,6 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
     presence.start()
   }
   const rooms = new Map() // loaded rooms only
-  // Repositories renamed or moved on GitHub (relay-repo-moves.js): every session following one follows its new name.
-  const repoMoveLog = repoMoves({ dataDir })
   const ipConns = new Map()
   // New sessions are rate-limited per account when sign-in is on, otherwise per address.
   const newRooms = new Map() // starter -> creation timestamps in the last hour
@@ -5123,20 +4028,12 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
       if (tooBigToLoad(name)) return null
       try {
         room = new Room(name, dataDir, cfg, log)
-        // Renamed or moved on GitHub while this session wasn't open: its branches follow the new name now.
-        room.repoMoves = repoMoveLog
-        for (const [, rec] of Object.entries(room.meta.upstreams || {})) {
-          if (rec && typeof rec.repo === 'string' && repoMoveLog.resolve(rec.repo) !== rec.repo) applyRepoMove(room, rec.repo, repoMoveLog.resolve(rec.repo))
-        }
-        room.mirrors = mirrors
         room.leases = leases
         room.cluster = cluster
         room.dataDirOf = dataDir
-        room.relayFileKey = relayFileKeyPair // large files on synced branches, once the owner agrees (plan §10)
         room.blobStore = store
-        room.apiFetch = apiFetch // the API: credentials for agents' commits (relay-commit.js)
+        room.apiFetch = apiFetch
         room.agentWakes = agentWakes // how each agent wakes, from the API (plans/agent-wake.md)
-        room.refreshPolicy() // what agents may commit, when its org or workspace says
       } catch (err) {
         if (!err.unreadable) throw err
         // Logged once, not on every retry; tried again each time, in case the operator repaired it.
@@ -5150,7 +4047,6 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
       if (cloudAis) { room.cloudAiWaker = cloudAis; cloudAis.watch(room) } // people's cloud AIs are woken from it
       if (adoptHosted) adoptHosted(room)
       room.presence = presence
-      if (opts.githubFetch) room.githubFetch = opts.githubFetch
       // Idle rooms are saved and dropped from memory (only when they're on disk).
       room.onEmpty = () => {
         if (!dataDir || rooms.get(name) !== room) return
@@ -5418,18 +4314,7 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
     return n
   }
   /** How busy and how big a loaded room is (relay-metrics.js): for /stats and the accounts API's placement. */
-  // Git pushes into a room's view (/git/<room>.git) being received now.
-  const gitPushes = new Map() // room -> count
-  /** Git work running or queued for a room now: pushes being received, and commits, pushes and bring-ins on its branches (relay-git.js). */
-  const gitBusy = (room) => {
-    let n = gitPushes.get(room.name) || 0
-    for (const rec of Object.values((room.meta && room.meta.upstreams) || {})) {
-      const repo = rec && rec.repo && rec.ref ? parseRepo(`https://${rec.repo}`) : null
-      if (repo) n += mirrors.queue.pending(repo.slug, rec.ref)
-    }
-    return n
-  }
-  const roomStats = (room) => ({ room: room.name, conns: room.conns.size, hosted: room.hostedSeen.size, ...room.meter.lastMinute(), docBytes: room.totalBytes(), diskBytes: diskOf(room.name), git: gitBusy(room) })
+  const roomStats = (room) => ({ room: room.name, conns: room.conns.size, hosted: room.hostedSeen.size, ...room.meter.lastMinute(), docBytes: room.totalBytes(), diskBytes: diskOf(room.name) })
   // The machine's own load (memory, event-loop lag, CPU), a minute at a time: for scaling the cluster on load.
   const machineMeter = new MachineMeter()
   /** The machine: rooms loaded, connections, memory, lag, CPU and every room's traffic (`list`: the rooms' stats, when already made). */
@@ -5468,7 +4353,6 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
     unloadForMove(name)
     leases.forget(name)
     removeLocalRoom(dataDir, name)
-    fs.rmSync(viewDir(dataDir, name), { recursive: true, force: true })
     for (const h of hosted.values()) if (hostedIn(h, name)) delete h.rooms[name]
     saveHosted()
     cluster.forget(name, to)
@@ -5574,88 +4458,6 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
       if (!fromApi(req)) return json(401, { error: 'only the accounts API may ask this' })
       return json(200, stats())
     }
-    // GitHub said a branch moved (the API checked GitHub's signature; src/api/routes/github.js). Each
-    // session following that branch looks now: its folders fetch at once, and the relay brings the
-    // commits in itself where no folder can. Only a hint: everyone reads the truth from git.
-    if (url.pathname === '/github/push' && req.method === 'POST') {
-      const auth = String(req.headers.authorization || '').replace(/^Bearer\s+/i, '')
-      const want = cfg.relayApiSecret || ''
-      const same = want && auth.length === want.length && crypto.timingSafeEqual(Buffer.from(auth), Buffer.from(want))
-      if (!same) return json(401, { error: 'only the accounts API may say this' })
-      return readJson(req, 16 * 1024, (err, b) => {
-        if (err || !b || typeof b.repo !== 'string' || typeof b.ref !== 'string') return json(400, { error: 'give repo and ref' })
-        let told = 0
-        for (const room of rooms.values()) if (room.notePush && room.notePush({ repo: b.repo, ref: b.ref, sha: typeof b.sha === 'string' ? b.sha : '', after: typeof b.after === 'string' ? b.after : '', before: typeof b.before === 'string' ? b.before : '', forced: b.forced === true, deleted: b.deleted === true, created: b.created === true })) told++
-        json(200, { ok: true, rooms: told })
-      })
-    }
-    // GitHub says a repository was renamed or moved to another owner (the API relays the webhook): it is
-    // remembered, so sessions not open now follow the new name when they load, and every open session
-    // following it follows it now: the new name in its branch list (members' folders repoint origin), and
-    // its GitHub connection asked about again.
-    if (url.pathname === '/github/moved' && req.method === 'POST') {
-      const auth = String(req.headers.authorization || '').replace(/^Bearer\s+/i, '')
-      const want = cfg.relayApiSecret || ''
-      const same = want && auth.length === want.length && crypto.timingSafeEqual(Buffer.from(auth), Buffer.from(want))
-      if (!same) return json(401, { error: 'only the accounts API may say this' })
-      return readJson(req, 16 * 1024, (err, b) => {
-        if (err || !b || typeof b.repo !== 'string' || typeof b.to !== 'string') return json(400, { error: 'give repo and to' })
-        if (!repoMoveLog.record(b.repo, b.to)) return json(400, { error: 'repo and to must be two GitHub repositories' })
-        let told = 0
-        for (const room of rooms.values()) {
-          const keys = applyRepoMove(room, b.repo, b.to)
-          if (!keys.length) continue
-          told++
-          log(`[${room.name}] ${keys.join(', ')}: GitHub says ${b.repo} is ${b.to} now; the session follows it`)
-          room.saveMeta(); room.broadcastBranches(); room.noteConnections({ keys, force: true })
-        }
-        json(200, { ok: true, rooms: told })
-      })
-    }
-    // A check suite finished on GitHub (the API relays the webhook): every session following that repository looks at the pull requests its tasks are in.
-    if (url.pathname === '/github/checks' && req.method === 'POST') {
-      const auth = String(req.headers.authorization || '').replace(/^Bearer\s+/i, '')
-      const want = cfg.relayApiSecret || ''
-      const same = want && auth.length === want.length && crypto.timingSafeEqual(Buffer.from(auth), Buffer.from(want))
-      if (!same) return json(401, { error: 'only the accounts API may say this' })
-      return readJson(req, 16 * 1024, (err, b) => {
-        if (err || !b || typeof b.repo !== 'string') return json(400, { error: 'give repo' })
-        let told = 0
-        for (const room of rooms.values()) if (room.noteChecks && room.noteChecks({ repo: b.repo, sha: typeof b.sha === 'string' ? b.sha : '', branch: typeof b.branch === 'string' ? b.branch : '', conclusion: typeof b.conclusion === 'string' ? b.conclusion : '' })) told++
-        json(200, { ok: true, rooms: told })
-      })
-    }
-    // A pull request changed on GitHub (the API relays the webhook): every session following that repository looks at the pull requests its tasks are in now.
-    if (url.pathname === '/github/pull' && req.method === 'POST') {
-      const auth = String(req.headers.authorization || '').replace(/^Bearer\s+/i, '')
-      const want = cfg.relayApiSecret || ''
-      const same = want && auth.length === want.length && crypto.timingSafeEqual(Buffer.from(auth), Buffer.from(want))
-      if (!same) return json(401, { error: 'only the accounts API may say this' })
-      return readJson(req, 16 * 1024, (err, b) => {
-        if (err || !b || typeof b.repo !== 'string' || !Number.isInteger(b.number)) return json(400, { error: 'give repo and number' })
-        let told = 0
-        for (const room of rooms.values()) if (room.notePull && room.notePull({ repo: b.repo, number: b.number, action: typeof b.action === 'string' ? b.action : '', merged: b.merged === true, head: typeof b.head === 'string' ? b.head : '', base: typeof b.base === 'string' ? b.base : '', sha: typeof b.sha === 'string' ? b.sha : '' })) told++
-        json(200, { ok: true, rooms: told })
-      })
-    }
-    // An org or workspace changed what agents may commit (the accounts API): every open session asks again now.
-    // With { room }, only that session (one just put in or taken out of a workspace), if this machine holds it.
-    if (url.pathname === '/github/policy' && req.method === 'POST') {
-      const auth = String(req.headers.authorization || '').replace(/^Bearer\s+/i, '')
-      const want = cfg.relayApiSecret || ''
-      const same = want && auth.length === want.length && crypto.timingSafeEqual(Buffer.from(auth), Buffer.from(want))
-      if (!same) return json(401, { error: 'only the accounts API may say this' })
-      return readJson(req, 4 * 1024, (err, b) => {
-        const one = !err && b && typeof b.room === 'string' && b.room ? b.room : ''
-        if (one) {
-          const room = ROOM_RE.test(one) ? rooms.get(one) : null
-          if (room) room.refreshPolicy()
-          return json(200, { ok: true, rooms: room ? 1 : 0 })
-        }
-        for (const room of rooms.values()) room.refreshPolicy()
-        json(200, { ok: true, rooms: rooms.size })
-      })
-    }
     // Mail came to a session's address (the accounts API, routes/mail.js): a line in its chat, which
     // wakes the session's email agents (inbox.js). Only the machine holding the session writes it.
     if (url.pathname === '/mail/arrived' && req.method === 'POST') {
@@ -5694,22 +4496,6 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
         json(200, { sessions })
       })
     }
-    // Someone connected GitHub (the API's callback): every session they are in checks its repository again now.
-    if (url.pathname === '/github/connected' && req.method === 'POST') {
-      const auth = String(req.headers.authorization || '').replace(/^Bearer\s+/i, '')
-      const want = cfg.relayApiSecret || ''
-      const same = want && auth.length === want.length && crypto.timingSafeEqual(Buffer.from(auth), Buffer.from(want))
-      if (!same) return json(401, { error: 'only the accounts API may say this' })
-      return readJson(req, 4 * 1024, (err, b) => {
-        if (err || !b || !/^person:[A-Za-z0-9_-]{1,64}$/.test(String(b.account || ''))) return json(400, { error: 'give the account' })
-        let n = 0
-        for (const room of rooms.values()) {
-          if (!room.meta || (room.meta.ownerSub !== b.account && !(room.meta.members && room.meta.members[b.account]))) continue
-          room.noteConnections({ force: true }); n++
-        }
-        json(200, { ok: true, rooms: n })
-      })
-    }
     // Making a session a quilt from the accounts API (POST /v1/sessions/:room/migrate, which checked the
     // owner's sign-in): { room, account, dry_run } plans it; { room, account, token } makes it, as the
     // owner, with their Seam sign-in. The room's own owner check still applies (Room.quiltPlan).
@@ -5771,10 +4557,6 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
       return readJson(req, 4096, (err, b) => {
         if (err) return json(400, { error: err.message })
         if (action === 'release') {
-          // Never mid git push or commit: the API tries again later (or another room).
-          const loaded = rooms.get(name)
-          const busy = loaded ? gitBusy(loaded) : gitPushes.get(name) || 0
-          if (busy) return json(409, { error: `${name} has git work running (${busy}); try again later` })
           letRoomGo(name)
           return json(200, { ok: true })
         }
@@ -5832,63 +4614,6 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
         res.end(JSON.stringify({ ok: true, aiSeenAt: prev.aiSeenAt || 0 }))
       })
     }
-    // Agents' folders use git through the relay (relay-githttp.js, plan §9): clone, fetch and push a session's
-    // branches at /git/<room>.git, signed in with the member's Quilt pass (git's password; quilt git-credential).
-    const gm = url.pathname.match(/^\/git\/([A-Za-z0-9_-]{1,64})\.git(\/info\/refs|\/git-upload-pack|\/git-receive-pack)$/)
-    if (gm) {
-      if (!cfg.gitSync || !cfg.gitHttp || !passKey || !dataDir) return text(404, 'this relay serves no git')
-      const name = gm[1]
-      const basic = /^Basic\s+([A-Za-z0-9+/=]+)$/i.exec(String(req.headers.authorization || ''))
-      const decoded = basic ? Buffer.from(basic[1], 'base64').toString('utf8') : ''
-      const pass = decoded ? verifyPass(decoded.slice(decoded.indexOf(':') + 1), passKey) : null
-      if (!pass || (pass.room && pass.room !== name)) { res.writeHead(401, { 'www-authenticate': 'Basic realm="Quilt"', 'content-type': 'text/plain' }); return res.end('Sign in with your Quilt pass: git asks Quilt for it (quilt git-credential).\n') }
-      const room = rooms.get(name) || getRoom(name)
-      if (!room || !room.exists || room.ended) return text(404, 'no such session')
-      if (!room.letIn(pass)) return text(403, NOT_LET_IN)
-      const service = gm[2] === '/info/refs' ? url.searchParams.get('service') : gm[2].slice(1)
-      if (service === 'git-receive-pack') { const a = room.httpAccess(pass); if (a && a.role === 'viewer') return text(403, 'you can only view this session, so you can\'t push') }
-      if (gm[2] === '/git-receive-pack') {
-        // A push being received: the room is not moved to another machine until it is done.
-        gitPushes.set(name, (gitPushes.get(name) || 0) + 1)
-        res.once('close', () => { const n = (gitPushes.get(name) || 1) - 1; if (n > 0) gitPushes.set(name, n); else gitPushes.delete(name) })
-      }
-      const def = viewRepoOf(room)
-      if (!def) { log(`[${name}] git over http: no GitHub repository (default ${room.defaultKey}: ${JSON.stringify(upstreamsOf(room)[room.defaultKey] || null)})`); return text(404, 'this session follows no GitHub repository') }
-      const repo = parseRepo(`https://${def.repo}`)
-      ;(async () => {
-        const m = await room.mirrors.ensure(repo, { url: room.gitRemoteUrl(repo) })
-        if (!(await runGit(m.dir, ['rev-parse', '--verify', '-q', `refs/remotes/origin/${def.ref}`])).out.trim()) await room.mirrors.fetch(m.dir, def.ref, { token: await room.gitToken(repo, { access: 'read' }) }).catch(() => {})
-        const dir = await ensureView(dataDir, name, m.dir)
-        await syncViewRefs(room, dir, def.repo)
-        serveGit(req, res, { root: path.dirname(dir), pathInfo: `/${name}.git${gm[2]}`, query: url.search.slice(1), env: { QUILT_HOOK_URL: `http://127.0.0.1:${httpServer.address().port}/git-hook`, QUILT_HOOK_TOKEN: hookToken, QUILT_ROOM: name, QUILT_WHO: `${pass.kind}:${pass.sub}`, QUILT_WHO_NAME: String(pass.name || '') }, git: cfg.gitHttpCommand, onError: (why) => log(`[${name}] git over http (${req.method} ${gm[2]}): ${why}`) })
-      })().catch((err) => { log(`[${name}] git over http: ${err.message}`); if (!res.headersSent) text(500, 'the relay could not serve git right now') })
-      return
-    }
-    // A push into a session's git view asks here, from git's hook on this machine (relay-githttp.js, git-hook.js).
-    if (url.pathname === '/git-hook' && req.method === 'POST') {
-      const auth = String(req.headers.authorization || '').replace(/^Bearer\s+/i, '')
-      if (auth.length !== hookToken.length || !crypto.timingSafeEqual(Buffer.from(auth), Buffer.from(hookToken))) return json(401, { ok: false, message: 'Quilt: not this relay\'s push' })
-      return readJson(req, 1024 * 1024, async (err, b) => {
-        try {
-          if (err || !b || typeof b.room !== 'string') return json(400, { ok: false, message: 'Quilt: a malformed push' })
-          const room = rooms.get(b.room) || getRoom(b.room)
-          if (!room || !room.exists) return json(404, { ok: false, message: 'Quilt: no such session' })
-          const updates = parseUpdates(b.updates)
-          if (b.phase === 'post') {
-            // The view's branches go back to what GitHub has (the push may have been replayed onto a newer head).
-            const published = (room.viewPublished && room.viewPublished.get(String(b.who))) || new Map()
-            const dir = viewDir(dataDir, b.room)
-            for (const u of updates) { const sha = published.get(u.ref); if (sha) await runGit(dir, ['update-ref', u.ref, sha]) }
-            const def = viewRepoOf(room)
-            if (def) await syncViewRefs(room, dir, def.repo)
-            return json(200, { ok: true })
-          }
-          const r = await receiveAgentPush(room, { who: String(b.who || ''), name: String(b.name || ''), updates, env: b.env || {} }, { log })
-          if (r.ok) { if (!room.viewPublished) room.viewPublished = new Map(); room.viewPublished.set(String(b.who), r.published) }
-          return json(200, { ok: r.ok, message: r.message })
-        } catch (e) { log(`[${b && b.room}] git push: ${e.message}`); return json(500, { ok: false, message: `Quilt: the relay couldn't take the push (${e.message})` }) }
-      })
-    }
     if (url.pathname === '/mcp') {
       // Hosted agents (and anyone with a pass): session tools over HTTP, no app needed.
       if (!passKey) return text(404, 'this relay has sign-in off; hosted agents need it on')
@@ -6157,13 +4882,12 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
       ws.isAlive = false
       ws.ping()
     }
-    for (const room of rooms.values()) if (!room.ended) { room.sweepClaims(); room.sweepBoxes(); room.trimMergedBranches(); room.pruneBranches(); room.findMergedBranches().catch(() => {}) }
+    for (const room of rooms.values()) if (!room.ended) { room.sweepClaims(); room.sweepBoxes(); room.pruneBranches() }
     if (sweepHosted) sweepHosted()
   }, 30000)
 
   // Delete rooms nobody has opened for a while (hosted relays shouldn't grow forever).
   const sweep = () => {
-    mirrors.prune()
     if (!dataDir || !cfg.roomTtlDays) return
     const cutoff = Date.now() - cfg.roomTtlDays * DAY
     let removed = 0
@@ -6191,33 +4915,16 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
   sweep()
   const sweeper = setInterval(sweep, 6 * 60 * 60 * 1000)
   sweeper.unref()
-  // Branches only hosted agents work on, with no folder online: the relay looks for new commits on GitHub itself.
-  const upstreamTicker = cfg.upstreamAuto && cfg.upstreamCheckMs > 0
-    ? setInterval(() => { for (const room of rooms.values()) if (!room.ended) { room.checkUpstreams().catch((err) => log(`[${room.name}] could not look for new commits: ${err.message}`)) } }, Math.min(cfg.gitSync ? 20 * 1000 : 60 * 1000, cfg.upstreamCheckMs)) // with the mirror, often enough that each branch's minute look isn't a tick late
-    : null
-  upstreamTicker?.unref()
-  // Live-sync leases renewed, and let go of for sessions that ended or sat idle for a day (relay-lease.js).
-  const leaseTicker = cfg.gitSync ? setInterval(() => {
+  // The relay's leases renewed, and let go of for sessions that ended (relay-lease.js).
+  const leaseTicker = setInterval(() => {
     // A migration's lease (Room.withMigrationLease) is let go of once no migration here holds it (after a crash, at the next tick).
     leases.tick({ ended: (name) => { if (name.startsWith(MIGRATION_LEASE)) return !migrating.has(name); const r = rooms.get(name); return !!(r && r.ended) } }).then((lost) => {
       for (const l of lost) { const r = rooms.get(l.room); if (r && !r.ended) { r.log(`[${r.name}] lost the live-sync lease of ${l.branch} to ${l.to || 'nobody (lapsed)'}`); r.broadcastBranches() } }
     }).catch((err) => log(`lease tick: ${err.message}`))
-  }, cfg.leaseHeartbeatMs || LEASE_HEARTBEAT_MS) : null
-  leaseTicker?.unref()
-  // Agents with work not in git on GitHub are reminded to commit it (relay-commit.js), about every ten minutes.
-  const remindTicker = cfg.upstreamAuto
-    ? setInterval(() => {
-      for (const room of rooms.values()) {
-        if (room.ended) continue
-        for (const key of new Set([...Object.keys(upstreamsOf(room)), ...Object.keys(room.meta.branches || {})].map((k) => room.resolveKey(k)))) remindUnpublished(room, key, { fetch: room.githubFetch }).catch((err) => log(`[${room.name}] ${key}: could not remind about uncommitted work: ${err.message}`))
-        reviewPulls(room, { fetch: room.githubFetch, log }).catch((err) => log(`[${room.name}] could not look at the tasks' pull requests: ${err.message}`))
-      }
-    }, 10 * 60 * 1000)
-    : null
-  remindTicker?.unref()
-
+  }, cfg.leaseHeartbeatMs || LEASE_HEARTBEAT_MS)
+  leaseTicker.unref()
   return new Promise((resolve, reject) => {
-    httpServer.once('error', (err) => { clearInterval(heartbeat); clearInterval(sweeper); clearInterval(upstreamTicker); clearInterval(remindTicker); features?.stop(); reject(err) })
+    httpServer.once('error', (err) => { clearInterval(heartbeat); clearInterval(sweeper); clearInterval(leaseTicker); features?.stop(); reject(err) })
     httpServer.listen(port, host, () => {
       const actualPort = httpServer.address().port
       resolve({
@@ -6228,13 +4935,10 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
         store, // exposed for tests
         presence, // exposed for tests
         hosted, // exposed for tests
-        mirrors, // the git mirrors (exposed for tests)
         leases, // the live-sync leases (exposed for tests)
         sweepHosted: () => sweepHosted && sweepHosted(), // exposed for tests: ends quiet hosted agents' visits now
         features, // exposed for tests
         sweep,
-        // exposed for tests: the relay's look at GitHub for a loaded room now ({ force }: every branch it looks after, not only those due)
-        checkUpstreams: (name, o) => { const room = rooms.get(name); return room ? room.checkUpstreams(o) : Promise.resolve([]) },
         cluster, // exposed for tests
         close: async () => {
           clearInterval(reportTicker)
@@ -6244,8 +4948,6 @@ export function startServer ({ port = 4321, host = '0.0.0.0', dataDir = null, lo
           clearInterval(leaseTicker)
           clearInterval(heartbeat)
           clearInterval(sweeper)
-          clearInterval(upstreamTicker)
-          clearInterval(remindTicker)
           features?.stop()
           updates.stop()
           // A join or a denial in the last moments before a deploy is kept.