heyquilt 0.3.138 → 0.3.141

package/RELEASES.md

@@ -11,6 +11,16 @@ Format: `## <version> — <YYYY-MM-DD>`, an optional one-line summary, then bull
 Lead each bullet with a short bold phrase. Inline `code` and **bold** are rendered;
 nothing else is.
 
+## 0.3.141 — 2026-11-01
+
+- **A new, empty folder joining a session that is already in Seam takes the square as it is.** Its first files come from the session's old copy of the branch, and before, a folder without git could start following its square while that old copy was still being written to it, so every older file went into the square as its own edits (an agent's new folder put 166 stale files into main's square). Now the folder's own syncing stops before it follows the square, and nothing it got from the session is ever counted as its edits.
+
+## 0.3.140 — 2026-11-01
+
+0.3.139 was tagged but never published; everything meant for it is here.
+
+- **Quilt no longer has git mode.** Every session's code lives in Seam: sessions are Seam repositories, committed and merged there, and Quilt no longer syncs with GitHub, pushes, commits for you or opens merge tasks. A session with a GitHub repository that never moved into Seam keeps its chat, tasks, agent feed and audit trail (its files stay as they were and are no longer shared live), and its owner can still make it a quilt from Settings, Session.
+
 ## 0.3.138 — 2026-11-01
 
 0.3.137 was tagged but never published; everything meant for it is here.

package/bin/quilt.js

@@ -28,7 +28,7 @@ Usage:
   quilt sync [--dir <folder>]                         Agents in a sandbox: sync this folder with the session once and exit
                                                       (needs QUILT_AGENT_KEY; run it at the start and end of every turn).
                                                       With the key, status, messages, say, tasks, task, history, claim,
-                                                      release, focus, commits, commit-request, tool and mcp work too
+                                                      release, focus, tool and mcp work too
   quilt setup                                         Connect Claude Code / Cursor / others via MCP
   quilt status                                        Show collaborators, claims, activity, chat
   quilt history [path] [--by name] [--since 2h] [--task id] [--diff] [-n 30]
@@ -47,16 +47,11 @@ Usage:
                                                       NAME's base URL (STRIPE_BASE_URL), and its requests go through
                                                       Quilt's vault; it never sees a value
   quilt commit <message>                              In a session that is a quilt: commit the square this folder follows
-  quilt commit-request <message> [--files a,b] [--task id]
-                                                      Ask a person to commit for you (when agents may not push here)
-  quilt commits                                       Open commit requests and recent commits
-  quilt github                                        Whether agents can push here through GitHub, and the link that connects it
   quilt focus <what you're doing>                     Tell collaborators what you're working on
   quilt claim <path|glob> [reason]                    Mark files as yours for now
   quilt release <path|glob|*>                         Release a claim
   quilt chat-link [name] [--minutes N]                Owner: a link for a chat-only AI (ChatGPT, claude.ai, Grok); 10 minutes
   quilt chat-link extend <name> <minutes>             Owner: keep a chat link working for that long from now
-  quilt github-token [--clear]                        Owner: a read-only GitHub token (read from stdin) so the relay brings in commits while everyone's offline
   quilt invite                                        Print this session's invite code
   quilt workspace list|files|get|put|write|mkdir|mv|rm  The workspace library (quilt workspace for help)
   quilt stop                                          Shut down everything quilt is running (relay, app, syncs)
@@ -110,13 +105,7 @@ async function main () {
     case 'wake': return wakeCmd()
     case 'get': return getFile()
     case 'commit': if (!argv.join(' ').trim()) fail('Usage: quilt commit <message>'); return simple('/square-commit', { message: argv.join(' ') }, (r) => r.text)
-    case 'commit-request': return commitRequest()
-    case 'commits': return commits()
-    case 'github': return githubStatusCmd()
-    case 'git-token': return gitToken()
     case 'run': return runCmd()
-    case 'git-credential': return gitCredential()
-    case 'git-pre-push': return gitPrePush()
     case 'chat': return chat()
     case 'focus': return simple('/focus', { text: argv.join(' ') }, () => 'focus updated')
     case 'claim': return simple('/claim', { pattern: argv[0], note: argv.slice(1).join(' ') }, (r) =>
@@ -132,20 +121,6 @@ async function main () {
       const name = argv.filter((a, k) => !(i >= 0 && (k === i || k === i + 1))).join(' ')
       return simple('/chat-link', { name, minutes }, (r) => `Chat link for ${r.name}, until ${new Date(r.expiresAt).toLocaleTimeString()}:\n\n  ${r.url}\n\nPaste it into ChatGPT, claude.ai or Grok with "Open this link and follow it to join our Quilt session."\nAnyone with it can act as ${r.name}. Extend it with \`quilt chat-link extend ${r.name} <minutes>\`; once it runs out, make a new one.`)
     }
-    case 'github-token': {
-      // Read from stdin, never the command line (where shell history and ps would keep it).
-      if (argv[0] === '--clear') return simple('/github-token', { token: '' }, () => 'The relay no longer has a GitHub token for this session.')
-      if (argv.length) fail('usage: quilt github-token [--clear]   (the token is read from stdin: pbpaste | quilt github-token)')
-      if (process.stdin.isTTY) process.stderr.write('Paste a read-only GitHub token (contents: read) and press Enter: ')
-      const token = await new Promise((resolve) => {
-        let buf = ''
-        process.stdin.setEncoding('utf8')
-        process.stdin.on('data', (d) => { buf += d; if (process.stdin.isTTY && buf.includes('\n')) { process.stdin.pause(); resolve(buf) } })
-        process.stdin.on('end', () => resolve(buf))
-      })
-      if (!token.trim()) fail('no token given')
-      return simple('/github-token', { token: token.trim() }, () => 'The relay has the token: it brings in commits from your private repository while nobody\'s folder is online.')
-    }
     case 'session': return sessionCmd()
     case 'invite': return invite()
     case 'workspace': case 'workspaces': return workspaceCmd()
@@ -478,6 +453,12 @@ async function withAgentKey () {
   return true
 }
 
+/** All of stdin, for `quilt tool <name> -` (the tool's arguments as JSON). */
+const readStdin = () => new Promise((resolve) => {
+  let s = ''
+  process.stdin.setEncoding('utf8'); process.stdin.on('data', (c) => { s += c }); process.stdin.on('end', () => resolve(s)); process.stdin.on('error', () => resolve(s))
+})
+
 /** The sandbox's QUILT_AGENT_KEY (src/ui/agent-env-key.js), or null; a malformed one stops here. */
 async function envKey () {
   const { agentEnvKeyFromEnv } = await import('../src/ui/agent-env-key.js')
@@ -779,99 +760,6 @@ async function wakeCmd () {
   return simple('/wake', { args }, (r) => r.text)
 }
 
-async function commitRequest () {
-  const { values, positionals } = parseArgs({ args: argv, allowPositionals: true, options: { files: { type: 'string' }, task: { type: 'string' } } })
-  const files = values.files ? values.files.split(',').map((f) => f.trim()).filter(Boolean) : undefined
-  await simple('/commit-request', { message: positionals.join(' '), files, task: values.task }, (r) =>
-    `asked for a commit [${r.id}] of ${r.files.length} file${r.files.length === 1 ? '' : 's'}: ${r.files.slice(0, 12).join(', ')}${r.files.length > 12 ? ', …' : ''}\n${r.committer}`)
-}
-
-// git in an agent's folder runs these (installGitHelpers, gitstate.js); `--dir` is the folder, whose
-// running session answers. They never print anything but what git expects, and never fail a git
-// command when Quilt isn't running: git then behaves as it would without Quilt. Nor do they make git
-// wait: a session that doesn't answer within HELPER_WAIT is taken as no session, and the whole helper
-// exits by HELPER_LIMIT whatever is still pending (the env overrides are for tests).
-const HELPER_WAIT = Number(process.env.QUILT_HELPER_WAIT_MS) || 4000
-const HELPER_LIMIT = Number(process.env.QUILT_HELPER_LIMIT_MS) || 10000
-function helperDeadline () { setTimeout(() => process.exit(0), HELPER_LIMIT).unref() }
-function helperDir () {
-  const i = argv.indexOf('--dir')
-  const dir = i >= 0 ? argv[i + 1] : process.cwd()
-  if (i >= 0) argv.splice(i, 2)
-  return dir
-}
-async function helperDaemon (dir) {
-  const { findDaemon, call } = await import('../src/control.js')
-  const d = findDaemon(dir)
-  return d ? { d, call } : null
-}
-// git closes stdin after what it sends; one that stays open is read for HELPER_WAIT at most.
-const readStdin = () => new Promise((resolve) => {
-  let s = ''
-  const done = () => { clearTimeout(t); process.stdin.pause(); resolve(s) }
-  const t = setTimeout(done, HELPER_WAIT)
-  process.stdin.setEncoding('utf8'); process.stdin.on('data', (c) => { s += c }); process.stdin.on('end', done); process.stdin.on('error', done)
-})
-
-/**
- * git's credential helper protocol: `get` answers with the session's token for the host; store and erase
- * are nothing to do. `--fallback` (a person's folder, git for everyone): when no Quilt session answers
- * (the app is closed) or it has no token, the person's own helpers are asked instead, as git would have
- * without Quilt: `git credential fill` from outside the folder, so only their global and system config count.
- */
-async function gitCredential () {
-  const dir = helperDir()
-  const fallback = argv.includes('--fallback')
-  if (fallback) argv.splice(argv.indexOf('--fallback'), 1)
-  if (argv[0] !== 'get') return
-  helperDeadline()
-  const input = await readStdin()
-  const fields = Object.fromEntries(input.split('\n').filter((l) => l.includes('=')).map((l) => { const i = l.indexOf('='); return [l.slice(0, i), l.slice(i + 1)] }))
-  try {
-    const h = await helperDaemon(dir)
-    if (h) {
-      const r = await h.call(h.d, 'POST', '/git/credential', { host: fields.host || '', protocol: fields.protocol || '' }, { timeoutMs: HELPER_WAIT })
-      if (r && r.username && r.password) return process.stdout.write(`username=${r.username}\npassword=${r.password}\n`)
-    }
-  } catch {}
-  if (fallback) await ownCredential(input)
-}
-
-/** The person's own credentials for what git asked (`input`, git's credential fields), or nothing: never a prompt. */
-async function ownCredential (input) {
-  const os = await import('node:os')
-  const { execFile } = await import('node:child_process')
-  const away = os.tmpdir()
-  const out = await new Promise((resolve) => {
-    const c = execFile('git', ['credential', 'fill'], { cwd: away, encoding: 'utf8', timeout: Math.max(1000, HELPER_LIMIT - HELPER_WAIT - 1000), killSignal: 'SIGKILL', env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: '', SSH_ASKPASS: '', GIT_CEILING_DIRECTORIES: path.dirname(away) } }, (err, stdout) => resolve(err ? '' : stdout))
-    c.stdin.end(input.endsWith('\n\n') ? input : `${input.replace(/\n*$/, '')}\n\n`)
-  })
-  const lines = out.split('\n').filter((l) => /^(username|password)=/.test(l))
-  if (lines.length === 2) process.stdout.write(`${lines.join('\n')}\n`)
-}
-
-/** The pre-push hook: refs on stdin (local ref, local sha, remote ref, remote sha), the remote's name and URL as arguments. Exits 1 with the reason when the push may not go. */
-async function gitPrePush () {
-  const dir = helperDir()
-  const [remote = 'origin'] = argv
-  helperDeadline()
-  const input = await readStdin()
-  const refs = input.split('\n').filter(Boolean).map((l) => { const [localRef, localSha, remoteRef, remoteSha] = l.trim().split(/\s+/); return { localRef, localSha, remoteRef, remoteSha } })
-  try {
-    const h = await helperDaemon(dir)
-    if (!h) return
-    const r = await h.call(h.d, 'POST', '/git/push-check', { remote, refs }, { timeoutMs: HELPER_WAIT })
-    if (r && r.ok === false) { process.stderr.write(`Quilt: ${r.why || 'this push is not allowed here'}\n`); process.exitCode = 1 }
-  } catch {}
-}
-
-/** A short-lived token for this folder's repository (agents), for gh or GitHub's API. */
-/** `quilt git-token` no longer prints a token (a value in a terminal is a value in an AI's context). */
-async function gitToken () {
-  const { GIT_TOKEN_GONE } = await import('../src/secret-run.js')
-  fail(GIT_TOKEN_GONE)
-}
-
 /** `quilt run -- <command>`: the command gets its secrets' stand-ins and gateways (src/secret-run.js). */
 async function runCmd () {
   const { RUN_USAGE, runSource, runWithSecrets } = await import('../src/secret-run.js')
@@ -885,30 +773,6 @@ async function runCmd () {
   try { process.exitCode = await runWithSecrets({ command, source }) } catch (err) { fail(err.message) }
 }
 
-async function githubStatusCmd () {
-  const { d, call } = await daemonOrFail()
-  const st = await call(d, 'GET', '/status')
-  const mine = (st.branches || []).find((b) => st.git && b.name === st.git.key) || (st.branches || []).find((b) => b.default)
-  const g = mine && mine.relay && mine.relay.github
-  const repo = mine && mine.relay && mine.relay.repo
-  if (!repo) return console.log('This session does not follow a GitHub repository (no member\'s folder is a clone of one), so there is nothing to connect.')
-  const words = { ok: `Git is on for everyone here, through @${g && g.login}'s connection: people and agents push with git, nothing to set up`, 'not-connected': 'not connected: nobody in the session has connected GitHub yet', 'not-installed': 'Quilt is not installed on this repository on GitHub yet', 'no-access': `no connected GitHub account (@${g && g.login}) may write to it`, 'not-github': 'not on GitHub' }
-  console.log(`${repo}: ${g ? words[g.state] || g.state : 'not checked yet'}`)
-  if (g && g.state === 'ok') return
-  const { readAccount } = await import('../src/account.js')
-  const token = readAccount()?.token
-  if (!token) return console.log('Sign in (quilt login), then run this again for the link that connects GitHub.')
-  const { githubConnectUrl } = await import('../src/account.js')
-  try { console.log(`Connect it (one click, once, by someone whose GitHub account can write to the repository):\n  ${await githubConnectUrl({ token, repo })}`) } catch (err) { console.log(`Could not get the link: ${err.message}`) }
-}
-
-async function commits () {
-  const { d, call } = await daemonOrFail()
-  const { describeCommitRequests } = await import('../src/commit.js')
-  const c = await call(d, 'GET', '/commits')
-  console.log(plain(describeCommitRequests(c, { canCommit: !!c.canCommit })))
-}
-
 async function getFile () {
   if (!argv[0]) fail('usage: quilt get <message-id> [dest]')
   await simple('/get', { id: argv[0], dest: argv[1] ? path.resolve(argv[1]) : undefined }, (r) => `saved to ${r.path}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyquilt",
-  "version": "0.3.138",
+  "version": "0.3.141",
   "description": "Real-time, tool-agnostic pair vibe coding: sync a project folder live between collaborators using any AI coding tool.",
   "author": {
     "name": "Daniel Carmichael",

package/src/account.js

@@ -224,35 +224,6 @@ export async function removeSandboxKey ({ token, id, keyId, api = apiUrl(), fetc
   return call(fetchImpl, api, 'DELETE', sandbox$(id, `/${encodeURIComponent(keyId)}`), null, token)
 }
 
-/** This account's GitHub connection (Quilt's GitHub App): { available, connected, login? }. */
-export async function githubStatus ({ token, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  return call(fetchImpl, api, 'GET', '/v1/me/github', null, token)
-}
-
-/** Where to send this person to connect GitHub (install Quilt's app on their repositories). */
-export async function githubConnectUrl ({ token, repo = '', scope = '', id = '', api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  const r = await call(fetchImpl, api, 'POST', '/v1/github/connect', { ...(repo ? { repo } : {}), ...(scope ? { scope, id } : {}) }, token)
-  if (!r.url) throw new Error(BAD_REPLY)
-  return r.url
-}
-
-/** A workspace's GitHub (plan §2): its connections, access mode and repositories, and its org's switch. */
-export async function workspaceGithub ({ token, id, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  return call(fetchImpl, api, 'GET', `/v1/workspaces/${encodeURIComponent(id)}/github`, null, token)
-}
-export async function setWorkspaceGithub ({ token, id, access, repos, agentCommits, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  // Only what is given changes: the access mode (with its repositories) and/or what agents may commit ('' for each session).
-  const body = { ...(access !== undefined ? { access, repos } : {}), ...(agentCommits !== undefined ? { agentCommits } : {}) }
-  return call(fetchImpl, api, 'PUT', `/v1/workspaces/${encodeURIComponent(id)}/github`, body, token)
-}
-export async function removeWorkspaceGithub ({ token, id, connectedBy = '', api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  return call(fetchImpl, api, 'DELETE', `/v1/workspaces/${encodeURIComponent(id)}/github/connection`, connectedBy ? { connectedBy } : {}, token)
-}
-export async function setOrgGithub ({ token, slug, requireGithub, agentCommits, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  const body = { ...(requireGithub !== undefined ? { requireGithub: !!requireGithub } : {}), ...(agentCommits !== undefined ? { agentCommits } : {}) }
-  return call(fetchImpl, api, 'PUT', `/v1/orgs/${encodeURIComponent(slug)}/github`, body, token)
-}
-
 // Access types, grants and session invites, as this computer's account (see
 // docs/superpowers/specs/2026-10-02-access-types-and-invites-design.md). Each throws with
 // .status when the API says no (401 once the token is revoked).

package/src/api/memory-store.js

@@ -399,35 +399,6 @@ export function createMemoryStore ({ now = Date.now } = {}) {
     addAuthSession (userId, s) { authSessions.set(s.id, { userId, createdAt: now(), lastActiveAt: now(), userAgent: '', ip: '', ...s }) },
     async authSessions (userId) { return all(authSessions, (s) => s.userId === userId).sort((a, b) => b.lastActiveAt - a.lastActiveAt).map(({ userId: _, ...s }) => ({ ...s })) },
     async endAuthSession (userId, id) { const s = authSessions.get(id); if (!s || s.userId !== userId) return false; authSessions.delete(id); return true },
-    async githubLink (userId) { const g = githubLinks.get(userId); return g ? { ...g } : null },
-    async setGithubLink (userId, { githubId, login }) { githubLinks.set(userId, { githubId, login, linkedAt: now() }) },
-    async deleteGithubLink (userId) { githubLinks.delete(userId) },
-    // GitHub connected for a scope (github_connections): an org, a workspace or a person; newest first.
-    async githubConnections ({ scope, scopeId }) { return all(githubConnections, (c) => c.scope === scope && c.scopeId === scopeId).sort((a, b) => b.createdAt - a.createdAt).map(copy) },
-    async addGithubConnection ({ scope, scopeId, connectedBy, installationId = null }) { githubConnections.set(`${scope}\0${scopeId}\0${connectedBy}`, { scope, scopeId, connectedBy, installationId, createdAt: now() }) },
-    async removeGithubConnection ({ scope, scopeId, connectedBy }) { githubConnections.delete(`${scope}\0${scopeId}\0${connectedBy}`) },
-    // A workspace's access mode (workspace_github): 'open', or 'repos' with the repositories it allows.
-    async workspaceGithub (workspaceId) { const w = workspaceGithub.get(workspaceId); return w ? { access: w.access, repos: [...w.repos], agentCommits: w.agentCommits || '' } : { access: 'open', repos: [], agentCommits: '' } },
-    // Only what is given changes: { access, repos } and/or { agentCommits } ('' for each session to decide).
-    async setWorkspaceGithub (workspaceId, { access, repos, agentCommits }) {
-      const w = workspaceGithub.get(workspaceId) || { access: 'open', repos: [], agentCommits: '' }
-      workspaceGithub.set(workspaceId, { access: access ?? w.access, repos: repos ? [...repos] : w.repos, agentCommits: agentCommits ?? w.agentCommits ?? '', updatedAt: now() })
-    },
-    // An org's GitHub switch (org_github): whether it requires GitHub.
-    async teamGithub (teamId) { const r = teamGithub.get(teamId); return { agentCommits: (r && r.agentCommits) || '' } },
-    async setTeamGithub (teamId, { agentCommits }) { teamGithub.set(teamId, { agentCommits: agentCommits || '', updatedAt: now() }) },
-    // The rules of the teams `memberId` is on: [{ teamId, name, agentCommits }], only those that set one.
-    async teamGitRules (memberId) {
-      return all(teamMembers, (tm) => tm.memberId === memberId)
-        .map((tm) => ({ team: teams.get(tm.teamId), rule: teamGithub.get(tm.teamId) }))
-        .filter((x) => x.team && x.rule && x.rule.agentCommits)
-        .map((x) => ({ teamId: x.team.id, name: x.team.name, agentCommits: x.rule.agentCommits }))
-    },
-    async orgGithub (orgId) { const o = orgGithub.get(orgId); return { requireGithub: !!(o && o.requireGithub), agentCommits: (o && o.agentCommits) || '' } },
-    async setOrgGithub (orgId, { requireGithub, agentCommits }) {
-      const o = orgGithub.get(orgId) || { requireGithub: false, agentCommits: '' }
-      orgGithub.set(orgId, { requireGithub: requireGithub ?? o.requireGithub, agentCommits: agentCommits ?? o.agentCommits ?? '', updatedAt: now() })
-    },
     // The API's own settings (app_settings): a value it keeps across starts.
     async getSetting (key) { return settings.has(key) ? settings.get(key) : null },
     // Relay leases (relay_leases; mirrors the SQL functions). `key`: the relay's name for what it holds.

package/src/api/routes/teams.js

@@ -37,8 +37,6 @@ export function teamRoutes ({ store, user, policyChanged = null }) {
           name: t.name,
           createdAt: t.createdAt,
           access: mine.get(t.id) || null,
-          // The team's git rule (git for everyone: '' sets nothing, off, branches or any).
-          git: (await store.teamGithub(t.id)).agentCommits,
           members: a.can('team_members', 'r') || mine.has(t.id)
             ? (await store.listTeamMembers(t.id)).map((m) => ({ memberId: m.memberId, name: m.name, access: m.access, kind: m.kind, scopes: m.scopes || [] }))
             : null
@@ -98,27 +96,6 @@ export function teamRoutes ({ store, user, policyChanged = null }) {
       return { member: memberView(tm) }
     }],
 
-    // The team's git rule (docs/superpowers/specs/2026-10-17-git-for-everyone.md): whether git is on for
-    // everyone in the sessions its people own in the org's workspaces, and what agents may push there.
-    // '' sets nothing; off, branches or any is a ceiling for the workspaces' and sessions' own choices.
-    ['GET', /^\/v1\/orgs\/([^/]+)\/teams\/([^/]+)\/github$/, async (req, body, [slug, id]) => {
-      const a = await orgFor(req, slug)
-      const team = await teamIn(a, id)
-      const mine = (await store.teamsOfMember(a.me.id)).some((x) => x.teamId === team.id)
-      if (!a.can('teams', 'r') && !mine) throw new HttpError(404, 'no such team')
-      return store.teamGithub(team.id)
-    }],
-    ['PUT', /^\/v1\/orgs\/([^/]+)\/teams\/([^/]+)\/github$/, async (req, body, [slug, id]) => {
-      const a = await orgFor(req, slug)
-      a.need('teams', 'u')
-      const team = await teamIn(a, id)
-      if (!('agentCommits' in body)) throw new HttpError(400, 'Give agentCommits: "" (the team sets nothing), off, branches or any.')
-      const v = body.agentCommits === null ? '' : body.agentCommits
-      if (!['', 'off', 'branches', 'any'].includes(v)) throw new HttpError(400, 'agentCommits is "" (the team sets nothing), off, branches or any.')
-      await store.setTeamGithub(team.id, { agentCommits: v })
-      if (policyChanged) policyChanged()
-      return store.teamGithub(team.id)
-    }],
 
     ['DELETE', /^\/v1\/orgs\/([^/]+)\/teams\/([^/]+)\/members\/([^/]+)$/, async (req, body, [slug, id, memberId]) => {
       const a = await orgFor(req, slug)

package/src/api/server.js

@@ -25,8 +25,6 @@ import { relayRoutes } from './routes/relay.js'
 import { relayClusterRoutes } from './routes/relay-cluster.js'
 import { relayCluster } from './relay-cluster.js'
 import crypto from 'node:crypto'
-import { githubRoutes } from './routes/github.js'
-import { githubApp, ensureWebhookSecret, redeliverFailed } from './github-app.js'
 import { releaseSource } from './releases.js'
 import { sessionRoutes, nowRoutes, nowAsker, overviewOf } from './routes/sessions.js'
 import { notifier, NOTIFY_EVERY_MS } from './notify.js'
@@ -361,8 +359,6 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
   // The relay on many machines: where each room lives, and heavy rooms' own machines (relay-cluster.js).
   const cluster = relayCluster({ store, relayUrl: relay, relaySecret, fetch: relayFetch || githubFetch, now, log, fly: relayFly, ...(heavy ? { limits: heavy } : {}), ...(relayTargets ? { targets: relayTargets } : {}), ...clusterTiming })
   const ctx = { store, user, person, device, bearer, now, site, apiUrl: api, mailer, log, limit: limitInvites, limitSend: limitInviteSend, limitTokens, limitStarts, spendResume, resumeWindowMs: RESUME_WINDOW_MS, limitJoin, agentAuth, reportKey, limitReports, relaySecret, files, maxFileBytes, workspaceQuotaBytes, maxWorkspaceFiles }
-  // GitHub's webhook secret: set on the app by this API at start (github-app.js), kept in the store when the environment gives none.
-  const hookSecret = { value: (github && github.webhookSecret) || '' }
   // On several machines, one leads what lives in a machine's memory (leader.js); alone, this one does.
   const lead = leader({ store, machineId, log, ...leaderTiming })
   // Scaling down (autoscale.js): an idle machine shuts itself down cleanly when the others can carry
@@ -381,27 +377,17 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
       exit()
     }
   })
-  const githubReady = (async () => {
-    if (!github) return
-    const app = githubApp(github, { fetch: githubFetch, now })
-    await ensureWebhookSecret({ cfg: github, app, store, hook: hookSecret, log })
-    // Asking GitHub for failed deliveries again is done once, by the leader, not by every machine.
-    await lead.ready
-    if (lead.leads()) await redeliverFailed({ app, log })
-  })().catch((err) => log(`github at start: ${err.message}`))
+  // Sessions are quilts (Seam): nothing waits on GitHub at start.
+  const githubReady = Promise.resolve()
   // A person's AI on its own cloud machine (routes/ai-vm.js): off (503) without Fly set up. Only the leader runs it.
   const aiVm = aiVmRoutes({ ...ctx, relayUrl, fly, waitMs: aiVmWaitMs, spareSuspendMs: aiVmSpareSuspendMs, leads: lead.leads })
   routes.push(...aiVm.routes)
   // Email notices people turned on in the website's Settings › Notifications (notify.js): the leader sends them.
   const notices = notifier({ store, mailer, ask: nowAsker({ store, cluster, relayOn: !!(relay && relaySecret), log }), overview: (account, t) => overviewOf(store, account, 'UTC', t), now, log, site, leads: lead.leads, everyMs: notifyEveryMs })
   if (notifyEveryMs > 0) notices.start()
-  // A team's git rule or who is on a team changed: the relay asks its sessions' rules again now (relay /github/policy).
-  // With a room (a session put in or taken out of a workspace), only that session asks.
-  const policyChanged = (room = '') => {
-    if (!relay || !relaySecret) return
-    cluster.tellRelays('/github/policy', room ? { room } : {}).catch((err) => log(`git rules to relay: ${err.message}`))
-  }
-  routes.push(...orgRoutes(ctx), ...memberRoutes(ctx), ...teamRoutes({ ...ctx, policyChanged }), ...inviteRoutes(ctx), ...agentRoutes({ ...ctx, passKey }), ...agentInviteRoutes({ ...ctx, workspaces }), ...joinRoutes(ctx), ...relayRoutes(ctx), ...githubRoutes({ ...ctx, github, githubFetch, relayHttp: relay, relayFetch: githubFetch, tellRelays: (path, body) => cluster.tellRelays(path, body), hookSecret, workspaces }), ...relayClusterRoutes({ ...ctx, cluster }), ...sessionRoutes(ctx), ...nowRoutes({ ...ctx, cluster, relayOn: !!(relay && relaySecret) }), ...browserRoutes(ctx), ...sessionMigrateRoutes({ ...ctx, cluster }), ...accessTypeRoutes(ctx), ...grantRoutes({ ...ctx, workspaces }), ...sessionInviteRoutes({ ...ctx, workspaces }), ...issueRoutes(ctx))
+  // Git rules went with git mode (R3): nothing to tell the relay.
+  const policyChanged = () => {}
+  routes.push(...orgRoutes(ctx), ...memberRoutes(ctx), ...teamRoutes({ ...ctx, policyChanged }), ...inviteRoutes(ctx), ...agentRoutes({ ...ctx, passKey }), ...agentInviteRoutes({ ...ctx, workspaces }), ...joinRoutes(ctx), ...relayRoutes(ctx), ...relayClusterRoutes({ ...ctx, cluster }), ...sessionRoutes(ctx), ...nowRoutes({ ...ctx, cluster, relayOn: !!(relay && relaySecret) }), ...browserRoutes(ctx), ...sessionMigrateRoutes({ ...ctx, cluster }), ...accessTypeRoutes(ctx), ...grantRoutes({ ...ctx, workspaces }), ...sessionInviteRoutes({ ...ctx, workspaces }), ...issueRoutes(ctx))
   // Always routed: with the flag off each answers a plain 404 of its own, so the app's
   // check at every launch isn't filed as a missing route.
   // Only these take a hosted agent's pass (workspaceReach), so they alone get the pass key.

package/src/api/supabase-store.js

@@ -298,58 +298,6 @@ export function createSupabaseStore ({ url, serviceKey, client }) {
       if (error) throw error
     },
 
-    // The GitHub account a person connected (routes/github.js): { githubId, login, linkedAt } or null.
-    async githubLink (userId) { return rowFrom(await one(db.from('github_links').select('github_id, login, linked_at').eq('user_id', userId).maybeSingle())) },
-    async setGithubLink (userId, { githubId, login }) {
-      await one(db.from('github_links').upsert({ user_id: userId, github_id: githubId, login, linked_at: new Date().toISOString() }, { onConflict: 'user_id' }))
-    },
-    async deleteGithubLink (userId) { await one(db.from('github_links').delete().eq('user_id', userId)) },
-    // GitHub connected for a scope (github_connections), newest first.
-    async githubConnections ({ scope, scopeId }) {
-      const rows = await one(db.from('github_connections').select('scope, scope_id, connected_by, installation_id, created_at').eq('scope', scope).eq('scope_id', scopeId).order('created_at', { ascending: false }))
-      return rows.map((r) => ({ scope: r.scope, scopeId: r.scope_id, connectedBy: r.connected_by, installationId: r.installation_id == null ? null : Number(r.installation_id), createdAt: Date.parse(r.created_at) }))
-    },
-    async addGithubConnection ({ scope, scopeId, connectedBy, installationId = null }) {
-      await one(db.from('github_connections').upsert({ scope, scope_id: scopeId, connected_by: connectedBy, installation_id: installationId, created_at: new Date().toISOString() }, { onConflict: 'scope,scope_id,connected_by' }))
-    },
-    async removeGithubConnection ({ scope, scopeId, connectedBy }) { await one(db.from('github_connections').delete().eq('scope', scope).eq('scope_id', scopeId).eq('connected_by', connectedBy)) },
-    async workspaceGithub (workspaceId) {
-      const r = await one(db.from('workspace_github').select('access, repos, agent_commits').eq('workspace_id', workspaceId).maybeSingle())
-      return r ? { access: r.access, repos: r.repos || [], agentCommits: r.agent_commits || '' } : { access: 'open', repos: [], agentCommits: '' }
-    },
-    // Only what is given changes: { access, repos } and/or { agentCommits } ('' for each session to decide).
-    async setWorkspaceGithub (workspaceId, { access, repos, agentCommits }) {
-      const row = { workspace_id: workspaceId, updated_at: new Date().toISOString() }
-      if (access !== undefined) { row.access = access; row.repos = repos || [] }
-      if (agentCommits !== undefined) row.agent_commits = agentCommits || null
-      await one(db.from('workspace_github').upsert(row, { onConflict: 'workspace_id' }))
-    },
-    async teamGithub (teamId) {
-      const r = await one(db.from('team_github').select('agent_commits').eq('team_id', teamId).maybeSingle())
-      return { agentCommits: (r && r.agent_commits) || '' }
-    },
-    async setTeamGithub (teamId, { agentCommits }) {
-      await one(db.from('team_github').upsert({ team_id: teamId, agent_commits: agentCommits || null, updated_at: new Date().toISOString() }, { onConflict: 'team_id' }))
-    },
-    // The rules of the teams `memberId` is on: [{ teamId, name, agentCommits }], only those that set one.
-    async teamGitRules (memberId) {
-      const rows = await one(db.from('team_members').select('team_id, teams (name, team_github (agent_commits))').eq('member_id', memberId))
-      return rows.map((r) => {
-        const g = r.teams && r.teams.team_github
-        const mode = Array.isArray(g) ? (g[0] && g[0].agent_commits) : (g && g.agent_commits)
-        return mode ? { teamId: r.team_id, name: (r.teams && r.teams.name) || '', agentCommits: mode } : null
-      }).filter(Boolean)
-    },
-    async orgGithub (orgId) {
-      const r = await one(db.from('org_github').select('require_github, agent_commits').eq('org_id', orgId).maybeSingle())
-      return { requireGithub: !!(r && r.require_github), agentCommits: (r && r.agent_commits) || '' }
-    },
-    async setOrgGithub (orgId, { requireGithub, agentCommits }) {
-      const row = { org_id: orgId, updated_at: new Date().toISOString() }
-      if (requireGithub !== undefined) row.require_github = !!requireGithub
-      if (agentCommits !== undefined) row.agent_commits = agentCommits || null
-      await one(db.from('org_github').upsert(row, { onConflict: 'org_id' }))
-    },
     // The API's own settings (app_settings): a value it keeps across starts, such as the webhook secret it set on GitHub.
     // Relay leases (relay_leases, through its locking functions; 16 R2). `key`: the relay's name for what it holds.
     // Before the migration that makes relay_leases is applied, a git branch's key ("<repo> <branch>") goes to the old functions.

package/src/branch-view.js

@@ -12,9 +12,6 @@
 // Everything on the relay that reads a branch's files asks here, for either form.
 import path from 'node:path'
 import crypto from 'node:crypto'
-import { runGit, GitFailed, authEnv } from './relay-git.js'
-import { parseRepo } from './relay-upstream.js'
-import { looksBinary, sha1 } from './fsutil.js'
 
 export const DIFF = 'diff'
 /** docKey's answer for a path a diff document leaves to git: never null (a deletion), never undefined (unreadable). */
@@ -161,84 +158,15 @@ export function baseOf (room, key, e = null) {
 
 // --------------------------------------------------------------- git --
 
-const TREE_CACHE = 16
-/** The relay's mirror for branch `key`'s repository: { dir, repo, token } or null (not on GitHub, or no mirror). */
-export async function mirrorFor (room, key) {
-  const ups = (room.meta && room.meta.upstreams) || {}
-  const b = room.meta && room.meta.branches && room.meta.branches[key]
-  // The branch's own record, the default branch's, or the repository the folder that started it named (a new session).
-  const rec = (ups[key] && ups[key].repo && ups[key]) || (ups[room.defaultKey] && ups[room.defaultKey].repo && ups[room.defaultKey]) || (b && b.repo ? { repo: b.repo } : null)
-  if (!rec || !room.mirrors) return null
-  const repo = parseRepo(`https://${rec.repo}`)
-  if (!repo || !repo.github) return null
-  const token = room.gitToken ? await room.gitToken(repo) : null
-  const { dir } = await room.mirrors.ensure(repo, { url: room.gitRemoteUrl(repo) })
-  return { dir, repo, token }
-}
-
-/** Makes sure the mirror has commit `sha`, fetching it from GitHub when it hasn't (a shallow mirror, or a commit it never fetched). */
-export async function ensureCommit (dir, sha, { token = null } = {}) {
-  if ((await runGit(dir, ['cat-file', '-e', `${sha}^{commit}`])).ok) return true
-  const r = await runGit(dir, ['fetch', '-q', 'origin', sha], { env: authEnv(token) })
-  return r.ok && (await runGit(dir, ['cat-file', '-e', `${sha}^{commit}`])).ok
-}
-
-/** Commit `sha`'s tree: Map path -> { mode, sha, size } (cached on the room, a few commits). */
-export async function treeAt (room, dir, sha) {
-  if (!room.gitTrees) room.gitTrees = new Map()
-  const k = `${dir}\0${sha}`
-  if (room.gitTrees.has(k)) { const t = room.gitTrees.get(k); room.gitTrees.delete(k); room.gitTrees.set(k, t); return t }
-  const r = await runGit(dir, ['ls-tree', '-r', '-z', '-l', sha])
-  if (!r.ok) throw new GitFailed(`listing ${sha.slice(0, 7)}`, r.err)
-  const out = new Map()
-  for (const entry of r.out.split('\0')) {
-    if (!entry) continue
-    const tab = entry.indexOf('\t')
-    const [mode, type, oid, size] = entry.slice(0, tab).split(/\s+/)
-    if (type !== 'blob') continue // submodules have no bytes here
-    out.set(entry.slice(tab + 1), { mode, sha: oid, size: Number(size) || 0 })
-  }
-  room.gitTrees.set(k, out)
-  while (room.gitTrees.size > TREE_CACHE) room.gitTrees.delete(room.gitTrees.keys().next().value)
-  return out
-}
-
-/** The bytes of `paths` at commit `sha`: Map path -> Buffer, or null when the commit hasn't it. */
-export async function bytesAt (dir, sha, paths) {
-  const out = new Map()
-  if (!paths.length) return out
-  const r = await runGit(dir, ['cat-file', '--batch'], { input: paths.map((p) => `${sha}:${p}\n`).join(''), buffer: true })
-  if (!r.ok) throw new GitFailed(`reading files at ${sha.slice(0, 7)}`, r.err)
-  const buf = r.out
-  let at = 0
-  for (const rel of paths) {
-    const nl = buf.indexOf(0x0a, at)
-    if (nl < 0) break
-    const line = buf.subarray(at, nl).toString('utf8')
-    at = nl + 1
-    if (/ missing$/.test(line) || / ambiguous$/.test(line)) { out.set(rel, null); continue }
-    const size = Number(line.split(' ')[2])
-    out.set(rel, Buffer.from(buf.subarray(at, at + size)))
-    at += size + 1
-  }
-  return out
-}
-
 /** Why git can't answer for a diff branch, in words for whoever asked. */
-const noGit = (key) => `the session leaves ${key}'s unchanged files to git, and the relay can't read git for it right now (no GitHub mirror, or GitHub out of reach); try again in a minute`
+const noGit = (key) => `the session left ${key}'s unchanged files to git, which the relay no longer reads (sessions are quilts now: open the branch's square)`
 
 /**
  * What git has of branch `key` at its base, for reading paths that follow git: { base, dir, tree }
  * or throws a plain-words error. Only for a diff document.
  */
-export async function gitOf (room, key, e) {
-  const base = baseOf(room, key, e)
-  if (!base) throw new Error(noGit(key))
-  let m
-  try { m = await mirrorFor(room, key) } catch { m = null }
-  if (!m) throw new Error(noGit(key))
-  if (!(await ensureCommit(m.dir, base, { token: m.token }))) throw new Error(noGit(key))
-  return { base, dir: m.dir, tree: await treeAt(room, m.dir, base) }
+export async function gitOf (room, key) {
+  throw new Error(noGit(key))
 }
 
 /**
@@ -280,17 +208,7 @@ export async function readPaths (room, key, e, rels) {
     else if (s.kind === 'git') fromGit.push(rel)
     else out.set(rel, { kind: 'missing' })
   }
-  if (fromGit.length) {
-    const g = await gitOf(room, key, e)
-    const known = fromGit.filter((rel) => g.tree.has(rel))
-    const bytes = await bytesAt(g.dir, g.base, known)
-    for (const rel of fromGit) {
-      const buf = bytes.get(rel)
-      if (!buf) out.set(rel, { kind: 'missing' })
-      else if (looksBinary(buf)) out.set(rel, { kind: 'binary', buf, git: true })
-      else out.set(rel, { kind: 'text', text: buf.toString('utf8'), git: true })
-    }
-  }
+  if (fromGit.length) await gitOf(room, key, e)
   return out
 }
 
@@ -315,44 +233,8 @@ export async function textOf (room, key, e, rel) {
  * the contents of `want` (and of every .gitattributes), hashes only for the rest. The hashes of a
  * commit are read once and kept on the room (a few commits).
  */
-export async function gitForSync (room, key, e, want = []) {
-  const g = await gitOf(room, key, e)
-  if (!room.gitSha1s) room.gitSha1s = new Map()
-  const ck = `${g.dir}\0${g.base}`
-  let hashes = room.gitSha1s.get(ck)
-  if (!hashes) {
-    hashes = new Map()
-    const rels = [...g.tree.keys()]
-    for (let i = 0; i < rels.length; i += 400) {
-      const part = rels.slice(i, i + 400)
-      const at = await bytesAt(g.dir, g.base, part)
-      for (const rel of part) { const b = at.get(rel); if (b) hashes.set(rel, { h: sha1(b), binary: looksBinary(b), size: b.length }) }
-    }
-    room.gitSha1s.set(ck, hashes)
-    while (room.gitSha1s.size > 4) room.gitSha1s.delete(room.gitSha1s.keys().next().value)
-  }
-  const gone = goneOf(e)
-  const files = new Map()
-  for (const [rel, x] of hashes) if (!hasEntry(e, rel) && !gone.has(rel)) files.set(rel, { h: x.h, binary: x.binary, size: x.size })
-  const read = [...new Set([...want, ...[...files.keys()].filter((rel) => path.posix.basename(rel) === '.gitattributes')])].filter((rel) => files.has(rel))
-  const at = await bytesAt(g.dir, g.base, read)
-  for (const rel of read) {
-    const b = at.get(rel)
-    if (!b) continue
-    const f = files.get(rel)
-    if (f.binary) f.buf = b; else f.text = b.toString('utf8')
-  }
-  return { base: g.base, files }
-}
-
-/** A diff branch's rule files that only git has (the session never changed them) at commit `sha`, matching `pattern`: [[path, text]]. */
-export async function gitRuleFiles (dir, sha, e, pattern) {
-  if (!sha) return []
-  const r = await runGit(dir, ['ls-tree', '-r', '-z', '--name-only', sha])
-  if (!r.ok) return []
-  const rels = r.out.split('\0').filter((rel) => rel && pattern.test(rel) && !hasEntry(e, rel) && !goneOf(e).has(rel))
-  const at = await bytesAt(dir, sha, rels)
-  return rels.map((rel) => [rel, at.get(rel)]).filter(([, b]) => b && b.length <= 256 * 1024).map(([rel, b]) => [rel, b.toString('utf8')])
+export async function gitForSync (room, key, e) {
+  return gitOf(room, key, e)
 }
 
 /** The rule files (ignore, attributes) branch `key` has, with their text: Map path -> text, from the session and git. */
@@ -360,12 +242,5 @@ export async function ruleFiles (room, key, e, names) {
   const want = (rel) => names.includes(path.posix.basename(rel))
   const out = new Map()
   for (const [rel, t] of e.files) if (want(rel)) out.set(rel, t.toString())
-  if (!isDiff(e)) return out
-  let g
-  try { g = await gitOf(room, key, e) } catch { return out }
-  const gone = goneOf(e)
-  const rels = [...g.tree.keys()].filter((rel) => want(rel) && !hasEntry(e, rel) && !gone.has(rel))
-  const bytes = await bytesAt(g.dir, g.base, rels)
-  for (const rel of rels) { const b = bytes.get(rel); if (b && b.length <= 256 * 1024) out.set(rel, b.toString('utf8')) }
   return out
 }