heyquilt 0.3.122 → 0.3.140

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-ask.js

@@ -1,13 +1,10 @@
 // Questions for the relay, "Quilt" in chat. Anyone in a session can @mention @Quilt (or message it directly)
-// and it answers from what it knows: how the session's branches stand against git, who is
-// connected, which branches it keeps, and (for the owner) trimming branches nobody uses. No
+// and it answers from what it knows: who is connected, which branches it keeps, and (for the owner) trimming branches nobody uses. No
 // model runs here: each question is matched by its words and answered by code. Pure but for
 // `room`, which the relay passes in (server.js answerRelay).
 
-import { RELAY_BY, isRelay } from './branches.js'
 import { mentioned } from './inbox.js'
-import { chosenBranches } from './relay-prune.js'
-import { RELAY_QUESTIONS, RELAY_OLD_NAMES } from './ui/chat.js'
+import { RELAY_QUESTIONS, RELAY_OLD_NAMES, RELAY_NAME as RELAY_BY, isRelay } from './ui/chat.js'
 
 export { RELAY_QUESTIONS }
 
@@ -25,7 +22,6 @@ export function asksRelay (m) {
 export function questionOf (text) {
   const t = String(text || '').replace(/@(the relay|quilt)\b/gi, ' ').toLowerCase()
   if (/\b(trim|prune|clean ?up|remove)\b/.test(t)) return 'trim'
-  if (/\b(git|github|upstream|commits?|behind|synced?)\b/.test(t)) return 'git'
   if (/\b(members?|connected|online|who|people|agents?)\b/.test(t)) return 'members'
   if (/\bbranch(es)?\b/.test(t)) return 'branches'
   return 'help'
@@ -53,32 +49,6 @@ function whoIsOn (room) {
   return on
 }
 
-function gitAnswer (room, now) {
-  const ups = room.meta.upstreams || {}
-  const lines = []
-  for (const key of Object.keys(room.meta.branches)) {
-    const r = ups[key]
-    if (!r || !r.name) continue
-    const parts = [`${key} follows ${r.name}${r.repo ? ` (${r.repo})` : ''}`]
-    if (r.sha) parts.push(`at ${r.sha.slice(0, 7)}${r.checkedAt ? `, checked ${ago(r.checkedAt, now)}` : ''}`)
-    if (r.brought && r.brought.at) parts.push(`brought in ${plural(r.brought.count || 0, 'commit')} ${ago(r.brought.at, now)}`)
-    if (r.clash && r.clash.task) parts.push(`waiting on merge task ${r.clash.task}`)
-    if (r.problem) parts.push(`problem: ${typeof r.problem === 'string' ? r.problem : r.problem.message || 'see the branch menu'}`)
-    const why = r.github && GITHUB_BLOCKED[r.github.state]
-    if (why) parts.push(`agents can't commit: ${why}`)
-    lines.push(parts.join('; '))
-  }
-  if (!lines.length) return 'No branch here follows a GitHub repository yet. It starts when a member with a git folder joins.'
-  return lines.length === 1 ? `${lines[0]}.` : `Against git:\n${lines.map((l) => `- ${l}`).join('\n')}`
-}
-
-// Why agents can't commit to a branch's repository, by its GitHub connection's state (relay-upstream.js noteConnection).
-const GITHUB_BLOCKED = {
-  'not-connected': 'nobody here has connected GitHub',
-  'not-installed': 'the Quilt app isn\'t installed on the repository',
-  'no-access': 'the connected GitHub account can\'t write to it'
-}
-
 function membersAnswer (room) {
   const people = new Set()
   for (const ws of room.conns.keys()) { const n = room.names.get(ws); if (n) people.add(n) }
@@ -116,38 +86,6 @@ export function unusedBranches (room, now = Date.now()) {
 }
 
 /** Branch names that are never trimmed for being merged: the trunk itself, whatever the session calls its default. */
-const TRUNKS = new Set(['main', 'master'])
-
-/**
- * The branches whose work is merged and can leave the session (Room.trimMergedBranches), so a
- * session never fills its MAX_BRANCHES with finished work. A branch counts when its pull request
- * was merged on GitHub (its upstream record has `merged`, from notePull, reviewPulls or a merge
- * made in Quilt) and nothing was written on it in the session since (`changed` no later than the
- * merge). Never the default branch, main or master, the branch it merged into, a branch someone
- * is on, holds a file on, or a hosted agent chose, nor one with session edits still waiting to go
- * to GitHub. Git keeps every branch: only the relay's copy goes.
- */
-export function mergedBranches (room, now = Date.now()) {
-  const on = whoIsOn(room)
-  const claimed = new Set(Object.values(room.meta.claims || {}).map((c) => room.branchOf(c)))
-  const chosen = chosenBranches(room, now) // a hosted agent's choice holds a branch worked on this week
-  const ups = room.meta.upstreams || {}
-  const bases = new Set()
-  for (const rec of Object.values(ups)) if (rec && rec.merged && rec.merged.into) bases.add(room.resolveKey ? room.resolveKey(rec.merged.into) : rec.merged.into)
-  return Object.entries(room.meta.branches)
-    .filter(([k, b]) => {
-      const rec = ups[k]
-      const m = rec && rec.merged
-      if (!m || !m.into || !(m.at > 0)) return false
-      if (k === room.defaultKey || TRUNKS.has(k) || TRUNKS.has(rec.ref) || bases.has(k) || rec.ref === m.into) return false
-      if (on.has(k) || claimed.has(k) || chosen.has(k)) return false
-      const pending = room.meta.sync && room.meta.sync[k] && room.meta.sync[k].pending
-      if (pending && Object.keys(pending).length) return false // session edits not on GitHub yet (relay-outbound.js)
-      return !(b && b.changed > m.at) // written on after the merge: that work isn't merged
-    })
-    .map(([k]) => k)
-}
-
 function trimAnswer (room, asker, now) {
   if (!asker.mayTrim) return 'Only the session owner can trim branches.'
   const gone = unusedBranches(room, now)
@@ -156,7 +94,7 @@ function trimAnswer (room, asker, now) {
   room.saveMeta()
   room.broadcastBranches()
   room.log(`[${room.name}] ${asker.name} trimmed ${plural(gone.length, 'unused branch')}: ${gone.join(', ')}`)
-  return `Trimmed ${plural(gone.length, 'branch')} nobody used for a day: ${list(gone)}. Git keeps them, and a branch comes back when someone checks it out.`
+  return `Trimmed ${plural(gone.length, 'branch')} nobody used for a day: ${list(gone)}. A branch comes back when someone checks it out.`
 }
 
 const HELP = `I can answer:\n${RELAY_QUESTIONS.map((q) => `- ${q.text}${q.owner ? ' (owner only)' : ''}`).join('\n')}`
@@ -166,7 +104,6 @@ const HELP = `I can answer:\n${RELAY_QUESTIONS.map((q) => `- ${q.text}${q.owner
  */
 export function relayAnswer (room, m, asker, now = Date.now()) {
   switch (questionOf(m.text)) {
-    case 'git': return gitAnswer(room, now)
     case 'members': return membersAnswer(room)
     case 'branches': return branchesAnswer(room, now)
     case 'trim': return trimAnswer(room, asker, now)

package/src/relay-cluster.js

@@ -50,14 +50,13 @@ export function clusterConfig (opts = {}, env = process.env) {
 }
 
 /** What cluster mode is missing; [] when it can run. */
-export function clusterProblems (cc, cfg, { fileKey = '' } = {}) {
+export function clusterProblems (cc, cfg) {
   if (!cc.on) return []
   const out = []
   if (!MACHINE_RE.test(cc.machineId)) out.push('FLY_MACHINE_ID (this machine\'s id)')
   if (!cfg.apiUrl) out.push('QUILT_API_URL')
   if (!cfg.relayApiSecret) out.push('RELAY_API_SECRET')
   if (!cfg.passPublicKey) out.push('QUILT_PASS_PUBLIC_KEY (sign-in)')
-  if (cfg.gitSync && !fileKey) out.push('QUILT_RELAY_FILE_KEY (the file key every machine shares)')
   if (!cc.peerUrl) out.push('QUILT_PEER_URL or FLY_APP_NAME (how machines reach each other)')
   return out
 }
@@ -75,10 +74,9 @@ export function storedRooms (dataDir) {
   return [...out].sort()
 }
 
-/** The room a request's path is about ('' for none): git, chat files, large files, chat links. */
+/** The room a request's path is about ('' for none): chat files, large files, chat links. */
 export function roomOfPath (pathname) {
-  const m = /^\/git\/([A-Za-z0-9_-]{1,64})\.git\//.exec(pathname) ||
-    /^\/files\/([A-Za-z0-9_-]{1,64})(?:\/|$)/.exec(pathname) ||
+  const m = /^\/files\/([A-Za-z0-9_-]{1,64})(?:\/|$)/.exec(pathname) ||
     /^\/blobs\/([A-Za-z0-9_-]{1,64})\//.exec(pathname) ||
     /^\/c\/([A-Za-z0-9_-]{1,64})\//.exec(pathname)
   return m ? m[1] : ''

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()
   }