heyquilt 0.3.121 → 0.3.138

package/src/session.js

@@ -2,6 +2,11 @@
 // back. Any tool that edits files on disk (Claude Code, Cursor, Codex, vim...)
 // participates automatically; concurrent edits are merged character by
 // character by the CRDT.
+import { describeQuiltPlan } from './session-quilt.js'
+import { SquareFollower, relayReader, gitAsideOf, setGitAside, putGitBack, unsentPaths, GIT_ASIDE, squareFor } from './session-follow.js'
+import { appSeamUrl } from './seam-url.js'
+import { pushRefusal } from './session-seam.js'
+import { quiltClient } from '@heyquilt/seam/lib/quilts/client.js'
 import fs from 'node:fs'
 import path from 'node:path'
 import crypto from 'node:crypto'
@@ -10,7 +15,7 @@ import { execFile, execFileSync } from 'node:child_process'
 import { EventEmitter } from 'node:events'
 import * as Y from 'yjs'
 import { watch } from 'chokidar'
-import { Connection, PUSH_REQUEST_TIMEOUT_MS } from './connection.js'
+import { Connection, PUSH_REQUEST_TIMEOUT_MS, QUILT_MOVE_TIMEOUT_MS } from './connection.js'
 import { loadIdentity } from './identity.js'
 import { writePrivateJson } from './private-file.js'
 import { MAX_SHARED_FILE_BYTES, FEATURES } from './protocol.js'
@@ -25,7 +30,12 @@ import { migrateDir } from './legacy.js'
 import { withComments, addComment as putComment } from './task-comments.js'
 import { readTasks, addTask as putTask, updateTask as patchTask, deleteTask as dropTask, planAutoTask, nextTask, pickupMode, columnName } from './tasks.js'
 import { getSettings } from './settings.js'
-import { HistoryLog, queryHistory, parseSince, currentTask, blameChange, lineDiff } from './history.js'
+import { HistoryLog, queryHistory, parseSince, currentTask, blameChange, lineDiff, legacyTail } from './history.js'
+import { linkedHistory, mergeLinked } from './quilt-history.js'
+import { readAccount } from './account.js'
+import { seamAccess, sessionCredential, isAgentKey } from './seam-access.js'
+import { startAsQuilt } from './quilt-default.js'
+import { releaseInSeam } from './seam-claims.js'
 import { historyMarks, awayChanges, mergeCatchUp, emptyCatchUp } from './catchup.js'
 import { Inbox, mentionsMe, describeEvent } from './inbox.js'
 import { projectRules, renderRules, gatherPlan, planKey } from './project-rules.js'
@@ -46,7 +56,7 @@ import { merge3, mergeAuto, hasMarkers } from './merge3.js'
 import { sameEditClient, asClient } from './same-edit.js'
 import { openMerge, updateMerge, readMerges, pruneMerges, cleanName } from './merges.js'
 import { ensureQuiltIgnored } from './gitignore.js'
-import { urlOrigin, gitDir, headKey, headRef, gitRuns, askTwice, lastCallTimedOut, busy as gitBusy, leftoverLock, STALE_LOCK_MS, indexStamp, classify, filesAt, changesBetween, commitsBetween, treeState, branchTip, watchGit, unmergedPaths, stashStamp, upstreamAdds, pullState, SETTLE_MS, BURST_PATHS, upstreamOf, fetchUpstream, isAncestor, stagedAgainst, fastForward, resetIndex, blobAt, committedAs, hasFilesUnder, repoBranches, remoteHost, backWithGit, installGitHelpers, setPersonGit, hasCommit, pushLocal, bundleOf, adoptPublished, fetchSignedIn, movedRemoteUrl, commitTimes, pushedBase, changedSince } from './gitstate.js'
+import { urlOrigin, gitDir, headKey, headRef, gitRuns, askTwice, lastCallTimedOut, busy as gitBusy, leftoverLock, STALE_LOCK_MS, indexStamp, classify, filesAt, changesBetween, commitsBetween, treeState, branchTip, watchGit, unmergedPaths, stashStamp, upstreamAdds, pullState, SETTLE_MS, BURST_PATHS, upstreamOf, fetchUpstream, isAncestor, stagedAgainst, fastForward, resetIndex, blobAt, committedAs, hasFilesUnder, repoBranches, remoteHost, backWithGit, installGitHelpers, setPersonGit, hasCommit, pushLocal, bundleOf, adoptPublished, fetchSignedIn, movedRemoteUrl, commitTimes, pushedBase, changedSince, ownSinceFork, linksAt } from './gitstate.js'
 import { planCatchUp, catchUpAdvice, publishedOf, notePublished } from './upstream.js'
 import { agentPrefix, noreply, slug, gitForEveryoneWords } from './github-commit.js'
 import { parseRepo, upstreamRef } from './relay-upstream.js'
@@ -57,13 +67,12 @@ import { cleanTyping, TYPING_MS, AGENT_TYPING_MS } from './ui/chat.js'
 import { DEFAULT_KEY } from './branchdocs.js'
 import { boxEntry } from './boxes.js'
 import { cleanVoice, newCallId, voiceView, inVoice, transcribeSetting, setTranscribe, addLine, readLines, MAX_IN_CALL, CALL_FULL } from './voice.js'
-import { toolLabel } from './agents/common.js'
+import { toolInUse } from './agents/common.js'
+import { squareShort } from '@heyquilt/seam/lib/quilts/errors.js'
 
 export { applyTextDiff }
 
 const LOCAL = Symbol('local')
-// The tools a person can be shown as using (a guessed one gives way to the AI that connects).
-const KNOWN_TOOLS = new Set(['Claude Code', 'Cursor', 'Codex', 'xAI', 'Windsurf', 'Zed'])
 const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904' // git's empty tree, the base of a branch pushed from nothing
 
 /**
@@ -80,6 +89,8 @@ function defaultCli () {
 const CLASH = Symbol('clash') // clash tasks this Quilt writes (quiet for its own inbox until settleClash)
 const CLASH_REASSIGN_MS = 5 * 60 * 1000 // a clash task's assignee gone this long: the next member takes it
 const CLASH_WAIT_MS = 30 * 1000 // no clash task from the first in line this long: the next one writes it
+const FILE_LOG_MS = 30 * 1000 // a file's History in the app reads the quilt's log at most this often (fileHistory)
+const HISTORY_SEAM_OFF_MS = 60 * 1000 // quilt_history reads through the relay this long after Seam would not let this member in
 const CLASH_IDLE_MS = 15 * 60 * 1000 // a clash assignee with no progress this long is handed on
 const CLASH_SETTLE_MS = 2000 // a clash task this member wrote is told to its AI after this long, if it survived a race
 const CLASH_KEEP_MS = 3 * 24 * 60 * 60 * 1000 // a finished clash record is kept this long
@@ -149,9 +160,36 @@ const SETTLE_BOXES_MS = 1500 // after an edit to one of our boxed files: does gi
 const RELAY_ASK_EVERY_MS = 5 * 1000 // a folder waiting for the relay asks it again this often (server.js SYNC_EVERY_GIT_MS)
 const INDEX_WATCH_MS = 8000 // after a bring-in, how long the index is checked against what another git may write back
 
+// The owner's app renews the room's read token this long before it ends, looks this often, and tries again after this (renewReadToken).
+const READ_RENEW_BEFORE_MS = 30 * 86400e3
+const READ_RENEW_CHECK_MS = 6 * 3600e3
+const READ_RENEW_RETRY_MS = 3600e3
+
+/** What a move says of large files in the session's storage that git does not have (server.js quiltSwitchNow): the folders put them in. */
+const largeLine = (list) => `Large files in the session's storage that git does not have are not in the squares yet (the relay can't read them); each folder that has them puts them in its square when it follows it, with a Seam sign-in on that computer: ${list.slice(0, 8).map((x) => `${x.path} (${x.branch}${x.size ? `, ${Math.max(1, Math.round(x.size / 1048576))} MB` : ''})`).join(', ')}${list.length > 8 ? `, and ${list.length - 8} more` : ''}.`
+
+/** What every member is told while the session moves (server.js withMigrationLease `moving`): what to expect, in plain words. */
+export const movingLine = (m) => m && m.kind === 'back'
+  ? 'The session\'s code is moving back from Seam to its git branches. Keep Quilt open: it can take a few minutes, and your edits are kept; your folder takes git back when it is done.'
+  : 'The session\'s code is moving into Seam, where it will be committed and merged; the session stays in Quilt. Keep Quilt open: it can take a few minutes on a large session, and your edits are kept; your folder then follows its square by itself.'
+
+
+/** The move's word on people Seam would not make writers of a square: their AIs can't commit there until they are. */
+function notSharedLines (list) {
+  if (!(list || []).length) return []
+  const by = new Map()
+  for (const x of list) { const k = `${x.member || 'everyone'} (${x.why})`; by.set(k, [...(by.get(k) || []), squareShort(x.square)]) }
+  const each = [...by].slice(0, 6).map(([who, sqs]) => `${who} in ${sqs.join(', ')}`)
+  return [`Not every person could be made a writer of every square, so their AIs can't commit there yet: ${each.join('; ')}${by.size > 6 ? '; …' : ''}. Add them to the quilt (seam quilts add <member> --level write) and share the square (seam_share).`]
+}
+/** What a move says when it made the room's read token again (server.js freshReadToken). */
+const readTokenLine = (why) => `The session's read token for its quilt was ${why === 'missing' ? 'missing' : why === 'expiring' ? 'about to end' : 'no longer taken by Seam'}, so a new one was made: every folder reads its square with it.`
+
 export class Session extends EventEmitter {
-  constructor ({ dir, server, room, secret, key = '', viewSecret = '', name, tool = 'unknown', toolGuessed = false, color = null, prefer = 'remote', kind = 'human', shareAgent = true, summarize = null, identity = null, passes = null, startName = '', startAgentCommits = '', workspace = '', autoClaimQuietMs = AUTO_CLAIM_QUIET_MS, handoffGraceMs = HANDOFF_GRACE_MS, aiTasks = null, pushLocalCommits = null, webhookTransport = null, pullWaitMs = PULL_WAIT_MS, bringInUpstream = true, clashReassignMs = CLASH_REASSIGN_MS, clashWaitMs = CLASH_WAIT_MS, clashSettleMs = CLASH_SETTLE_MS, clashIdleMs = CLASH_IDLE_MS, catcherWaitMs = CATCHER_WAIT_MS, gitBacking = true, gitRemote = null, followsRelay = true, turns = false, features = null, cli = defaultCli() }) {
+  constructor ({ dir, server, room, secret, key = '', viewSecret = '', name, tool = 'unknown', color = null, prefer = 'remote', kind = 'human', shareAgent = true, summarize = null, identity = null, passes = null, startName = '', startAgentCommits = '', newSession = false, quiltDefault = null, workspace = '', autoClaimQuietMs = AUTO_CLAIM_QUIET_MS, handoffGraceMs = HANDOFF_GRACE_MS, aiTasks = null, pushLocalCommits = null, webhookTransport = null, pullWaitMs = PULL_WAIT_MS, bringInUpstream = true, clashReassignMs = CLASH_REASSIGN_MS, clashWaitMs = CLASH_WAIT_MS, clashSettleMs = CLASH_SETTLE_MS, clashIdleMs = CLASH_IDLE_MS, catcherWaitMs = CATCHER_WAIT_MS, gitBacking = true, gitRemote = null, followsRelay = true, turns = false, features = null, cli = defaultCli(), apiAuth = null }) {
     super()
+    // The Quilt sign-in this session runs as, for the accounts API and Seam (seam-access.js): its person's, or its agent's key.
+    this.apiAuth = apiAuth
     // An agent that works in turns (agent-join.js keptInProject): the relay shows it away between them.
     this.turns = turns
     this.pullWaitMs = pullWaitMs
@@ -179,8 +217,6 @@ export class Session extends EventEmitter {
     // Signs in to a relay that requires it (see pass-source.js), with passes for this room.
     this.passes = passes && passes.forRoom ? passes.forRoom(room) : passes
     this.tool = tool
-    // Nobody picked `tool`, Quilt guessed it (tool-guess.js): the first AI that connects corrects it.
-    this.toolGuessed = toolGuessed
     this.color = color
     this.prefer = prefer
     this.stateDir = migrateDir(this.root)
@@ -247,6 +283,9 @@ export class Session extends EventEmitter {
     this.relayProblem = null // why the relay can't be reached, when we know (setRelayProblem)
     this.agentPrompts = new Map() // conv -> latest prompt line, so an edit can be titled after the question that started it
     this.merging = new Set() // paths held out of normal sync until their offline merge has run
+    // At layout 3 the folder follows its branch's square in place (session-follow.js): { square, since }, and
+    // while it does, its branch-document sync and git-mode upstream work are held (enterSquare).
+    this.inSquare = null
     this.catchUp = null // "while you were away" (catchup.js), until the person dismisses it
     this.awayBackups = null // while joining: copies of ours kept in .quilt/conflicts, for the catch-up
     this.work = null // { state: 'working'|'done', note, ts }: what an agent says it's doing
@@ -324,6 +363,10 @@ export class Session extends EventEmitter {
     this.startAgentCommits = startAgentCommits // the person's default for what agents may commit, set on a new room the same way
     this.workspace = workspace // the workspace this session is in (the app knows); told to the relay as owner, so webhook events can say so
     this.startNameSent = false
+    // A session this app just started: with QUILT_SOURCE_DEFAULT on the API it becomes a quilt from the start (quilt-default.js).
+    this.newSession = !!newSession
+    this.quiltDefault = quiltDefault // tests: replaces startAsQuilt's options
+    this.startQuiltTried = false
     this.logs = [] // the last 200 log lines (for status and tests)
     // Git awareness (gitstate.js): a git operation in this folder is recognised, not broadcast as edits.
     this.git = null // { key, branch, sha } this folder was on when the session started (null: not a repo)
@@ -462,8 +505,10 @@ export class Session extends EventEmitter {
     this.gone = doc.getMap('gone')
     this.fileBases = doc.getMap('fileBases')
     this.merges = doc.getMap('merges')
-    this.tallies = doc.getMap('changes')
-    this.history = new HistoryLog(doc, doc.getArray('history'), { origin: LOCAL })
+    // While the folder follows a square, who changed what is the square's (followSquareDoc).
+    const record = this.squareDoc || doc
+    this.tallies = record.getMap('changes')
+    this.history = new HistoryLog(record, record.getArray('history'), { origin: LOCAL })
   }
 
   /**
@@ -630,6 +675,8 @@ export class Session extends EventEmitter {
     // Back in a folder we synced before: the line is an offline edit, merged once synced. A first
     // join adds it after taking the room's files (reconcileFirstJoin), which may replace .gitignore.
     if (hadState) this.ignoreQuiltState()
+    // Restarted while the folder follows its square: its .git is set aside (session-follow.js) and stays so; its branch is the note's.
+    this.gitAside = gitDir(this.root) ? null : gitAsideOf(this.root)
     this.git = await headKey(this.root)
     this.gitSeen = this.git
     // A repo whose git can't be run (not on the PATH of an app started from the Dock, say) or
@@ -641,7 +688,7 @@ export class Session extends EventEmitter {
     const resumed = hadState && this.resumeHold()
     // The branch document this folder syncs: the branch it syncs in git (still the one it was paused off, until
     // the folder follows git), ∅ (the room's default) without git.
-    this.branch = this.git ? this.git.key : (gitDir(this.root) && headRef(this.root)) || DEFAULT_KEY
+    this.branch = this.git ? this.git.key : (gitDir(this.root) && headRef(this.root)) || (this.gitAside && this.gitAside.branch) || DEFAULT_KEY
     // The form saved is the saved branch's; another branch's is the relay's to say when it is joined.
     if (this.savedBranch !== this.branch) { this.branchForm = null; this.diffBase = null }
     const diffJoin = await this.diffJoinFields()
@@ -681,6 +728,29 @@ export class Session extends EventEmitter {
     this.conn.on('access', (a) => this.setAccess(a))
     this.conn.on('members', (m) => this.setMembers(m))
     this.conn.on('branches', (list) => this.setBranches(list))
+    // Seam (Seam's plans/quilt-source-control/16): the relay says when the session is a quilt, and which.
+    this.conn.on('quilt', (q) => {
+      this.quilt = q
+      this.emit('quilt', q)
+      // At layout 3 this folder follows its branch's square by itself (session-follow.js).
+      if (!this.squareFollower) this.squareFollower = new SquareFollower(this)
+      this.squareFollower.onQuilt(q).catch(() => {})
+      this.renewReadToken().catch(() => {})
+    })
+    // A write of this folder's reached a read-only branch document at layout 3: it was not kept (server.js refusedReadOnly).
+    this.conn.on('read-only', (r) => this.noteReadOnly(r))
+    this.conn.on('quilt-shadow', (q) => { this.quiltShadow = q; this.emit('quilt-shadow', q) })
+    this.conn.on('importing', (x) => { this.quiltImporting = x; this.scheduleStatusWrite(); this.emit('importing', x) })
+    // The forced date (16 flag 9, force-date.js): live sync stopped here, or the owner's open makes the session a quilt.
+    this.conn.on('force', (f) => this.onForce(f))
+    // A move of the session (into Seam, or back) runs on the relay: said in the log, the app and quilt_status while it lasts.
+    this.conn.on('moving', (m) => {
+      const was = this.moving
+      this.moving = m
+      if (m && !was) this.log(`🧵 ${movingLine(m)}`)
+      else if (!m && was) this.log(`🧵 the move of the session's code ${was.kind === 'back' ? 'back to its git branches' : 'into Seam'} is over.`)
+      this.scheduleStatusWrite()
+    })
     // GitHub moved this folder's branch: fetch and bring it in now, not at the next minute's look.
     this.conn.on('pushed', (p) => {
       if (!this.git || !this.git.branch || p.branch !== this.branchKey() || this.stopped) return
@@ -712,7 +782,9 @@ export class Session extends EventEmitter {
       const gitNow = this.diffForm && !resumed && this.git && this.git.sha ? await changedSince(this.root, this.git.sha).catch(() => null) : null
       const offline = resumed ? { entries: [], take: [], downloads: [] } : this.captureOffline(gitNow)
       this.goLive()
-      if (offline.entries.length) this.log(`${offline.entries.length} file(s) changed while you were away; merging once the relay has synced…`)
+      // A folder that follows its square (its .git set aside) is compared with the branch document it last synced, which the
+      // square's work has moved past: its block's first look says what went in, so nothing is said here.
+      if (offline.entries.length && !gitAsideOf(this.root)) this.log(`${offline.entries.length} file(s) changed while you were away; merging once the relay has synced…`)
       const synced = this.conn.waitForSync()
       // An agent's folder synced before folders were git-backed: once the relay has synced, with its
       // branch's repository known, it is made a checkout, and git is watched from then on.
@@ -777,6 +849,8 @@ export class Session extends EventEmitter {
       await this.maybeBackWithGit()
     }
     await this.startWatcher()
+    // git was set aside while following a square, and the session is not one at layout 3 now (or Seam is off here): it comes back.
+    if (this.gitAside) this.conn.waitForSync().then(() => { if (!this.inSquare && !this.stopped) return this.gitBack() }).catch(() => {})
     return this
   }
 
@@ -790,7 +864,7 @@ export class Session extends EventEmitter {
    */
   async maybeBackWithGit ({ late = false } = {}) {
     // A person's folder too, while git is on for everyone here and a connection covers the repository (git for everyone): with GitHub as origin.
-    if (!this.gitBacking || (this.kind !== 'agent' && !this.personGitOn()) || this.git || gitDir(this.root) || this.stopped || this.backing) return false
+    if (!this.gitBacking || (this.kind !== 'agent' && !this.personGitOn()) || this.git || gitDir(this.root) || this.gitAside || this.inSquare || this.stopped || this.backing) return false
     // The relay's record of the branch (its repository and the commit the session is at) comes with its
     // branch list; when it isn't here yet, setBranches tries again as it arrives (no wait at start).
     const relay = this.relayEntryFor(this.branch)
@@ -984,6 +1058,9 @@ export class Session extends EventEmitter {
    */
   async pushCheck ({ remote = 'origin', refs = [] } = {}) {
     const list = (Array.isArray(refs) ? refs : []).filter((r) => r && typeof r.remoteRef === 'string')
+    // A session that is a quilt lands work through Seam, and GitHub takes only Seam's export: an
+    // agent's push goes nowhere, and a person's to the session's repository is told the Seam way.
+    if (this.quilt && this.quilt.id && (this.kind === 'agent' || await this.isSessionRemote(remote))) return { ok: false, why: pushRefusal(this.quilt.slug || this.quilt.id) }
     if (this.kind !== 'agent') return this.personPushCheck({ remote })
     const policy = (this.access && this.access.agentCommits) || 'branches'
     if (policy === 'off') return { ok: false, why: `${gitForEveryoneWords({ policy: 'off', by: this.offBy() })} Ask a person for the commit with quilt_request_commit.` }
@@ -1035,6 +1112,16 @@ export class Session extends EventEmitter {
     return { ok: false, why: `${gitForEveryoneWords({ policy: 'off', by })} ${by ? 'Its admins turn it back on in its settings.' : 'The session owner turns it back on in the session\'s settings (under Version control, This session\'s source control).'}` }
   }
 
+  /** Whether `remote` (a name or URL) is the session's GitHub repository: its own folder's origin, or one its branches follow. */
+  async isSessionRemote (remote = 'origin') {
+    const name = String(remote || 'origin')
+    const url = /^[a-z][a-z0-9+.-]*:\/\/|^[^/\s]+@[^/\s]+:/i.test(name) ? name : await this.gitOut(['config', '--get', `remote.${name}.url`])
+    if (url && url === this.relayGitUrl()) return true
+    const repo = url ? parseRepo(url) : null
+    if (!repo || !repo.github) return false
+    return name === 'origin' || this.sessionRepos().has(`github.com/${repo.owner}/${repo.name}`.toLowerCase())
+  }
+
   /** The rule over the session that turned git off ({ by, name }), or null when the owner did (or it is on). */
   offBy () {
     const by = this.access && this.access.agentCommitsBy
@@ -1213,6 +1300,9 @@ export class Session extends EventEmitter {
     if (was && was.agentCommits !== a.agentCommits) this.gitToken = null
     this.syncPersonGitSoon() // git for everyone: a person's helper follows git on or off
     if (a.state === 'approved' && a.owner) this.sendStartName()
+    if (this.force && this.force.migrate && a.state === 'approved' && a.owner) this.onForce(this.force)
+    // A new session becomes a quilt as its owner (in a room with no owner, the relay lets any editor: quiltPlanRefusal).
+    if (a.state === 'approved' && a.role !== 'viewer' && (a.owner || !a.controlled)) this.startQuiltOnce()
     if (a.state === 'approved' && this.webhook && !this.webhook.local) this.migrateWebhook().catch(() => {}) // the relay sends it from now on (or again, if it lost it)
     if (a.state === 'pending' && (!was || was.state !== 'pending')) this.log(`⏳ waiting for the session owner to let you in (you were invited to ${a.invitedAs === 'viewer' ? 'view' : 'edit'})`)
     if (a.state === 'approved' && was && (was.role !== a.role || String(was.scopes) !== String(a.scopes) || String(was.scopesExcept || []) !== String(a.scopesExcept || []))) {
@@ -1313,6 +1403,19 @@ export class Session extends EventEmitter {
     this.rename(this.startName).catch((err) => this.log(`couldn't name the session: ${err.message}`))
   }
 
+  /** A new session, as its owner, starts as a quilt when the API says new sessions do (flags order 8); once, in the background. */
+  startQuiltOnce () {
+    if (!this.newSession || this.startQuiltTried) return
+    this.startQuiltTried = true
+    // Made as a person: an agent's own key only reads on Seam, so an agent's new session is made as the person signed in on this computer.
+    const credential = async () => {
+      const c = await sessionCredential({ apiAuth: this.apiAuth, account: readAccount })()
+      if (c && isAgentKey(c) && !process.env.SEAM_TOKEN) { const acc = readAccount(); if (acc && acc.token) return acc.token }
+      return c
+    }
+    this.startingQuilt = startAsQuilt(this, { credential, ...(this.quiltDefault || {}) })
+  }
+
   /** As the owner, tells the relay which workspace the session is in (once per run; again when it moves). */
   sendWorkspace () {
     if (!this.workspace || this.workspaceSent === this.workspace || !this.isOwner) return
@@ -1690,9 +1793,12 @@ export class Session extends EventEmitter {
 
   /** Runs once the relay has synced: merges every captured path against the session's version. */
   async mergeOffline ({ entries, take, downloads }) {
+    if (this.syncStopped) { for (const e of entries) this.merging.delete(e.rel); return null }
     if (this.stopped) { for (const e of entries) this.merging.delete(e.rel); return null } // the next start captures them again
     // The saved copy was of an older document of this branch: the folder joined fresh instead (rejoinFresh).
     if (this.staleRejoin || this.rejoinedFresh) { for (const e of entries) this.merging.delete(e.rel); return null }
+    // The folder follows its square: the block takes the edits made while away in (they differ from lastKnown, editedSinceSync).
+    if (this.inSquare) { for (const e of entries) this.merging.delete(e.rel); return null }
     const counts = { pushed: 0, merged: 0, ai: 0, conflict: 0 }
     const paths = { merged: [], conflict: [] } // for the catch-up
     const queue = entries.slice()
@@ -2009,6 +2115,7 @@ export class Session extends EventEmitter {
 
   /** `gitNow`: for a diff branch, what the folder has that differs from HEAD (gitstate.js changedSince), or null. */
   reconcileFirstJoin (gitNow = null) {
+    if (this.inSquare || this.syncStopped) return { pulled: 0 } // the square's block brings the folder in (session-follow.js)
     const onDisk = new Set(walk(this.root, this.ig))
     let pulled = 0; let pushed = 0; let backedUp = 0
     const backupDir = path.join(this.stateDir, 'conflicts', new Date().toISOString().replace(/[:.]/g, '-'))
@@ -2128,6 +2235,10 @@ export class Session extends EventEmitter {
   // ------------------------------------------------------- local -> shared --
 
   queue (rel) {
+    // The folder follows its square: the block sees every change; git moving HEAD may take it to another branch's square.
+    // The app hears of each change on disk all the same (its Files list and an open file read the folder then: squareFiles).
+    if (this.syncStopped) return // live sync stopped at the forced date (onForce): the folder is plain git
+    if (this.inSquare) { if (rel === HEAD_CHANGED) this.squareHeadMoved(); else this.emit('file-changed', { path: rel }); return }
     this.pending.add(rel)
     if (!this.flushTimer) this.flushTimer = setTimeout(() => this.flushPending(), FLUSH_MS)
   }
@@ -2933,7 +3044,7 @@ export class Session extends EventEmitter {
 
   /** (Re)arms the settle timer: the hold ends SETTLE_MS after the last file or git event. */
   settleSoon () {
-    if (!this.hold || this.hold.kind === 'switching' || this.stopped || this.holdAwaitsSync) return
+    if (!this.hold || this.hold.kind === 'switching' || this.stopped || this.holdAwaitsSync || this.inSquare) return
     clearTimeout(this.settleTimer)
     const gen = ++this.settleGen
     this.settleTimer = setTimeout(() => {
@@ -3303,7 +3414,7 @@ export class Session extends EventEmitter {
 
   /** Looks again shortly (a branch moved, a fetch landed); several asks in a row make one look. */
   checkUpstreamSoon ({ fetch = false, delay = SETTLE_MS } = {}) {
-    if (!this.git || !this.git.branch || this.stopped) return
+    if (!this.git || !this.git.branch || this.stopped || this.inSquare || this.syncStopped) return
     this.upstreamFetch = this.upstreamFetch || fetch
     if (this.upstreamTimer) return // one look is already on its way: it takes this ask too
     this.upstreamTimer = setTimeout(() => {
@@ -3332,7 +3443,7 @@ export class Session extends EventEmitter {
    * fetching first when asked, and catches up when the branch is behind. Returns the state.
    */
   async checkUpstream ({ fetch = false, now = false } = {}) {
-    if (!this.git || !this.git.branch || this.stopped) return this.upstream
+    if (!this.git || !this.git.branch || this.stopped || this.inSquare || this.syncStopped) return this.upstream
     if (!this.quietForUpstream()) {
       this.upstreamLater(fetch) // busy for a moment: asked again once it's quiet
       return this.upstream
@@ -3569,7 +3680,17 @@ export class Session extends EventEmitter {
     for (const rel of paths) {
       if (this.syncable(rel) && this.writeRefusal(rel)) { state({ waiting: `you may not change ${rel} in this session` }); return }
     }
-    const diskKey = (rel) => this.diskKey(rel)
+    // Links are git's (the session never syncs them): one the folder has as git has it at either end is that version, and one the commits bring is written as a link.
+    const [linksFrom, linksTo] = [await linksAt(this.root, from, paths), await linksAt(this.root, to, paths)]
+    if (!linksFrom || !linksTo) return
+    const linkKey = (rel) => {
+      let target
+      try { target = fs.readlinkSync(resolveInside(this.root, rel)) } catch { return undefined }
+      if (linksTo.has(rel) && theirs.get(rel) === target) return target
+      if (linksFrom.has(rel) && base.get(rel) === target) return target
+      return undefined
+    }
+    const diskKey = (rel) => { const k = this.diskKey(rel); return k === undefined ? linkKey(rel) : k }
     // The session and this folder must agree first: a change still on its way waits for the next look.
     // Following, that is every file the commits changed: the branch moves only once the session's versions are
     // on disk, or a commit made meanwhile (git commit -a) would take a file still on its way for a deletion.
@@ -3625,7 +3746,7 @@ export class Session extends EventEmitter {
             const data = key.startsWith('bin:') ? await blobAt(this.root, to, rel) : key
             if (data === null) throw new Error('git could not read it')
             fs.mkdirSync(path.dirname(abs), { recursive: true })
-            this.writeFile(rel, abs, data)
+            if (linksTo.has(rel)) { fs.rmSync(abs, { force: true }); fs.symlinkSync(String(data), abs) } else this.writeFile(rel, abs, data)
           }
           written++
           if (this.syncable(rel)) this.ingest(rel, { pulled: true })
@@ -3686,6 +3807,514 @@ export class Session extends EventEmitter {
    * Asked for by an AI (quilt_sync_branch): fetch and bring commits in now, without waiting for
    * the next look or another member's folder. What happened: { branch, upstream, moved, busy }.
    */
+  /**
+   * What making this session a quilt would do (Seam's plans/quilt-source-control/16), read only: the
+   * relay's dry run (behind QUILT_SOURCE_URL there, the owner's), as { plan, text }.
+   */
+  async quiltPlan () {
+    if (!this.conn || !this.conn.connected) throw new Error('not connected to the relay; the dry run needs a connection')
+    const r = await this.conn.branchRequest({ op: 'quilt-plan' })
+    return { plan: r.plan, text: describeQuiltPlan(r.plan) }
+  }
+
+  /**
+   * Makes the session a quilt (Seam's plans/quilt-source-control/16, "Without history"): the relay does
+   * it, as the owner, with `token` (their Seam sign-in: SEAM_TOKEN, else their Quilt account's).
+   * What it made: { quilt, text }.
+   */
+  async quiltMigrate (token, { op = 'quilt-migrate' } = {}) {
+    if (!this.conn || !this.conn.connected) throw new Error('not connected to the relay; making the session a quilt needs a connection')
+    if (!token) throw new Error('sign in first (quilt login, or set SEAM_TOKEN): the session becomes a quilt as its owner')
+    const r = await this.conn.branchRequest({ op, token }, { timeoutMs: QUILT_MOVE_TIMEOUT_MS })
+    const q = r.quilt
+    // A session with a git remote moves in steps (the relay's quiltMakeWithRemote): Seam importing it, then ready for the cut-over.
+    if (q && (q.stage === 'importing' || q.stage === 'ready')) return { quilt: q, text: q.text }
+    const lines = [`Session ${this.room || ''} is now the quilt ${q.slug}.`.replace('Session  is', 'This session is')]
+    if (q.history) lines.push(`It is the quilt its git remote was imported into: main is at patch ${q.patch && q.patch.no}, git's history before it.`)
+    else if (q.patch) lines.push(`Patch ${q.patch.no} holds the main branch as it was.`)
+    for (const s of q.squares) lines.push(`Branch ${s.from} is square ${squareShort(s.id)}.`)
+    for (const b of q.based_at_tip || []) {
+      lines.push(b.why === 'unfetched'
+        ? `The relay never fetched ${b.from} from git, so its square starts at main's tip with the branch's files over it: its history before the move is main's, not the branch's.`
+        : b.why === 'merged'
+          ? `${b.from}'s commit ${String(b.wanted || '').replace(/^git:/, '').slice(0, 12)} is already merged into main, so its square starts at main's tip.`
+          : `Seam has no commit for ${String(b.wanted || '').replace(/^git:/, '')}, so ${b.from}'s square starts at main's tip.`)
+    }
+    if (q.adoption) lines.push(`Work on the main branch that git does not have is in the square "Uncommitted work" (${squareShort(q.adoption)}).`)
+    if (q.read_token) lines.push(readTokenLine(q.read_token))
+    if (q.large) lines.push(largeLine(q.large))
+    if (q.rebased) lines.push(`Someone's unfinished work boxed on an older main went onto main's newer copy as their change only, not their whole file: ${q.rebased.slice(0, 8).map((x) => `${x.path} (${x.branch})`).join(', ')}.`)
+    if (q.claims && q.claims.left && q.claims.left.length) lines.push(`Claims not moved: ${q.claims.left.map((c) => `${c.pattern} (${c.why})`).join(', ')}.`)
+    if (q.layout === 3) lines.push('Its files are in its squares now; apps without Seam are asked to update. quilt session migrate --back goes back to git.')
+    lines.push(...notSharedLines(q.not_shared))
+    const moved = Object.keys(q.tasks || {}).length
+    if (moved) lines.push(`${moved} task${moved === 1 ? '' : 's'} with a pull request follow${moved === 1 ? 's' : ''} its square.`)
+    if (q.left_out.length) lines.push(`Large files left in the session's storage, not in the quilt: ${q.left_out.join(', ')}.`)
+    return { quilt: q, text: lines.join('\n') }
+  }
+
+  /**
+   * The relay's word on the forced date (16 flag 9). `stopped`: the session had a git remote and did
+   * not cut over, so its live file sync stopped for good: this folder is plain git from now on (no
+   * file is written or shared by Quilt, no git work of Quilt's), said once in the log, the app and
+   * every quilt answer. `migrate`: a session with no git remote, past the date, opened by its owner:
+   * made a quilt now, as they would with the button (once per run of the app).
+   */
+  onForce (f) {
+    this.force = f || null
+    if (f && f.stopped && !this.syncStopped) {
+      this.syncStopped = { at: f.stopped.at }
+      clearTimeout(this.flushTimer)
+      this.flushTimer = null
+      this.pending.clear()
+      clearTimeout(this.upstreamTimer)
+      this.upstreamTimer = null
+      const why = String(f.stopped.why || 'Live sync stopped: this session\'s folder is plain git now.')
+      this.log(`🧵 ${why}`)
+      this.notice(why)
+      this.scheduleStatusWrite()
+      this.emit('force', f)
+      return
+    }
+    if (f && f.migrate && !f.remote && !this.forceMigrateTried && this.access && this.access.owner) {
+      const token = process.env.SEAM_TOKEN || (readAccount() || {}).token
+      if (!token) return
+      this.forceMigrateTried = true
+      this.log('🧵 The date for moving sessions into Seam has passed: making this session a quilt now (its code is committed in Seam from here on; nothing is lost).')
+      this.quiltMake(token).then((r) => { this.log(`🧵 ${r.text.split('\n')[0]}`); this.notice(r.text) }, (err) => this.log(`⚠️ couldn't make the session a quilt at the forced date: ${err.message}. Settings → Session → Make this a quilt tries again.`))
+    }
+    this.emit('force', f)
+  }
+
+  /**
+   * "Make this a quilt" (16 flag 9), the owner's button and `quilt session migrate`: the relay makes the
+   * session a quilt and moves its files into its squares in one go (Room.quiltMake). { quilt, text }.
+   */
+  quiltMake (token) { return this.quiltMigrate(token, { op: 'quilt-make' }) }
+
+  /**
+   * The session's files into its squares' live documents on the relay (layout 3, 16), as the
+   * owner, once it is a quilt: { layout, live, adoption, text }.
+   */
+  async quiltSwitch (token) {
+    if (!this.conn || !this.conn.connected) throw new Error('not connected to the relay; moving the session needs a connection')
+    if (!token) throw new Error('sign in first (quilt login, or set SEAM_TOKEN): the session moves into its squares as its owner')
+    const r = await this.conn.branchRequest({ op: 'quilt-switch', token }, { timeoutMs: QUILT_MOVE_TIMEOUT_MS })
+    const lines = ['The session\'s files are in its squares now; its branches are kept, read-only.']
+    for (const [b, k] of Object.entries(r.live || {})) lines.push(`${b} is in square ${squareShort(k.replace(/^quilt\//, ''))}.`)
+    if (r.adoption) lines.push(`Work on the main branch since it became a quilt is in the square "Uncommitted work" (${squareShort(r.adoption)}).`)
+    if (r.read_token) lines.push(readTokenLine(r.read_token))
+    if (r.large) lines.push(largeLine(r.large))
+    if (r.rebased) lines.push(`Someone's unfinished work boxed on an older main went onto main's newer copy as their change only, not their whole file: ${r.rebased.slice(0, 8).map((x) => `${x.path} (${x.branch})`).join(', ')}.`)
+    lines.push('Apps without Seam are asked to update. quilt session migrate --back goes back to the branches.')
+    lines.push(...notSharedLines(r.not_shared))
+    return { ...r, text: lines.join('\n') }
+  }
+
+  /**
+   * At layout 3 (Seam's plans/quilt-source-control/16): `dir` (its own folder) follows this folder's
+   * branch's square, live (session-follow.js), signed in to Seam with `token` (else as this member). Only with
+   * Seam on for this app (seam-url.js) and the relay saying the session is a layout-3 quilt.
+   */
+  async quiltFollow (token, dir) {
+    if (!this.squareFollower) this.squareFollower = new SquareFollower(this)
+    // As `token`, else as this member (seamMember), the same as `quilt commit` and the Seam tools.
+    const client = !appSeamUrl() ? null : token ? quiltClient({ api: appSeamUrl(), token }) : await this.seamClientNow()
+    const r = await this.squareFollower.follow({ dir: dir ? path.resolve(this.root, String(dir)) : '', client })
+    return { ...r, text: `${r.dir} follows the square ${squareShort(r.square)}: edits there are live for everyone on it.` }
+  }
+
+  /**
+   * The folder follows its branch's square in place (session-follow.js, at layout 3): from now on
+   * its block takes every change, so the session's own sync of the folder holds: nothing goes to
+   * the read-only branch document, and no git-mode upstream work runs (no fetch, fast-forward or
+   * merge into uncommitted work, no boxes). Called before the block opens, so nothing slips through.
+   */
+  enterSquare (at) {
+    if (this.inSquare && this.inSquare.square === at.square) return
+    this.inSquare = { square: at.square, since: Date.now() }
+    clearTimeout(this.flushTimer)
+    this.flushTimer = null
+    this.pending.clear()
+    this.setGitAside()
+    this.scheduleStatusWrite()
+  }
+
+  /** In a quilt nobody uses git: the folder's .git goes into .quilt while it follows its square (session-follow.js), and git-mode work stops. */
+  setGitAside () {
+    let r
+    try { r = setGitAside(this.root, { branch: this.branchKey() }) } catch (err) { this.log(`⚠️ couldn't set git aside in this folder (${err.message}); git still works here, but the session's code history is in Seam`); return }
+    if (r.both) this.log('⚠️ a new .git appeared in this folder while it follows its square; the one set aside is kept in .quilt/git-before-seam')
+    if (r.moved || r.already) this.gitAside = gitAsideOf(this.root)
+    if (r.moved) this.log('🧵 git is set aside in this folder while it follows its square (in .quilt/git-before-seam): in a quilt, Seam keeps the history. It comes back if the session goes back to its branches.')
+    if (r.worktrees) {
+      const n = r.worktrees.length
+      this.log(`🧵 ${n} other worktree${n === 1 ? '' : 's'} of this repository (${r.worktrees.slice(0, 5).join(', ')}${n > 5 ? `, and ${n - 5} more` : ''}) keep using git while this folder follows its square: each one's .git file points at this folder's .git in .quilt/git-before-seam meanwhile, and goes back as it was with it.`)
+    }
+    if (this.gitWatcher) { const w = this.gitWatcher; this.gitWatcher = null; Promise.resolve(w.close()).catch(() => {}) }
+    clearInterval(this.upstreamPoll)
+    this.upstreamPoll = null
+    this.git = null
+  }
+
+  /** The .git set aside comes back (before git-mode sync resumes), and git is watched again. */
+  async gitBack () {
+    if (!gitAsideOf(this.root)) { this.gitAside = null; return false }
+    let back = false
+    try { back = putGitBack(this.root) } catch (err) { this.log(`⚠️ couldn't put git back in this folder (${err.message}); it is in .quilt/git-before-seam`); return false }
+    if (!back) { this.log('⚠️ this folder has a new .git, so the one set aside stays in .quilt/git-before-seam'); return false }
+    this.gitAside = null
+    this.git = await headKey(this.root)
+    this.gitSeen = this.git
+    if (this.git && !this.stopped) this.startGitWatch()
+    this.log('git is back in this folder.')
+    this.scheduleStatusWrite()
+    return true
+  }
+
+  /**
+   * Back from the square (the session went back to layout 2): the old sync resumes. What the folder
+   * holds now that differs from the branch document (the square's work, the same on every member's
+   * folder) is shared as one edit from all of them (same-edit.js), then git-mode work carries on.
+   * `writers` (path -> name, who last wrote it in the square: live-square.js lastWriters): only that
+   * member's folder boxes a returning file. Whichever folder ingested it first used to, so a member
+   * who reached the session first held another's work, and the writer's next edit reached nobody.
+   */
+  async leaveSquare ({ writers = null } = {}) {
+    if (!this.inSquare) return
+    this.unfollowSquareDoc()
+    // git first: git-mode sync resumes on a folder git knows again.
+    await this.gitBack()
+    this.inSquare = null
+    // The block's record of the folder goes too: after branches, a later switch starts from the session's sync, not from it.
+    try { fs.rmSync(path.join(this.stateDir, 'block.json'), { force: true }) } catch {}
+    const moved = this.squareBranch && this.squareBranch !== this.branchKey()
+    this.squareBranch = null
+    if (moved) this.queue(HEAD_CHANGED)
+    else {
+      for (const rel of new Set([...walk(this.root, this.ig), ...this.lastKnown.keys()])) {
+        if (!this.syncable(rel) || this.untouchedHere(rel)) continue
+        try { this.ingest(rel, { same: true, claim: !!(writers && writers.get(rel) === this.name) }) } catch (err) { this.log(`could not sync ${rel}: ${err.message}`) }
+      }
+    }
+    this.scanDisk({ baseline: true })
+    this.checkUpstreamSoon({ fetch: true })
+    this.settleSoon()
+    this.scheduleStatusWrite()
+  }
+
+  /**
+   * Whether the folder's copy of `rel` changed since the session last synced it (for the square's
+   * first look at the folder, live-block.js adopt). A folder never synced has no edits of its own.
+   */
+  editedSinceSync (rel) {
+    if (!this.lastKnown.size) return false
+    const k = this.diskKey(rel)
+    if (k === undefined) return true // a link, or too large for the session: the folder's own
+    return this.lastKnown.has(rel) ? k !== this.lastKnown.get(rel) : k !== null
+  }
+
+  /**
+   * Whether `rel` was someone else's box in this folder before the move (ghost): the folder kept its own
+   * copy (git's, moved on by pulls) while the session held the box's, so the square's first look puts the
+   * box's change onto the folder's copy (live-block.js combineAway), from what everyone had when it began.
+   */
+  boxedHere (rel) { return this.boxBase.has(rel) }
+
+  /**
+   * Whether the session held `rel` back from this folder before the move: someone else's box here (the
+   * folder kept git's copy, or none for a new file), or a change still waiting for whoever held the file
+   * (an open merge record: deleted or changed offline while another held it). The folder's lack of it
+   * at the square's first look is then not its deletion.
+   */
+  heldBackHere (rel) {
+    if (this.boxBase.has(rel)) return true
+    try { return this.mergeList().some((m) => m && m.path === rel && m.state !== 'done') } catch { return false }
+  }
+
+  /** Whether the session synced `rel` with this folder (the square's first look takes a file it has as git or the session left it for no edit). */
+  syncedHere (rel) {
+    if (!this.lastKnown.has(rel) || this.boxBase.has(rel)) return false
+    // A large file in the session's storage is not in the square (the relay can't read its bytes, so the
+    // move left it out and named it): the folder's copy is what puts it there, never the square's absence.
+    const b = this.blobs && this.blobs.get(rel)
+    return !(b && b.stored)
+  }
+
+  /** The paths this folder's branch changed since it left the default branch, { committed, uncommitted } (the square's first look keeps those as the folder's), or null when git can't say. */
+  branchOwnPaths () {
+    return ownSinceFork(this.root, gitAsideOf(this.root) ? { gitDir: path.join(this.root, GIT_ASIDE) } : {}).catch(() => null)
+  }
+
+  /**
+   * The paths whose edits this folder made into its branch document but the relay does not hold
+   * (session-follow.js unsentPaths): at layout 3 the read-only document refused them, so the
+   * folder's copy is its own work, never the switch's older copy. Empty with nothing refused;
+   * null when the relay can't say (an older relay).
+   */
+  async unsentPaths () {
+    if (!this.bdoc || !this.conn || !this.conn.connected || this.conn.branchKey === null) return null
+    const r = await this.conn.branchRequest({ op: 'state', branch: this.conn.branchKey })
+    const bytes = (b64) => new Uint8Array(Buffer.from(String(b64 || ''), 'base64'))
+    return unsentPaths(this.bdoc, bytes(r.sv), bytes(r.deleted))
+  }
+
+  /**
+   * The folder's block on its square is open: who changed what (the chronology, Changes) is kept in
+   * the square's live document from now on. It came with the branch's at the switch and goes on from
+   * square to square (session-layout3.js copyIntoLive, carryLive), so a file's History, Changes and
+   * the Files tree carry on where the branch left them.
+   */
+  followSquareDoc (doc) {
+    if (!doc || this.squareDoc === doc) return
+    this.squareDoc = doc
+    this.history = new HistoryLog(doc, doc.getArray('history'), { origin: LOCAL })
+    this.tallies = doc.getMap('changes')
+    this.scheduleStatusWrite()
+  }
+
+  /** Back on the branch's document (the block closed). */
+  unfollowSquareDoc () {
+    if (!this.squareDoc) return
+    this.squareDoc = null
+    if (this.bdoc) { this.history = new HistoryLog(this.bdoc, this.bdoc.getArray('history'), { origin: LOCAL }); this.tallies = this.bdoc.getMap('changes') }
+    this.scheduleStatusWrite()
+  }
+
+  /**
+   * Edits this folder made in its square, as its block took them in (live-block.js onEdits): on
+   * record as this member's, the same as on a branch (recordActivity: the chronology and Changes in
+   * the square's live document `doc`, the room's activity, this member's presence).
+   */
+  squareEdits (list, doc, held = null) {
+    this.followSquareDoc(doc)
+    for (const e of list) {
+      const texts = typeof e.before === 'string' || typeof e.after === 'string' ? { before: e.before, after: e.after } : undefined
+      try { this.recordActivity(e.path, e.kind, e.detail || '', texts, { activity: false }) } catch (err) { this.emit('debug', `could not record ${e.path}: ${err.message}`) }
+      this.noteMyEdit(e.path)
+      // Claims follow edits here too (as ingest makes them on a branch): the room's claims on this
+      // branch, which the Loom stitches, quilt_before_edit answers and the file queue hang on.
+      const claim = this.claimFor(e.path)
+      if (e.kind !== 'deleted' && (!claim || this.autoClaims.has(e.path)) && this.aiMayBeEditing()) this.autoClaim(e.path)
+    }
+    // The room's activity names a file the relay finds in the square (server.js onBranch): sent once the relay holds the edit, over the block's connection.
+    const push = () => { if (this.stopped) return; for (const e of list) { try { this.pushActivity(e.path, e.kind, e.detail || '') } catch {} } }
+    if (held) held().then(push, push); else push()
+  }
+
+  /**
+   * The text the session last synced for `rel` (the square's first look combines an edit made while
+   * away with the square's), or null: a file a diff branch leaves to git is git's, read from
+   * the .git set aside.
+   */
+  async syncedText (rel) {
+    // Someone else's box: what everyone had when it began (ghost), not the folder's own copy since.
+    if (this.boxBase.has(rel)) { const b = this.boxBase.get(rel); return b && typeof b.text === 'string' ? b.text : null }
+    const k = this.lastKnown.get(rel)
+    if (k !== undefined) return typeof k === 'string' && !/^bin:[0-9a-f]{40}$/.test(k) ? k : null
+    if (!this.followsGit(rel) || !gitAsideOf(this.root)) return null
+    const buf = await blobAt(this.root, 'HEAD', rel, { gitDir: path.join(this.root, GIT_ASIDE) })
+    return buf && !looksBinary(buf) ? buf.toString('utf8') : null
+  }
+
+  /** Whether the session never syncs anything in folder `rel` (.git, .quilt, node_modules, ignored ones): the block's walk skips it. */
+  ignoredDir (rel) { return !isSafeRelPath(rel) || isIgnored(this.ig, rel) || this.ig.ignores(`${rel}/`) }
+
+  /** The branch the folder is on for its square: git's, once git moved it while following (squareHeadMoved). */
+  squareBranchKey () { return this.squareBranch || this.branchKey() }
+
+  /** git moved HEAD while the folder follows a square: on another branch, the folder follows that branch's square. */
+  squareHeadMoved () {
+    clearTimeout(this.squareHeadTimer)
+    this.squareHeadTimer = setTimeout(async () => {
+      const head = await headKey(this.root).catch(() => null)
+      if (!head || !this.inSquare || this.stopped) return
+      const key = head.key === DEFAULT_KEY ? this.branchKey() : head.key
+      if (key === this.squareBranchKey()) return
+      this.squareBranch = key
+      if (this.squareFollower) await this.squareFollower.branchMoved(this.quilt).catch((err) => this.log(`🧵 ${err.message}`))
+    }, SETTLE_MS)
+    this.squareHeadTimer.unref?.()
+  }
+
+  /** Reads of the quilt for the folder's block: through the relay, with the room's read token (session-follow.js relayReader). */
+  squareReader () { return relayReader(this.conn) }
+
+  /**
+   * This member to Seam (seam-access.js): SEAM_TOKEN, else the Quilt sign-in the session runs as
+   * (its person's, or its agent's key traded for an agent token). The Seam tools (control.js), the
+   * folder's block and `quilt commit` all use this one, so they act as the same member.
+   */
+  seamMember () {
+    if (!this.seam) this.seam = seamAccess({ api: () => this.seamApiUrl ?? appSeamUrl(), credential: () => sessionCredential({ apiAuth: this.apiAuth, account: readAccount })() })
+    return this.seam
+  }
+
+  /** A Seam client as this member for the square the folder follows (seamMember), for uploads and commits; throws with why when there is none. */
+  async seamClientNow () {
+    if (!this.quilt || !this.quilt.id) throw new Error('This session is not a quilt.')
+    const f = this.squareFollower
+    const square = (f && f.here && f.here.square) || (f && f.following && f.following.square) || null
+    return (await this.seamMember().client(this.quilt.id, square ? [square] : [])).client
+  }
+
+  /** The same, or null without one (the block reads through the relay meanwhile). */
+  async seamWriteClient () {
+    try { return await this.seamClientNow() } catch { return null }
+  }
+
+  /** `quilt commit`: the square's live work, committed from this folder (session-follow.js). */
+  async squareCommit (message) {
+    if (!this.squareFollower) throw new Error('This folder does not follow a square: the session is not a quilt at layout 3.')
+    // As this member, the same as seam_commit's (a cloud AI's agent token renews itself).
+    if (this.squareFollower.here && this.squareFollower.here.block) this.squareFollower.here.block.client = await this.seamClientNow()
+    const r = await this.squareFollower.commit({ message })
+    if (r && r.nothing) return { nothing: true, text: 'Nothing to commit: the square has no work since its last commit.' }
+    const head = r && r.square && r.square.head
+    return { ...r, text: `Committed to square ${squareShort(this.squareFollower.here.square)}${head ? ` as ${String(head).slice(0, 12)}` : ''}.` }
+  }
+
+  /**
+   * { branch } when this folder's branch has no square in the quilt at layout 3 (a branch made after the
+   * switch, or main with nothing to adopt): its edits reach nobody until one is opened for it. Else null.
+   */
+  squareless () {
+    if (!this.quilt || this.quilt.layout !== 3 || !this.root) return null
+    const branch = this.squareBranchKey()
+    return squareFor(this.quilt, branch) ? null : { branch }
+  }
+
+  /**
+   * The app's Open a square (status `squareless`): the same ask the first refused write makes
+   * (openBranchSquare, the relay's quilt-open, as this member), with what went wrong said, not only
+   * logged. { square, text }.
+   */
+  async openSquareHere () {
+    if (!this.quilt || this.quilt.layout !== 3 || !this.quilt.id) throw new Error('This session\'s code is not in Seam.')
+    if (!this.conn || !this.conn.connected) throw new Error('This folder is not connected to the relay; try again in a moment.')
+    const branch = this.squareBranchKey()
+    const at = squareFor(this.quilt, branch)
+    if (at) return { square: at.square, text: `${branch} has a square already: ${squareShort(at.square)}.` }
+    if (this.openingSquare) throw new Error(`A square for ${branch} is being opened already; your folder follows it in a moment.`)
+    let r
+    try { r = await this.openBranchSquare(branch, { quiet: false }) } catch (err) {
+      // A branch the relay never had (checked out in git after the move): nothing to start its square from.
+      if (/is not one of this session's branches/.test(err.message)) throw new Error(`${branch} was made after the session's code moved into Seam, so the session has nothing of it to start a square from. Check out a branch the session has (main, say) and your folder follows that branch's square; or ask the session's owner.`)
+      throw err
+    }
+    return { square: r.square, text: r.opened ? `Opened square ${squareShort(r.square)} for ${branch}: your folder follows it in a moment, with your files as its work, and your edits reach everyone on it.` : `${branch} has a square already: ${squareShort(r.square)}; your folder follows it in a moment.` }
+  }
+
+  /**
+   * The relay refused a write of this folder's to a read-only branch document (layout 3): said in
+   * the log, kept for status (quilt_status, the app), and told to this member's AI at its next call.
+   */
+  noteReadOnly (r) {
+    if (!r || !r.why) return
+    this.readOnly = { branch: r.branch || '', ...(r.square ? { square: String(r.square) } : {}), why: String(r.why).slice(0, 500), at: Date.now() }
+    this.log(`⚠️ ${this.readOnly.why}`)
+    this.notice(this.readOnly.why)
+    this.scheduleStatusWrite()
+    if (r.noSquare) this.openBranchSquare(r.branch || this.branchKey()).catch(() => {})
+  }
+
+  /**
+   * The session owner's app renews the room's read token (every folder reads its square with it)
+   * when the relay says it is missing, refused, or ends within a month: the relay holds no
+   * credential that can (server.js readTokenState), the owner's sign-in can. Checked whenever the
+   * relay says something of the quilt and every few hours; tried at most once an hour.
+   */
+  async renewReadToken () {
+    const q = this.quilt
+    if (!q || q.layout !== 3 || !this.isOwner || !this.conn || !this.conn.connected || !appSeamUrl() || this.stopped) return null
+    if (!this.readRenewTimer) { this.readRenewTimer = setInterval(() => this.renewReadToken().catch(() => {}), READ_RENEW_CHECK_MS); this.readRenewTimer.unref?.() }
+    const r = q.read || {}
+    if (!(r.renew || (r.ends && r.ends - Date.now() < READ_RENEW_BEFORE_MS))) return null
+    if (this.readRenewAt && Date.now() - this.readRenewAt < READ_RENEW_RETRY_MS) return null
+    this.readRenewAt = Date.now()
+    try {
+      const { token } = await this.seamMember().client(q.id, [])
+      const a = await this.conn.branchRequest({ op: 'quilt-shadow', token, quilt: q.slug || q.id }, { timeoutMs: QUILT_MOVE_TIMEOUT_MS })
+      if (a.read && a.read.renewed) this.log(`🧵 made a new read token for ${q.slug || q.id}${a.read.until ? ` (until ${a.read.until.slice(0, 10)})` : ''}: every folder reads its square with it.`)
+      return a
+    } catch (err) {
+      this.log(`⚠️ couldn't renew the session's read token for ${q.slug || q.id} (${err.message}); folders can't read their squares without it. quilt session migrate --shadow ${q.slug || q.id} tries again.`)
+      return null
+    }
+  }
+
+  /**
+   * The folder's branch has no square at layout 3 (the relay kept its edits in the branch's
+   * document): one is opened for it as this member (server.js quiltOpen), with the document and
+   * those edits, and the folder follows it when the relay says so. One ask at a time. `quiet: false`
+   * (the app's button, openSquareHere): a failure throws instead of only being logged.
+   */
+  async openBranchSquare (branch, { quiet = true, token: given = null } = {}) {
+    if (this.openingSquare || !this.quilt || !this.quilt.id || !this.conn || !this.conn.connected || !appSeamUrl()) {
+      if (quiet) return null
+      throw new Error(!appSeamUrl() ? 'Seam is turned off for this app (QUILT_SOURCE_URL=off).' : 'This folder is not connected to the relay; try again in a moment.')
+    }
+    this.openingSquare = true
+    try {
+      // `token`: the owner's sign-in a new session was made a quilt with (quilt-default.js).
+      const token = given || (await this.seamMember().client(this.quilt.id, [])).token
+      const r = await this.conn.branchRequest({ op: 'quilt-open', token, branch }, { timeoutMs: QUILT_MOVE_TIMEOUT_MS })
+      if (r.opened) this.log(`🧵 opened square ${squareShort(r.square)} for ${branch}, which had none: this folder follows it, with your edits.`)
+      // What is on disk is the new square's work: the folder is never written over as it starts to follow it (session-follow.js openHere).
+      this.folderWins = r.square
+      this.readOnly = null
+      this.scheduleStatusWrite()
+      return r
+    } catch (err) {
+      if (!quiet) throw err
+      this.log(`⚠️ couldn't open a square for ${branch} (${err.message}); your edits are kept in the session, and the next one asks again`)
+      return null
+    } finally { this.openingSquare = false }
+  }
+
+  /**
+   * 16 step 1: links the session to the quilt an import of its git remote fills (`quilt`; null
+   * unlinks), as the owner with `token`. The session stays as it is; quilt_history and the app
+   * read the quilt's log from then on.
+   */
+  async quiltShadowLink (token, quilt) {
+    if (!this.conn || !this.conn.connected) throw new Error('not connected to the relay; linking the session needs a connection')
+    if (!token) throw new Error('sign in first (quilt login, or set SEAM_TOKEN): the session is linked as its owner')
+    const r = await this.conn.branchRequest({ op: 'quilt-shadow', token, quilt: quilt || null }, { timeoutMs: QUILT_MOVE_TIMEOUT_MS })
+    if (r.read) {
+      const name = r.shadow.slug || r.shadow.id
+      const until = r.read.until ? ` (until ${r.read.until.slice(0, 10)})` : ''
+      return { ...r, text: r.read.renewed ? `The session has a new read token for ${name}${until}: every folder reads its square with it.` : `The session's read token for ${name} works${until}; nothing to renew.` }
+    }
+    const text = r.shadow ? `This session now reads the quilt ${r.shadow.slug || r.shadow.id}'s log (quilt_history); git stays its source of truth until the cut-over.` : r.was ? `This session no longer reads the quilt ${r.was.slug || r.was.id}.` : 'This session was not linked to a quilt.'
+    return { ...r, text }
+  }
+
+  /**
+   * Back to the branches (layout 2) from the kept branch documents, as the owner with `token`.
+   * The relay refuses while the quilt has open squares, unless each is named in `carried` (its
+   * work carried over by hand: seam diff <square> | git apply).
+   */
+  async quiltUnswitch (token, carried = []) {
+    if (!this.conn || !this.conn.connected) throw new Error('not connected to the relay')
+    if (!token) throw new Error('sign in first (quilt login, or set SEAM_TOKEN): going back reads the quilt\'s open squares as its owner')
+    const r = await this.conn.branchRequest({ op: 'quilt-unswitch', token, carried }, { timeoutMs: QUILT_MOVE_TIMEOUT_MS })
+    const lines = [r.shadow
+      ? `The session works from its branches and git again; it still reads the quilt ${r.shadow.slug || r.shadow.id}'s log.`
+      : 'The session works from its branches again; the squares keep their live documents.']
+    const quilt = (r.quilt && (r.quilt.slug || r.quilt.id)) || ''
+    const list = (a) => `${a.slice(0, 8).join(', ')}${a.length > 8 ? `, and ${a.length - 8} more` : ''}`
+    for (const k of r.kept || []) {
+      const sq = squareShort(k.square)
+      if (k.error) { lines.push(`No folder follows square ${sq} (${k.branch}) now, and the relay could not copy its work back (${k.error}): it is in the square (seam diff ${sq} --quilt ${quilt}) and on the relay.`); continue }
+      if (k.copied.length) lines.push(`No folder follows square ${sq} (${k.branch}) now, so the relay copied its work into ${k.branch}: ${list(k.copied)}.`)
+      if (k.uncommitted) lines.push(`Its live work could not be committed in Seam (${k.uncommitted}); what was copied is in ${k.branch}.`)
+      else if (k.commit) lines.push(`All of square ${sq}'s work stays readable in Seam at ${String(k.commit).slice(0, 12)} (seam diff ${sq} --quilt ${quilt}).`)
+      for (const x of k.left) lines.push(`Not copied into ${k.branch}: ${x.path}, ${x.why}${k.commit && !k.uncommitted ? `; get it with seam cat ${String(k.commit).slice(0, 12)} ${x.path} --quilt ${quilt}` : ''}.`)
+    }
+    return { ...r, text: lines.join('\n') }
+  }
+
   async syncBranchNow () {
     // A folder that can't bring commits in itself (no git here, or its fetch fails) asks the
     // relay to look at GitHub for its branch now (relay-upstream.js), as a hosted agent can.
@@ -4397,8 +5026,9 @@ export class Session extends EventEmitter {
    * Pushes the on-disk state of a path into the shared doc. Returns true if anything changed.
    * `pulled`: git brought this version (a pull), so it is not an edit of ours: never claimed, and counted as the pull's.
    */
-  ingest (rel, { pulled = false } = {}) {
-    if (!this.syncable(rel)) return false
+  /** `claim`: false keeps this edit from claiming (boxing) the file for us (leaveSquare: another member's work). */
+  ingest (rel, { pulled = false, same = false, claim: mayClaim = true } = {}) {
+    if (!this.syncable(rel) || this.inSquare || this.syncStopped) return false
     if (this.merging.has(rel)) return false // its offline merge hasn't run yet; see mergeOffline
     if (this.held()) { this.heldPaths.add(rel); return false } // git is at work in this folder; see onSettled
     if (this.pullWait.has(rel)) { if (!this.onDisk(rel)) return false; this.endPullWait(rel) } // made way for a pull: not a deletion
@@ -4407,7 +5037,7 @@ export class Session extends EventEmitter {
     if (this.downloading.has(rel)) return false // our copy is being replaced by a download
     if (this.writeFailed.has(rel)) return false // the shared version never reached the disk: what's there is no edit of ours
     // New ignore rules: a box of ours on a file they now leave out lets go (settleBoxesOnce).
-    if (IGNORE_FILES.includes(path.posix.basename(rel))) { this.ig = loadIgnore(this.root); this.settleBoxesSoon() }
+    if (IGNORE_FILES.includes(path.posix.basename(rel)) || rel === '.gitmodules') { this.ig = loadIgnore(this.root); this.settleBoxesSoon() }
     const disk = this.readDisk(rel)
     const boxed = this.boxedByOther(rel)
     if (boxed) {
@@ -4472,7 +5102,7 @@ export class Session extends EventEmitter {
     const quiltOwn = this.quiltOwnWrite === rel && disk && disk.key === this.quiltOwnKey
     if (quiltOwn) { this.quiltOwnWrite = null; this.quiltOwnKey = null }
     // With boxes, a deletion is boxed too: it reaches nobody else's folder until it's committed.
-    if ((disk || this.boxesOn()) && !pulled && !quiltOwn && this.ready && !this.seeding && changesIt && (!claim || this.autoClaims.has(rel) || this.unboxedOwn(rel, claim)) && this.aiMayBeEditing()) this.autoClaim(rel)
+    if (mayClaim && (disk || this.boxesOn()) && !pulled && !quiltOwn && this.ready && !this.seeding && changesIt && (!claim || this.autoClaims.has(rel) || this.unboxedOwn(rel, claim)) && this.aiMayBeEditing()) this.autoClaim(rel)
     if (!pulled && this.ownBox(rel)) this.settleBoxesSoon() // put back to what was committed, say: the box opens
 
     if (!disk) {
@@ -4552,7 +5182,8 @@ export class Session extends EventEmitter {
         texts = { before, after: disk.text }
         // Folders on one branch pull the same commits, often at the same moment: made under an id
         // taken from the change, the pull's edit is the same edit from each of them, and lands once.
-        detail = pulled ? asClient(this.bdoc, sameEditClient('pull', rel, this.files.has(rel) ? before : null, disk.text), put) : put()
+        // So is the square's work every folder brings back when a session leaves layout 3 (leaveSquare).
+        detail = pulled || same ? asClient(this.bdoc, sameEditClient(pulled ? 'pull' : 'square', rel, this.files.has(rel) ? before : null, disk.text), put) : put()
       }
       if (disk.exec) { if (this.modes.get(rel) !== 'x') this.modes.set(rel, 'x') } else if (this.modes.has(rel)) this.modes.delete(rel)
       this.notePresentHere(rel, this.entryBase())
@@ -4646,13 +5277,18 @@ export class Session extends EventEmitter {
    * `texts` is { before, after } for text files, so the chronology keeps the diff. `pulled`: a git pull
    * brought it: counted as the pull's, and left out of the activity log (notePull writes one line for it all).
    */
-  recordActivity (rel, kind, detail, texts, { pulled = false } = {}) {
+  recordActivity (rel, kind, detail, texts, { pulled = false, activity = true } = {}) {
     const now = Date.now()
     this.tally(rel, kind, detail, now, texts, pulled)
     // A folder's starting copy of a branch (seeding) is nobody's change and no task's: it is on record, but never blamed or counted as unpublished work.
     this.history.record({ by: this.name, path: rel, kind, detail, before: texts?.before, after: texts?.after, task: pulled || this.seeding ? null : this.currentTask(), pulled, seed: !!this.seeding, ts: now })
     // A pull is logged once by notePull; a starting copy (seeding) is nobody's edit, so the file tree names no one for it.
-    if (pulled || this.seeding) return
+    if (pulled || this.seeding || !activity) return
+    this.pushActivity(rel, kind, detail, now)
+  }
+
+  /** The room's activity log: one entry for a change of ours (bursts to one file fold into one). */
+  pushActivity (rel, kind, detail, now = Date.now()) {
     const last = this.lastActivityPush.get(rel)
     // Collapse bursts of edits to the same file into one entry.
     if (kind === 'edited' && last && now - last < 20000) return
@@ -4741,6 +5377,7 @@ export class Session extends EventEmitter {
    * the others: it's noted in writeFailed and tried again later.
    */
   applyRemote (paths) {
+    if (this.inSquare || this.syncStopped) return
     const failed = []
     for (const p of paths) {
       try { this.fromRemote(p); this.writeFailed.delete(p) } catch { failed.push(p) }
@@ -4787,7 +5424,7 @@ export class Session extends EventEmitter {
   }
 
   writeOut (rel) {
-    if (!this.syncable(rel)) return
+    if (!this.syncable(rel) || this.inSquare || this.syncStopped) return
     if (this.ghost(rel)) return
     if (this.merging.has(rel)) return // mergeOffline writes this path once it has merged it
     if (this.held()) { this.heldPaths.add(rel); return } // written back when the hold ends (writeBack)
@@ -4833,7 +5470,7 @@ export class Session extends EventEmitter {
       this.lastKnown.set(rel, shared)
     }
     // New ignore rules: a box of ours on a file they now leave out lets go (settleBoxesOnce).
-    if (IGNORE_FILES.includes(path.posix.basename(rel))) { this.ig = loadIgnore(this.root); this.settleBoxesSoon() }
+    if (IGNORE_FILES.includes(path.posix.basename(rel)) || rel === '.gitmodules') { this.ig = loadIgnore(this.root); this.settleBoxesSoon() }
 
     if (this.ready && !this.arriving) { // a move writing its branch onto the folder is no partner's change
       this.emit('file-changed', { path: rel, by: this.lastEditorOf(rel) || 'partner' })
@@ -4985,7 +5622,7 @@ export class Session extends EventEmitter {
 
   /** Tries failed uploads, downloads and writes again. */
   retryFailed () {
-    if (!this.ready || this.stopped) return
+    if (!this.ready || this.stopped || this.inSquare || this.syncStopped) return
     if (this.hold && this.hold.kind === 'switching' && !this.following) this.recheckSoon()
     const failed = [...this.retry]
     this.retry.clear()
@@ -5294,6 +5931,7 @@ export class Session extends EventEmitter {
 
   /** Stats the folder and queues every path that appeared, changed or vanished since the last scan. */
   scanDisk ({ baseline = false } = {}) {
+    if (this.inSquare || this.syncStopped) return
     const seen = new Set()
     for (const rel of walk(this.root, this.ig)) {
       let st
@@ -5339,7 +5977,7 @@ export class Session extends EventEmitter {
 
   /**
    * Joins, updates or leaves the session's voice call (src/voice.js): `v` is null to leave, or
-   * { muted, sig, transcribing } from the app window, which does the audio. Only people talk.
+   * { muted, sig, transcribing, sharing } from the app window, which does the audio. Only people talk.
    */
   setVoice (v) {
     if (!this.conn || !this.conn.awareness) throw new Error('Not connected to the session yet.')
@@ -5524,6 +6162,8 @@ export class Session extends EventEmitter {
   requestCommit (message, { files = null, task = null, via = null, by = null, id = null, description = '', quiet = false } = {}) {
     message = String(message || '').trim().slice(0, MAX_MESSAGE)
     if (this.access && this.access.state === 'approved' && this.access.role === 'viewer') throw new Error('viewers can’t ask for commits')
+    // In Seam nobody waits on someone with git: whoever is on a square commits it.
+    if (this.quilt && this.quilt.layout === 3) throw new Error('This session\'s code is committed in Seam, so there is no one to ask: commit your square yourself (the square button at the top of the app, quilt commit "<message>", or seam_commit for an AI).')
     // A commit request is a message to the host: the relay undoes it from someone who may not post.
     if (!this.mayTalk()) throw new Error(TALK_REFUSED)
     const t = task ? this.taskList().find((x) => x.id === String(task)) : null
@@ -5634,9 +6274,91 @@ export class Session extends EventEmitter {
   historyQuery ({ path, by, since, task, limit } = {}) {
     const from = parseSince(since)
     if (from === undefined) throw new Error('since: use a duration like 2h or 3d, "today", "yesterday", or a date')
-    return queryHistory(this.history.entries(), { path, by, since: from ?? undefined, task, limit: Math.min(Number(limit) || 50, 500) })
+    // Once the session is a quilt (the relay says so, src/server.js branchesFields), older changes are its legacy tail.
+    const entries = legacyTail(this.history.entries(), { at: this.quilt && this.quilt.at, history: !!(this.quilt && this.quilt.history) })
+    return queryHistory(entries, { path, by, since: from ?? undefined, task, limit: Math.min(Number(limit) || 50, 500) })
+  }
+
+  /**
+   * quilt_history: historyQuery, and in a session linked to a quilt (Seam on, the relay says the
+   * session is a quilt or shadows one, 16) the quilt's log merged in (quilt-history.js): read as
+   * this member (seamMember: SEAM_TOKEN, else the session's Quilt sign-in, the same member as the
+   * Seam tools), else through the relay with the room's read token.
+   * { entries, note? }; the diffs of the log's commits only when `with_diff`.
+   */
+  async historyLinked ({ path: p, by, since, task, limit, with_diff: withDiff } = {}) {
+    // The relay says whether the room is linked (it has Seam on; this app may not): its read token answers then.
+    const link = this.quiltLink()
+    if (!link) return { entries: this.historyQuery({ path: p, by, since, task, limit }) }
+    const from = parseSince(since)
+    if (from === undefined) throw new Error('since: use a duration like 2h or 3d, "today", "yesterday", or a date')
+    const own = legacyTail(this.history.entries(), { at: this.quilt && this.quilt.at, history: !!(this.quilt && this.quilt.history) })
+    const query = { path: p || '', by, since: from ?? undefined, task, limit: Math.min(Number(limit) || 50, 500), withDiff: !!withDiff }
+    const quilt = { id: link.id, slug: link.slug || '' }
+    const api = this.seamApiUrl ?? appSeamUrl()
+    // As this member; one Seam would not let in (an agent with no member row, say) is not asked again for a
+    // minute. No sign-in yet is not Seam's answer: a sign-in made meanwhile (quilt login, SEAM_TOKEN) is used at once.
+    let seam = null
+    if (api && !(this.historySeamOff && Date.now() - this.historySeamOff < HISTORY_SEAM_OFF_MS)) {
+      try { seam = (await this.seamMember().client(quilt.id, [], { read: true, retry: false })).client } catch (err) { if (err.status) this.historySeamOff = Date.now() }
+    }
+    if (seam) {
+      // No retries: Seam down falls back to the relay's read at once.
+      const r = await linkedHistory({ seam, quilt, entries: own, query })
+      if (!r.note) return { entries: r.list }
+    }
+    let got = null
+    try { got = this.conn && this.conn.connected ? await this.conn.branchRequest({ op: 'quilt-log', query: { ...query, with_diff: !!withDiff } }) : null } catch (err) { got = { note: `Seam's log for ${quilt.slug || quilt.id} could not be read (${err.message}); this is the session's own record.` } }
+    const note = !got ? `Seam's log for ${quilt.slug || quilt.id} was not read: this folder is not connected to the relay.` : got.note || ''
+    return { entries: mergeLinked(own, (got && got.entries) || [], { ...query, logRead: !note }), ...(note ? { note } : {}) }
+  }
+
+  /** The quilt the relay says this session is, or shadows (16 step 1): { id, slug, shadow, at? }, or null. */
+  quiltLink () {
+    const l = this.quilt || this.quiltShadow
+    // `layout: 3`: the session's files are in its squares (the app's source control is Seam's then).
+    return l && l.id ? { id: l.id, slug: l.slug || '', shadow: !this.quilt, ...(this.quilt && this.quilt.at ? { at: this.quilt.at } : {}), ...(this.quilt && this.quilt.layout === 3 ? { layout: 3 } : {}) } : null
+  }
+
+  /**
+   * A file's History in the app, in a session linked to a quilt: its live changes not in the
+   * quilt's log yet, then the patches that touched it (each newest first), the same chronology
+   * quilt_history gives agents. null when the session is not linked.
+   */
+  async fileHistory (file) {
+    const quilt = this.quiltLink()
+    if (!quilt) return null
+    // The app asks again after every save to the file: the log is read at most every 30 s a file.
+    const logs = this.fileLogs || (this.fileLogs = new Map())
+    let got = logs.get(file)
+    if (!got || got.quilt !== quilt.id || Date.now() - got.at > FILE_LOG_MS) {
+      const { entries, note } = await this.historyLinked({ path: file, limit: 100 })
+      got = { quilt: quilt.id, at: Date.now(), patches: entries.filter((e) => e.seam).reverse(), note: note || '' }
+      logs.delete(file)
+      logs.set(file, got)
+      if (logs.size > 50) logs.delete(logs.keys().next().value)
+    }
+    const newest = got.patches.length ? got.patches[0].ts : 0
+    // What git brought in is the log's, once the log was read; the session's starting copy (seed) is nobody's live work.
+    const live = this.history.entries().filter((e) => e.path === file && e.ts > newest && !e.seed && !(e.pulled && !got.note)).reverse()
+    return { quilt, live, patches: got.patches, ...(got.note ? { note: got.note } : {}) }
+  }
+
+  /** A read of the linked quilt through the relay, with the room's read token: { quilt: null } when the session is not linked. */
+  async quiltRead (req) {
+    if (!this.quiltLink()) return { quilt: null }
+    if (!this.conn || !this.conn.connected) throw new Error('This folder is not connected to the relay.')
+    const { id, op, ...r } = await this.conn.branchRequest(req)
+    return r
   }
 
+  /** Who wrote each line of a file on main (Seam's blame); { working: true } while Seam works it out. */
+  quiltBlame (file) { return this.quiltRead({ op: 'quilt-blame', path: file }) }
+  /** Code search over main. */
+  quiltSearch (q) { return this.quiltRead({ op: 'quilt-search', q }) }
+  /** One patch of the log: its files and the diff of `file`. */
+  quiltShow (commit, file) { return this.quiltRead({ op: 'quilt-show', commit, path: file }) }
+
   /** `input` is a title, or { title, assignee, forAi, to_ai, tool, files }. "me" means this person. */
   addTask (input) {
     const fields = typeof input === 'string' ? { title: input } : { ...(input || {}) }
@@ -6038,7 +6760,20 @@ export class Session extends EventEmitter {
    * agents may push here. The agent then works and pushes there like anyone; the pull request opens
    * by itself. Returns the branch, or null when nothing was done (people's folders, no git, already on its own branch).
    */
-  async branchForTask (task) {
+  branchForTask (task) { return this.branchMove(() => this.branchForTaskNow(task)) }
+
+  /**
+   * One branch move at a time in this agent's folder: a task's new branch (branchForTask) and leaving
+   * a merged one (leaveMergedBranch) both check out; at once, they fought over git's index, or the
+   * second undid the first (an agent taking a task as its last one's branch merged got no branch).
+   */
+  branchMove (fn) {
+    const p = (this.branchMoves || Promise.resolve()).then(fn)
+    this.branchMoves = p.catch(() => {})
+    return p
+  }
+
+  async branchForTaskNow (task) {
     if (this.kind !== 'agent' || !this.git || !this.git.branch || !task || !task.title || !this.canCommitHere()) return null
     const prefix = agentPrefix(this.name)
     const settle = async () => { for (let i = 0; i < 20 && (this.hold || gitBusy(this.root, gitDir(this.root))); i++) await new Promise((r) => setTimeout(r, 250)) }
@@ -6089,7 +6824,9 @@ export class Session extends EventEmitter {
    * its own the merge didn't take (changes not committed, or commits the session's record of the branch
    * hasn't), the folder checks out the branch it merged into and brings it up to date. Returns the branch, or null.
    */
-  async leaveMergedBranch (b) {
+  leaveMergedBranch (b) { return this.branchMove(() => this.leaveMergedBranchNow(b)) }
+
+  async leaveMergedBranchNow (b) {
     const here = b.key
     const into = this.branchList.some((x) => x.key === b.merged.into) ? b.merged.into : (this.branchList.find((x) => x.default) || {}).key || 'main'
     if (!into || into === here) return null
@@ -6252,14 +6989,32 @@ export class Session extends EventEmitter {
     if (!dirty) return null
     const rels = [...dirty.keys()].filter((rel) => this.syncable(rel))
     const history = this.history.entries()
-    // Each changed line is put down to whoever added or removed it last; a file git or this folder
-    // can't give as text falls back to who edited it since it was last committed.
-    const before = await filesAt(this.root, 'HEAD', rels.filter((rel) => dirty.get(rel) !== 'A')) || new Map()
-    const editors = new Map()
     const byPath = new Map()
     for (const h of history) { if (h && h.path) { if (!byPath.has(h.path)) byPath.set(h.path, []); byPath.get(h.path).push(h) } }
-    const rest = []
+    // Who changed a file is worked out again only when the file, its history or HEAD changed since the
+    // last look. Done for every file every two minutes (reviewCommits), reading each one and its copy
+    // at HEAD and diffing them, it held hundreds of MB at a time in a folder far from its HEAD.
+    const head = ((await this.gitOut(['rev-parse', '--verify', '-q', 'HEAD'])) || '').trim()
+    const keyOf = (rel) => {
+      let st = null
+      try { st = fs.statSync(path.join(this.root, rel)) } catch {}
+      const h = byPath.get(rel) || []
+      return `${head} ${dirty.get(rel)} ${st ? `${st.size} ${st.mtimeMs}` : '-'} ${h.length} ${h.length ? h[h.length - 1].ts : 0}`
+    }
+    const cache = (this.editorsCache ||= new Map())
+    const editors = new Map()
+    const todo = new Map() // rel -> its key
     for (const rel of rels) {
+      const key = keyOf(rel)
+      const c = cache.get(rel)
+      if (c && c.key === key) editors.set(rel, c.names)
+      else todo.set(rel, key)
+    }
+    // Each changed line is put down to whoever added or removed it last; a file git or this folder
+    // can't give as text falls back to who edited it since it was last committed.
+    const before = todo.size ? await filesAt(this.root, 'HEAD', [...todo.keys()].filter((rel) => dirty.get(rel) !== 'A')) || new Map() : new Map()
+    const rest = []
+    for (const rel of todo.keys()) {
       const was = dirty.get(rel) === 'A' ? '' : before.get(rel)
       let now = ''
       if (dirty.get(rel) !== 'D') { try { now = fs.readFileSync(path.join(this.root, rel), 'utf8') } catch { now = null } }
@@ -6267,6 +7022,8 @@ export class Session extends EventEmitter {
       editors.set(rel, blameChange({ before: was, after: now, entries: byPath.get(rel) || [] }))
     }
     if (rest.length) for (const [rel, names] of editorsSince(rest, history, await lastCommitted(this.root))) editors.set(rel, names)
+    for (const [rel, key] of todo) cache.set(rel, { key, names: editors.get(rel) })
+    for (const rel of cache.keys()) if (!dirty.has(rel)) cache.delete(rel)
     const st = this.commitStatus({ includeMe: false })
     const busy = st.busy.map((b) => b.name)
     const claims = [...this.claims.values()]
@@ -6404,8 +7161,9 @@ export class Session extends EventEmitter {
     if (!client) return
     this.agents.add(String(client).slice(0, 80))
     this.conn.awareness.setLocalStateField('agents', [...this.agents])
-    const used = toolLabel(client)
-    if (this.toolGuessed && KNOWN_TOOLS.has(used) && used !== this.tool) {
+    // The AI that connects is the tool this person uses, whatever Settings says (toolInUse).
+    const used = toolInUse(this.tool, this.agents)
+    if (used !== this.tool) {
       this.tool = used
       this.conn.awareness.setLocalStateField('tool', used)
     }
@@ -7094,7 +7852,7 @@ export class Session extends EventEmitter {
 
   /** settleBoxes in a moment: after a commit, a file put back, or an edit to one of our boxed files. */
   settleBoxesSoon (ms = SETTLE_BOXES_MS) {
-    if (this.stopped || !this.git || this.settleBoxesTimer) return
+    if (this.stopped || !this.git || this.settleBoxesTimer || this.inSquare || this.syncStopped) return
     this.settleBoxesTimer = setTimeout(() => {
       this.settleBoxesTimer = null
       this.settleBoxes().catch((err) => this.log(`could not look at your boxes: ${err.message}`))
@@ -7458,6 +8216,7 @@ export class Session extends EventEmitter {
    * claim that covers a path that isn't a claim itself }.
    */
   async releaseReport (pattern = '*', via = null) {
+    if (this.quilt && this.quilt.id && this.quilt.layout === 3) return this.releaseInSeam(String(pattern || '*'), via)
     const r = await this.conn.claimRequest({ op: 'release', pattern: String(pattern), ...this.as(via) })
     if (r.released) this.noteActivity(`Released ${pattern === '*' ? 'all my claims' : pattern}`, { via })
     const out = { released: r.released || 0 }
@@ -7465,6 +8224,27 @@ export class Session extends EventEmitter {
     return out
   }
 
+  /**
+   * releaseReport at layout 3, where claims are Seam's (seam-claims.js): this member lets go of theirs
+   * in Seam as themselves (seamMember), the claims the move made for them included, though the mover
+   * holds those in Seam (the relay says which: quilt-claims). One someone waits for is kept (`held`):
+   * Seam hands it on with a note instead.
+   */
+  async releaseInSeam (pattern = '*', via = null) {
+    if (!this.conn) throw new Error('not connected to the relay')
+    let asked
+    try { asked = await this.conn.claimRequest({ op: 'quilt-claims', ...this.as(via) }) } catch (err) {
+      // A relay from before 0.3.132 can't say whose the move's claims were: let go of nothing rather than someone else's.
+      throw new Error(`The relay could not say whose this session's claims are (${err.message}), so none was let go of. Try again once the relay is updated, or let go of one in Seam (seam unclaim <claim> --quilt ${this.quilt.slug || this.quilt.id}).`)
+    }
+    const { gone, ...r } = await releaseInSeam({ access: this.seamMember(), api: this.seamApiUrl ?? appSeamUrl(), quilt: this.quilt.id, asked, pattern })
+    if (gone.length) {
+      await this.conn.claimRequest({ op: 'quilt-released', ids: gone, ...this.as(via) }).catch(() => {})
+      this.noteActivity(`Released ${pattern === '*' ? 'all my claims' : pattern}`, { via })
+    }
+    return r
+  }
+
   /**
    * The session's boxes as the app shows them (boxes.js): each with what it changes from the version
    * this folder has. Someone else's: from this folder's version before the box (what is on disk);
@@ -7883,9 +8663,12 @@ export class Session extends EventEmitter {
     const fromGithub = (p) => { const v = gh && gh.get(p); return v && typeof v.sha === 'string' ? { sha: v.sha, by: v.by || '', at: v.at || 0, came: v.came || 0, subject: v.subject || '' } : null }
     const out = []
     // A diff branch's files the session never changed are the folder's own checkout's (branch-view.js): listed too.
-    const listed = this.diffForm ? new Set([...this.sharedPaths(), ...[...this.gitOnly.keys()].filter((p) => this.followsGit(p) && this.onDisk(p))]) : this.sharedPaths()
+    // Following a square in place (layout 3), the folder is the square's live copy: listed from disk.
+    const square = this.squareFiles()
+    const listed = square ? new Set(square.keys()) : this.diffForm ? new Set([...this.sharedPaths(), ...[...this.gitOnly.keys()].filter((p) => this.followsGit(p) && this.onDisk(p))]) : this.sharedPaths()
     for (const p of listed) {
       if (!isSafeRelPath(p)) continue
+      if (square) { out.push({ path: p, binary: square.get(p), edited: edited.get(p) || null, claim: claimFor(p), github: null }); continue }
       const blob = this.blobs.get(p)
       out.push({ path: p, binary: blob ? !this.files.has(p) : this.diffForm && this.files.has(p) === false && /^bin:/.test(String(this.gitOnly.get(p) || '')), edited: edited.get(p) || null, claim: claimFor(p), github: fromGithub(p) })
     }
@@ -7910,7 +8693,46 @@ export class Session extends EventEmitter {
     return out
   }
 
-  /** Contents of one shared file, straight from the shared doc (never from disk); a chat file from the chat files folder. */
+  /**
+   * While the folder follows its square in place (layout 3, session-follow.js), the folder IS the
+   * square's live copy: every edit of everyone on the square comes to disk, and the branch document
+   * the session synced with is frozen, read-only, for a move back. So the app's Files and file views
+   * read the folder then: path -> whether it is binary (sniffed once per size and time), or null when
+   * the folder does not follow a square.
+   */
+  squareFiles () {
+    if (!this.inSquare) return null
+    const seen = this.squareSniff || (this.squareSniff = new Map()) // path -> { key, binary }
+    const out = new Map()
+    for (const rel of walk(this.root, this.ig)) {
+      if (!this.syncable(rel)) continue
+      let st
+      try { st = fs.statSync(path.join(this.root, rel)) } catch { continue }
+      const key = `${st.size}:${st.mtimeMs}`
+      let c = seen.get(rel)
+      if (!c || c.key !== key) {
+        let binary = st.size > MAX_TEXT_BYTES
+        if (!binary) { try { binary = looksBinary(fs.readFileSync(path.join(this.root, rel))) } catch { continue } }
+        c = { key, binary }
+        seen.set(rel, c)
+      }
+      out.set(rel, c.binary)
+    }
+    for (const rel of seen.keys()) if (!out.has(rel)) seen.delete(rel)
+    return out
+  }
+
+  /** One file of the folder while it follows its square (squareFiles): its bytes, or null when the session doesn't sync it or it is not there. */
+  squareFileBytes (rel) {
+    if (!this.syncable(rel)) return null
+    try {
+      const p = path.join(this.root, rel)
+      if (!fs.statSync(p).isFile()) return null
+      return fs.readFileSync(p)
+    } catch { return null }
+  }
+
+  /** Contents of one shared file, straight from the shared doc (never from disk, but for a folder following its square: squareFiles); a chat file from the chat files folder. */
   readShared (rel) {
     rel = String(rel || '').replace(/^\.\//, '')
     if (!isSafeRelPath(rel)) return null
@@ -7920,6 +8742,11 @@ export class Session extends EventEmitter {
       const buf = fs.readFileSync(path.join(this.root, rel))
       return buf.length <= MAX_TEXT_BYTES && !looksBinary(buf) ? { path: rel, text: buf.toString('utf8'), chat: e.chat } : { path: rel, binary: true, size: buf.length, chat: e.chat }
     }
+    if (this.inSquare) {
+      const buf = this.squareFileBytes(rel)
+      if (!buf) return null
+      return buf.length <= MAX_TEXT_BYTES && !looksBinary(buf) ? { path: rel, text: buf.toString('utf8') } : { path: rel, binary: true, size: buf.length }
+    }
     const t = this.files.get(rel)
     if (t) return { path: rel, text: t.toString() }
     const b = this.blobs.get(rel)
@@ -7939,6 +8766,10 @@ export class Session extends EventEmitter {
       if (!this.chatFileEntries().some((x) => x.path === rel)) return null
       return { path: rel, buf: fs.readFileSync(path.join(this.root, rel)) }
     }
+    if (this.inSquare) {
+      const buf = this.squareFileBytes(rel)
+      return buf ? { path: rel, buf } : null
+    }
     const t = this.files.get(rel)
     if (t) return { path: rel, buf: Buffer.from(t.toString(), 'utf8') }
     const b = this.blobs.get(rel)
@@ -7963,7 +8794,8 @@ export class Session extends EventEmitter {
       const git = cleanGit(s.git)
       peers.push({
         name: s.name,
-        tool: s.tool,
+        // An older app keeps its person's stale tool after their AI connects: show the AI that did.
+        tool: toolInUse(s.tool, s.agents || []),
         color: s.color,
         kind: s.kind || 'human',
         // A person's cloud AI (its relay checked whose): one of that person's AI sessions.
@@ -7994,15 +8826,33 @@ export class Session extends EventEmitter {
       const t = typing.get(p.name)
       if (t) { p.typing = true; if (t.to) p.typingTo = t.to }
       const v = voices.get(p.name)
-      if (v && !p.persona) p.voice = { muted: v.muted, ...(v.transcribing ? { transcribing: true } : {}) }
+      if (v && !p.persona) p.voice = { muted: v.muted, ...(v.transcribing ? { transcribing: true } : {}), ...(v.sharing ? { sharing: true } : {}) }
     }
     const myVoice = voices.get(this.name)
+    const square = this.squareFollower ? this.squareFollower.status() : null
     return {
       room: this.room,
       server: this.server,
       branch: this.branch,
       connected: !!(this.conn && this.conn.connected),
       ...(this.relayProblem ? { problem: this.relayProblem } : {}),
+      // The quilt the session is linked to (the app's History, Blame and search read it through the relay).
+      ...(this.quiltLink() ? { quilt: this.quiltLink() } : {}),
+      // At layout 3: the square this folder follows, with its one line (session-follow.js), and a write the relay could not keep.
+      ...(square ? { square } : {}),
+      // In Seam: each branch's square, as Seam names it (the app's sidebar shows who is on which).
+      ...(this.quilt && this.quilt.layout === 3 ? { squares: Object.fromEntries(Object.entries(this.quilt.live || {}).filter(([, k]) => typeof k === 'string' && k.startsWith('quilt/')).map(([b, k]) => [b, squareShort(k.slice('quilt/'.length))])) } : {}),
+      // The owner is moving the session into Seam or back right now (the relay's `moving`): { kind, since, line }.
+      ...(this.moving ? { moving: { ...this.moving, line: movingLine(this.moving) } } : {}),
+      // The forced date (16 flag 9): live sync stopped here (`stopped`), or when it is ({ at, remote }).
+      ...(this.force ? { force: this.force } : {}),
+      // "Make this a quilt" on a session with a git remote: Seam importing it ({ slug, repo }), or linked (quiltShadow).
+      ...(this.quiltImporting ? { importing: this.quiltImporting } : {}),
+      ...(this.quiltShadow ? { shadow: this.quiltShadow } : {}),
+      // The folder's branch has no square in the quilt (openSquareHere; the app's button opens one).
+      ...(!square && this.squareless() ? { squareless: this.squareless() } : {}),
+      // Until the folder follows a square, its edits reach nobody: said until it does.
+      ...(this.readOnly && this.quilt && this.quilt.layout === 3 && !(square && !square.opening && !square.problem) ? { readOnly: this.readOnly } : {}),
       access: this.access,
       sessionName: this.sessionName,
       members: this.members,
@@ -8022,7 +8872,7 @@ export class Session extends EventEmitter {
         color: this.conn?.awareness.getLocalState()?.color,
         agent: { ...(this.agentState || { status: 'idle' }), sharing: this.agentSharing, summarized: !!this.summarizer },
         work: this.work,
-        ...(myVoice && myVoice.me ? { voice: { muted: myVoice.muted, ...(myVoice.transcribing ? { transcribing: true } : {}) } } : {})
+        ...(myVoice && myVoice.me ? { voice: { muted: myVoice.muted, ...(myVoice.transcribing ? { transcribing: true } : {}), ...(myVoice.sharing ? { sharing: true } : {}) } } : {})
       },
       // The session's call: whether the owner has transcripts on.
       voice: { transcribe: transcribeSetting(this.doc, this.members).on },
@@ -8076,7 +8926,9 @@ export class Session extends EventEmitter {
     for (const t of this.rechecks.values()) clearTimeout(t)
     this.rechecks.clear()
     clearInterval(this.reconcileTimer)
+    clearInterval(this.readRenewTimer)
     clearInterval(this.upstreamPoll)
+    if (this.squareFollower) await this.squareFollower.stop()
     clearTimeout(this.clashTimer)
     if (this.clashPending) clearTimeout(this.clashPending.timer)
     clearTimeout(this.upstreamTimer)
@@ -8090,6 +8942,7 @@ export class Session extends EventEmitter {
     clearTimeout(this.typingExpiryTimer)
     if (this.conn) this.conn.close()
     this.saveState()
+    this.emit('stopped')
     await new Promise((r) => setTimeout(r, 100))
   }
 }