heyquilt 0.3.121 → 0.3.138

package/src/now-summary.js

@@ -0,0 +1,113 @@
+// The website dashboard's summary of now (plans/dashboard ticket 9): for one person, what is going on in
+// a session this relay holds. Who is in it and what each AI is doing, the board in brief, the latest
+// file changes, held files and who waits for them, and what needs this person: messages to them not
+// answered, tasks for them, files someone waits for from them, and, for the owner, commit requests and
+// people asking to join. The accounts API asks for it (GET /v1/me/now, every 15 to 30 seconds from the
+// page) and merges what each relay machine says; nothing here is streamed or stored.
+import { waitingOn } from './duties.js'
+import { readTasks, activeTasks } from './tasks.js'
+
+export const NOW_LIMITS = { people: 24, recent: 8, detailRecent: 80, held: 24, needs: 24, text: 160 }
+const EDIT_FRESH_MS = 4 * 60 * 1000 // a peer's edit counts as current this long (as relay-mcp.js)
+
+const clip = (s, n = NOW_LIMITS.text) => {
+  const t = String(s || '').replace(/\s+/g, ' ').trim()
+  return t.length > n ? `${t.slice(0, n - 1)}…` : t
+}
+
+/** The name `account` ('person:<id>') has in `room`, or '' when it isn't the owner or a member. */
+export function nameIn (room, account) {
+  const meta = room && room.meta
+  if (!meta || typeof account !== 'string') return ''
+  if (meta.ownerSub && meta.ownerSub === account) return meta.ownerName || 'owner'
+  const m = meta.members && Object.prototype.hasOwnProperty.call(meta.members, account) ? meta.members[account] : null
+  return m && !m.chat && typeof m.name === 'string' ? m.name : ''
+}
+
+/** The files a peer edited in the last few minutes, newest first. */
+function freshEdits (editing, now) {
+  return Object.entries(editing || {})
+    .filter(([, ts]) => Number.isFinite(ts) && now - ts < EDIT_FRESH_MS)
+    .sort((a, b) => b[1] - a[1])
+    .map(([p]) => p)
+}
+
+/** Who is in the room now, each with what their AI is doing. */
+function peopleIn (room, now) {
+  const out = []
+  const seen = new Set()
+  const states = room.awareness && room.awareness.getStates ? [...room.awareness.getStates().values()] : []
+  for (const s of states) {
+    if (!s || typeof s.name !== 'string' || !s.name || seen.has(s.name)) continue
+    seen.add(s.name)
+    const ag = s.agent || {}
+    const working = ag.sharing !== false && (ag.status === 'working' || (s.work && s.work.state === 'working'))
+    out.push({
+      name: clip(s.name, 64),
+      kind: s.kind === 'agent' ? 'agent' : 'person',
+      tool: clip(ag.tool || s.tool || '', 40),
+      ai: ag.sharing === false ? 'paused' : working ? 'working' : (ag.tool ? 'idle' : ''),
+      focus: clip(s.focus || (s.work && s.work.state === 'working' ? s.work.note : '') || '', 120),
+      editing: freshEdits(s.editing, now).slice(0, 3)
+    })
+  }
+  for (const h of room.hostedOnline ? room.hostedOnline() : []) {
+    if (!h || !h.name || seen.has(h.name)) continue
+    seen.add(h.name)
+    out.push({ name: clip(h.name, 64), kind: h.kind === 'agent' ? 'agent' : 'person', tool: 'hosted', ai: '', focus: '', editing: [] })
+  }
+  return out.slice(0, NOW_LIMITS.people)
+}
+
+/**
+ * The summary of `room` for `account`, or null when the account isn't in it. `now` is the time;
+ * `detail` (one session's page) keeps more of the latest file changes, for its Activity tab.
+ * The room is read through what Room already offers (server.js): meta, awareness, doc, claimList, pendingList.
+ */
+export function nowSummary (room, account, { now = Date.now(), detail = false } = {}) {
+  const me = nameIn(room, account)
+  if (!me) return null
+  const owner = !!(room.meta.ownerSub && room.meta.ownerSub === account)
+  const doc = room.doc
+  const chat = doc ? doc.getArray('chat').toArray() : []
+  const tasks = doc ? activeTasks(readTasks(doc.getMap('tasks'))) : []
+  const claims = room.claimList ? room.claimList() : []
+  const people = peopleIn(room, now)
+
+  const needs = []
+  for (const m of waitingOn(chat.filter((x) => x && (!x.to || x.to === me || x.by === me)), me, { now })) {
+    needs.push({ kind: m.kind, by: clip(m.by, 64), text: clip(m.text), at: m.ts })
+  }
+  for (const t of tasks) {
+    if (t.column === 'todo' && t.assignee === me && !t.forAi) needs.push({ kind: 'task', by: clip(t.by, 64), text: clip(t.title), at: t.ts, task: t.id })
+  }
+  for (const c of claims) {
+    if (c.by === me && c.queue && c.queue.length) needs.push({ kind: 'file', by: clip(c.queue[0].by, 64), text: clip(c.pattern, 200), at: c.queue[0].ts || c.ts, waiting: c.queue.length })
+  }
+  if (owner && doc) {
+    for (const r of doc.getMap('commitRequests').values()) {
+      if (r && r.id && r.state === 'open') needs.push({ kind: 'commit', by: clip(r.by, 64), text: clip(r.message), at: r.ts, files: Array.isArray(r.files) ? r.files.length : 0 })
+    }
+    for (const p of room.pendingList ? room.pendingList() : []) needs.push({ kind: 'join', by: clip(p.name, 64), text: p.kind === 'agent' ? 'An agent asks to join' : 'Asks to join', at: p.since, agent: p.kind === 'agent' })
+  }
+  needs.sort((a, b) => (b.at || 0) - (a.at || 0))
+
+  const byColumn = { todo: 0, doing: 0, qa: 0 }
+  for (const t of tasks) if (t.column in byColumn) byColumn[t.column]++
+  const recent = (doc ? doc.getArray('activity').toArray() : []).filter((x) => x && x.by).slice(-(detail ? NOW_LIMITS.detailRecent : NOW_LIMITS.recent)).reverse()
+    .map((x) => ({ by: clip(x.by, 64), kind: clip(x.kind, 20), path: clip(x.path || x.detail || '', 200), at: x.ts }))
+
+  return {
+    room: room.name,
+    name: clip(room.meta.name || '', 80),
+    me,
+    owner,
+    people,
+    working: people.filter((p) => p.ai === 'working').length,
+    tasks: { open: byColumn.todo + byColumn.doing + byColumn.qa, ...byColumn, mine: tasks.filter((t) => t.column !== 'done' && t.assignee === me).length },
+    recent,
+    held: claims.slice(0, NOW_LIMITS.held).map((c) => ({ path: clip(c.pattern, 200), by: clip(c.by, 64), box: !!c.box, waiting: (c.queue || []).map((q) => clip(q.by, 64)) })),
+    needs: needs.slice(0, NOW_LIMITS.needs),
+    at: now
+  }
+}

package/src/pathrules.js

@@ -20,6 +20,8 @@ export const CHAT_FILES = 'Chat files'
 // copies of the project.
 export const ALWAYS_IGNORED = [
   '.git', '.quilt', '.cowove', 'node_modules', '.DS_Store', 'Thumbs.db', '.claude/worktrees',
+  // A Seam block's own record (a folder checked out with seam checkout): Seam's, never the session's.
+  '.seam',
   `/${CHAT_FILES}`,
   // Each person's own Claude Code settings (permissions, Quilt's hooks) stay on their machine.
   '.claude/settings.local.json',
@@ -66,6 +68,16 @@ export function makeIgnore (texts = []) {
   }
 }
 
+/** The folders a .gitmodules text names as submodules (`path = …`), as safe relative paths. */
+export function submodulePathsIn (text) {
+  const out = []
+  for (const m of String(text || '').matchAll(/^\s*path\s*=\s*(.+?)\s*$/gm)) {
+    const p = m[1].replace(/^"(.*)"$/, '$1').replace(/\/+$/, '')
+    if (isSafeRelPath(p)) out.push(p)
+  }
+  return out
+}
+
 export function isIgnored (ig, rel) {
   if (!rel || rel === '.') return false
   // Check every ancestor directory so "dist/" also excludes "dist/a/b.js".

package/src/protocol.js

@@ -17,7 +17,7 @@ export const MSG_ADMIN = 14 // client (owner) -> relay: JSON { id, op: 'approve'
 export const MSG_MEMBERS = 15 // relay -> client: JSON { members, sessionName, pending?, reply?: { id, ok, error } }
 export const MSG_PASS = 16 // client -> relay: JSON { pass }: a fresh session pass, sent at least every 5 minutes
 export const MSG_BRANCH = 17 // client -> relay: JSON { id, op: 'join'|'confirm'|'remove', branch, base?, adopt?, sv? }
-export const MSG_BRANCHES = 18 // relay -> client: JSON { branches, reply?: { id, op, ok, error?, branch?, created?, base? } }
+export const MSG_BRANCHES = 18 // relay -> client: JSON { branches, quilt?, shadow?, reply?: { id, op, ok, error?, branch?, created?, base? } }
 
 // Every sync message names its document: the room's (chat, tasks, the feed, commit requests,
 // activity) is '', a branch's (its files) is the branch key. Git never allows an empty branch name.
@@ -25,7 +25,15 @@ export const ROOM_DOC = ''
 
 // What this app can do, sent when it connects. The relay turns away apps without what a session needs.
 // branch-diffs: this app reads a branch document that holds only what differs from git (branch-view.js).
-export const FEATURES = 'large-files,branches,branch-diffs'
+// quilts: this app works in a session whose files are in its squares' live documents (layout 3,
+// Seam's plans/quilt-source-control/16 flag 4: sent by every app before anyone opens a block).
+// quilt-folders: this app's folder follows its branch's square in place at layout 3 (session-follow.js);
+// an app with `quilts` but not this (0.3.125) kept syncing to the read-only branch documents.
+// quilt-moves: this app's folder follows a square whose base moves (main brought in): it re-projects onto
+// the new head, says which head each edit was made on, and takes in only its own edits. The relay brings
+// main into a square only when every folder on it can follow that (server.js outdatedOn); 0.3.133 and
+// 0.3.134, which can but don't say so, are known by their asking to bring main in.
+export const FEATURES = 'large-files,branches,branch-diffs,quilts,quilt-folders,quilt-moves'
 
 // WebSocket close codes the relay uses to refuse a client for good.
 export const CLOSE_AUTH_FAILED = 4401

package/src/quilt-default.js

@@ -0,0 +1,84 @@
+// New sessions are quilts from the start (Seam's plans/quilt-source-control/16, flags order 8,
+// QUILT_SOURCE_DEFAULT=1 on the accounts API): the app that starts a session (the desktop app,
+// `quilt start`, or an AI's quilt_start_session; every tool goes through the same Session) makes it
+// a quilt without history as soon as the folder's files have reached the relay: patch 1 holds them
+// (binaries and modes too), and the room moves to layout 3 with a square for the folder.
+//
+// Nothing is lost when it can't: a folder with a git remote is not made a quilt here (16: a room
+// with a git remote becomes a quilt only with its history, which flag 9's "Make this a quilt"
+// starts), and any failure leaves the session a working git-mode session, with the reason said to
+// the owner and their AIs and `quilt session migrate` to try again by hand.
+import { execFileSync } from 'node:child_process'
+import { apiUrl } from './account.js'
+
+const FEATURES_TIMEOUT_MS = 5000
+const SYNC_TRIES = 20
+const SYNC_WAIT_MS = 500
+
+/** Whether the accounts API at `api` has new sessions start as quilts (GET /v1/features `quilt_source_default`). False when it can't say. */
+export async function quiltDefaultOn ({ api = apiUrl(), fetch: fetchImpl = globalThis.fetch } = {}) {
+  try {
+    const res = await fetchImpl(`${String(api).replace(/\/+$/, '')}/v1/features`, { signal: AbortSignal.timeout(FEATURES_TIMEOUT_MS) })
+    if (!res.ok) return false
+    const f = await res.json()
+    return !!(f && f.quilt_source_default === true)
+  } catch { return false }
+}
+
+/** Whether the folder at `root` is a git repository with a remote (its history belongs in the quilt: 16 "With history"). */
+export function folderHasGitRemote (root) {
+  try {
+    return execFileSync('git', ['--no-optional-locks', 'remote'], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 10_000 }).trim().length > 0
+  } catch { return false }
+}
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+/**
+ * Makes the new session `session` a quilt (migrate, then the layout-3 switch) as its owner, once.
+ * Resolves to { done: true, quilt } or { done: false, why }; never throws.
+ */
+export async function startAsQuilt (session, { flagOn = quiltDefaultOn, credential, hasRemote = folderHasGitRemote, syncTries = SYNC_TRIES, syncWaitMs = SYNC_WAIT_MS } = {}) {
+  const skip = (why) => ({ done: false, why })
+  try {
+    if (!(await flagOn())) return skip('off')
+    if (session.stopped) return skip('stopped')
+    if (session.quilt) return skip('already a quilt')
+    if (session.root && hasRemote(session.root)) {
+      session.log('🧵 this folder has a git remote, so the new session stays on git: it becomes a quilt with its history later (Make this a quilt).')
+      return skip('git remote')
+    }
+    if (session.branchForm === 'diff') return skip('diff branch')
+    // The folder's files are its patch 1: they must all be on the relay first.
+    let synced = false
+    for (let i = 0; i < syncTries && !synced && !session.stopped; i++) {
+      if (session.ready && !session.seeding) {
+        try { session.flushPending?.() } catch {}
+        try { await session.conn.confirmBranch(); synced = true; break } catch {}
+      }
+      await wait(syncWaitMs)
+    }
+    if (session.stopped) return skip('stopped')
+    if (!synced) throw new Error("the folder's files had not all reached the relay")
+    if (session.quilt) return skip('already a quilt')
+    const token = await credential()
+    if (!token) throw new Error('no sign-in to reach Seam with')
+    const m = await session.quiltMigrate(token)
+    await session.quiltSwitch(token)
+    // The folder equals patch 1, so the switch opened no square for it: one is opened now, as the
+    // owner, and the folder follows it (16: a square for the session's first folder). Should that
+    // fail, the session is a quilt still, and the folder's first edit asks for its square (readOnly).
+    for (let i = 0; i < syncTries * 4 && !session.stopped && !(session.quilt && session.quilt.layout === 3); i++) await wait(syncWaitMs / 4)
+    const branch = typeof session.branchKey === 'function' ? session.branchKey() : session.branch
+    if (session.quilt && session.quilt.layout === 3 && !(session.quilt.live || {})[branch]) {
+      try { await session.openBranchSquare(branch, { quiet: false, token }) } catch (err) { session.log(`🧵 couldn't open a square for this folder yet (${err.message}); its first edit asks again.`) }
+    }
+    session.log(`🧵 new session: its code is in Seam from the start (quilt ${(m.quilt && m.quilt.slug) || ''}, patch 1).`)
+    return { done: true, quilt: m.quilt }
+  } catch (err) {
+    const why = String((err && err.message) || err)
+    session.log(`🧵 this new session's code could not go into Seam (${why}); the session works as before, on git. The owner can try again with: quilt session migrate`)
+    if (session.notice) { try { session.notice(`This new session's code could not go into Seam (${why}), so it stays on git for now. The session owner can try again with \`quilt session migrate\`.`) } catch {} }
+    return skip(why)
+  }
+}

package/src/quilt-history.js

@@ -0,0 +1,106 @@
+// quilt_history in a session linked to a quilt (Seam's plans/quilt-source-control/16, step 1
+// "Shadow", and after the session became a quilt): the chronology is Seam's log (the commits and
+// patches, imported from git or made in Seam) plus the session's own live record of changes not
+// committed yet (the branch document's `history`, history.js), oldest first, newest kept.
+//
+// Quilt reads Seam over its HTTP API (a client with the @heyquilt/seam quiltClient shape: `log`,
+// `show`), as the member (Session.seamMember) or, on the relay, with the room's read token. When
+// Seam can't be read, the session's own record is shown with a note, never an error: the tool
+// worked before the link and keeps working without Seam. The same for every AI tool: this runs
+// behind quilt_history in both MCP servers (mcp.js through the folder's daemon, relay-mcp.js).
+import { MAX_DIFF_CHARS, queryHistory } from './history.js'
+
+/**
+ * The quilt a room's chronology reads from: `{ id, slug, at?, shadow? }`, or null. A quilt the
+ * session became (meta.quilt_id), or the quilt it shadows while git is still the authority
+ * (meta.quiltShadow, 16 step 1: an import following the session's git remote). Only with Seam
+ * on (QUILT_SOURCE_URL), so every other session reads its own record exactly as before.
+ */
+export function historyQuilt (meta, env = process.env) {
+  if (!env || !env.QUILT_SOURCE_URL || !meta) return null
+  if (typeof meta.quilt_id === 'string' && meta.quilt_id) {
+    const q = meta.quilt || {}
+    return { id: meta.quilt_id, slug: q.slug || '', ...(q.at ? { at: q.at } : {}) }
+  }
+  const s = meta.quiltShadow
+  if (s && typeof s.id === 'string' && s.id) return { id: s.id, slug: s.slug || '', shadow: true }
+  return null
+}
+
+/** The part of a path or glob Seam's log can filter by: a file, or the folder before the first wildcard. */
+export function seamPathOf (p) {
+  const s = String(p || '').replace(/\\/g, '/').replace(/^\.\//, '')
+  if (!s) return ''
+  const wild = s.search(/[*?[{]/)
+  if (wild < 0) return s.replace(/\/+$/, '')
+  const dir = s.slice(0, wild)
+  return dir.includes('/') ? dir.slice(0, dir.lastIndexOf('/')) : ''
+}
+
+const MAX_SHOWN = 10 // commits whose diffs are read when asked for them
+
+/**
+ * The quilt's log as chronology entries, oldest first: one per commit, `{ seam: true, commit,
+ * short, patch, by, ts, message, files, task, diff }`. `since` is a timestamp. Throws what Seam
+ * said when it can't be read.
+ */
+export async function seamHistory (seam, quilt, { path = '', by, since, task, limit = 30, withDiff = false, rev = 'main' } = {}) {
+  const p = seamPathOf(path)
+  const r = await seam.log(quilt, { rev, limit: Math.min(Number(limit) || 30, 200), ...(p ? { paths: [p] } : {}), ...(by ? { author: by } : {}), ...(typeof since === 'number' ? { since: String(Math.floor(since)) } : {}), ...(task ? { task } : {}) })
+  const out = []
+  for (const c of (r && r.commits) || []) {
+    if (!c || !c.id) continue
+    const a = c.author || {}
+    out.push({
+      id: `seam:${c.id}`,
+      seam: true,
+      commit: c.id,
+      short: c.short || c.id.slice(0, 12),
+      ...(c.patch && c.patch.patch_no != null ? { patch: { line: c.patch.line || rev, no: c.patch.patch_no } } : {}),
+      by: String(a.name || a.member_id || ''),
+      ts: Number(c.at ?? c.authored_at) || 0,
+      message: String(c.message || '').split('\n')[0].slice(0, 200),
+      files: Number(c.files) || (Array.isArray(c.changes) ? c.changes.length : 0),
+      task: c.task_id ? { id: String(c.task_id), title: '' } : null,
+      path: p,
+      diff: ''
+    })
+  }
+  if (withDiff) {
+    for (const e of out.slice(0, MAX_SHOWN)) {
+      try {
+        const s = await seam.show(quilt, e.commit, { format: 'unified', ...(p ? { paths: [p] } : {}) })
+        const text = ((s && s.diff && s.diff.files) || []).map((f) => f.patch || (f.binary ? `${f.path}: binary` : '')).filter(Boolean).join('\n')
+        e.diff = text.length > MAX_DIFF_CHARS ? `${text.slice(0, MAX_DIFF_CHARS)}\n… (diff truncated)` : text
+      } catch { e.diff = '' }
+    }
+  }
+  return out.sort((x, y) => x.ts - y.ts)
+}
+
+/**
+ * The chronology of a linked session: the quilt's log (`seam`, a client) and the session's own
+ * record (`entries`, history.js), filtered by `query` (path, by, since timestamp, task, limit,
+ * withDiff), oldest first, the newest `limit` kept. A change git pulled into the session is the
+ * log's (an imported patch) and is left out of the session's record when the log answered, so it
+ * is not counted twice (16: "entries with `pulled` or `seed` are dropped", here only `pulled`:
+ * a seed is the session's first copy, which the log has no entry for). Returns { list, note }:
+ * `note` says why the log is missing, when it is.
+ */
+export async function linkedHistory ({ seam, quilt, entries = [], query = {} }) {
+  const { path = '', by, since, task, limit = 30, withDiff = false } = query
+  let fromSeam = []
+  let note = ''
+  if (!seam) note = `Seam's log for ${quilt.slug || quilt.id} was not read: the session has no read token for it (its owner links it again); this is the session's own record.`
+  else {
+    try { fromSeam = await seamHistory(seam, quilt.id, { path, by, since, task, limit, withDiff }) } catch (err) { note = `Seam's log for ${quilt.slug || quilt.id} could not be read (${String(err.message || err).slice(0, 200)}); this is the session's own record.` }
+  }
+  return { list: mergeLinked(entries, fromSeam, { ...query, logRead: !note }), note }
+}
+
+/** The session's own entries (filtered by `query`; git's pulls left out when `logRead`) with the log's, oldest first, the newest `limit`. */
+export function mergeLinked (entries, fromSeam, { path = '', by, since, task, limit = 30, logRead = true } = {}) {
+  const own = queryHistory(logRead ? entries.filter((e) => !(e && e.pulled)) : entries, { path, by, since, task, limit: 0 })
+  const list = [...own, ...(fromSeam || [])].sort((a, b) => a.ts - b.ts)
+  return limit && list.length > limit ? list.slice(-limit) : list
+}

package/src/quilt-remote.js

@@ -0,0 +1,78 @@
+// "Make this a quilt" for a session with a git remote (Seam's plans/quilt-source-control/16, flag 9, and
+// "An opt-in team's migration"): the steps the owner's one button runs, in order, each time it is
+// clicked, from where the session stands. Pure: no I/O (test/unit/quilt-remote.test.js).
+//
+//   1. import   Seam imports the GitHub repository and follows it (the owner's Seam GitHub App
+//               installation is the read credential; 16 step 1). The session stays git-mode.
+//   2. link     Once the import follows, the session reads the quilt's log (the shadow link).
+//   3. cut-over In the owner's sitting: main must take pushes from Seam's export only (a ruleset only
+//               the repository's GitHub owner can add: plain steps), then the import is cut over
+//               with export to the same remote on, then the session moves in with its history.
+
+export const SEAM_APP = { id: 5475977, slug: 'seam-by-heyquilt' }
+
+/** owner/name of the session's GitHub remote, from its upstreams (the default branch's first), or null. */
+export function githubRepoOf (upstreams, defaultKey) {
+  const all = Object.entries(upstreams || {})
+  const pick = all.find(([k]) => k === defaultKey) || all[0]
+  const m = pick && /^github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(\.git)?$/.exec(String((pick[1] && pick[1].repo) || ''))
+  return m ? m[1] : null
+}
+
+/** Which of the owner's Seam GitHub installations reaches `repo`, or null. */
+export function installationFor (gh, repo) {
+  const want = String(repo).toLowerCase()
+  return ((gh && gh.installations) || []).find((i) => (i.repos || []).some((r) => String(r.full_name || '').toLowerCase() === want)) || null
+}
+
+/** The step the session is at: 'import' (nothing yet), 'link' (importing), 'cutover' (linked to the quilt that follows). */
+export function remoteStage ({ quiltImport = null, quiltShadow = null }) {
+  if (quiltShadow) return 'cutover'
+  if (quiltImport) return 'link'
+  return 'import'
+}
+
+/** Whether GitHub's rules for main (GET /repos/:o/:r/rules/branches/main) keep everyone but an app from pushing to it. */
+export function mainGuarded (rules) {
+  return Array.isArray(rules) && rules.some((r) => r && r.type === 'update')
+}
+
+/** What the repository's GitHub owner does so only Seam pushes to main (16's cut-over checklist, step 5). */
+export function rulesetSteps (repo) {
+  return [
+    `On GitHub, open https://github.com/${repo}/settings/rules and choose New ruleset, then New branch ruleset.`,
+    'Name it "Seam is the authority on main" and set Enforcement status to Active.',
+    `Under Bypass list, add the app ${SEAM_APP.slug} (Seam), set to Always allow.`,
+    'Under Target branches, add the default branch and the pattern release/**.',
+    'Turn on Restrict updates, Restrict deletions and Block force pushes, then Create.',
+    'Ask everyone to stop pushing to main and wait for CI\'s last run there. Then click Move into Seam now.'
+  ]
+}
+
+/** The ruleset as GitHub's API takes it (for an owner who prefers `gh api -X POST repos/<repo>/rulesets --input`). */
+export function rulesetBody () {
+  return {
+    name: 'Seam is the authority on main',
+    target: 'branch',
+    enforcement: 'active',
+    bypass_actors: [{ actor_id: SEAM_APP.id, actor_type: 'Integration', bypass_mode: 'always' }],
+    conditions: { ref_name: { include: ['~DEFAULT_BRANCH', 'refs/heads/release/**'], exclude: [] } },
+    rules: [{ type: 'update' }, { type: 'deletion' }, { type: 'non_fast_forward' }]
+  }
+}
+
+/** What the owner does when no Seam GitHub installation of theirs reaches the repository. */
+export function installSteps (repo, installUrl = `https://github.com/apps/${SEAM_APP.slug}/installations/new`) {
+  return [
+    'Sign in to Seam at https://seam.heyquilt.com with the same account you use for Quilt.',
+    `Connect GitHub there and install the Seam app on ${repo} (${installUrl}). Seam reads the repository with it, and later pushes main to it.`,
+    'Then click Make this a quilt again.'
+  ]
+}
+
+/** One error whose message is the plain steps, with the steps alone in `steps` (the app lists them). */
+export function stepsError (lead, steps) {
+  const e = new Error(`${lead}\n${steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`)
+  e.steps = steps
+  return e
+}

package/src/relay-commit.js

@@ -17,6 +17,7 @@ import {
 } from './github-commit.js'
 import { readTasks, addTask, updateTask } from './tasks.js'
 import { addComment } from './task-comments.js'
+import { quiltOf } from './session-seam.js'
 
 export { CommitRefused }
 
@@ -566,6 +567,8 @@ export const mergeSchema = (z) => ({
  * connection (or the owner's token) covers the repository. Cheap: from the relay's record.
  */
 export function agentsCanCommit (room, key) {
+  // A session that is a quilt has no GitHub path for anyone's work: it lands with Seam (session-seam.js).
+  if (quiltOf(room.meta)) return false
   if (agentCommitsOf(room) === 'off') return false
   const found = repoRecordFor(room, key)
   if (!found) return false
@@ -676,6 +679,8 @@ export async function finishTaskFor (room, { who, key, task: taskId }, { fetch =
   const map = room.doc.getMap('tasks')
   const task = readTasks(map).find((t) => t.id === taskId)
   if (!task) return { merged: null }
+  // In a quilt a task's work lands with seam_merge: a pull request from before the switch is git's, and stays as it is.
+  if (quiltOf(room.meta)) return { merged: null }
   // A clash task (clash.js) is the merge itself.
   if (Object.values((room.meta && room.meta.upstreams) || {}).some((rec) => rec && rec.clash && rec.clash.task === taskId)) return { merged: null }
   if (!agentsCanCommit(room, key) && !task.pr) return { merged: null }

package/src/relay-lease.js

@@ -1,5 +1,5 @@
 // One live session per repository and branch (plan §8, addendum 16.6). The session that pushes
-// repo@branch holds its lease in the accounts API (git_sync_leases), which works across relay
+// repo@branch holds its lease in the accounts API (relay_leases), which works across relay
 // machines; the relay renews every lease it holds every LEASE_HEARTBEAT_MS, for every session active
 // in the last 24 hours (loaded or not), and keeps the list on its disk so a restart picks them up.
 // A lease lapses LEASE_TTL_MS after its last heartbeat (two missed: a crashed relay's).
@@ -52,9 +52,13 @@ function localStore (now) {
   }
 }
 
+/** A lease's key in the accounts API (relay_leases): "<repo> <branch>". */
+export const leaseKeyOf = (repo, branch) => `${repo} ${branch}`
+
 function apiStore ({ apiUrl, secret, fetch }) {
   const call = async (what, body) => {
-    const res = await fetch(`${String(apiUrl).replace(/\/+$/, '')}/v1/relay/leases/${what}`, { method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${secret}` }, body: JSON.stringify(body) })
+    // `key` (relay_leases, 16 R2) beside repo and branch, which an API from before R2 reads instead: the same lease either way.
+    const res = await fetch(`${String(apiUrl).replace(/\/+$/, '')}/v1/relay/leases/${what}`, { method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${secret}` }, body: JSON.stringify({ key: leaseKeyOf(body.repo, body.branch), ...body }) })
     if (!res.ok) throw new Error(`the accounts API answered ${res.status}`)
     return res.json()
   }