heyquilt 0.3.121 → 0.3.122

package/RELEASES.md

@@ -11,6 +11,25 @@ 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.122 — 2026-10-26
+
+- **Seam follows a live git repository**: `seam import git https://… --into <slug> --follow` imports a git remote on the server and keeps taking its new commits on `main` and `release/*` every 10 minutes, or at once when a git hook or cron job pokes it (`POST /v1/imports/:id/poke` with the import's secret; `seam import poke`). Those lines stay frozen while git leads, so nothing merges in Seam until cut-over; a rewritten branch stops the follow. `seam import status` shows where it is. Also as the `seam_import_remote`, `seam_import_status` and `seam_import_poke` tools.
+- **Seam exports to any git remote**: `seam export remote <url> --quilt <q> [--line main,release/*] [--releases] [--credential <name>]` pushes each merge on those lines to GitHub, GitLab or any git remote as it lands, fast-forward only, with release tags when asked. A remote someone else pushed to is refused, never forced, and `seam export status` says which line and commit; failures to reach the remote retry by themselves. Also as `seam_export_remote` and `seam_export_status`, and `PUT`/`GET /v1/quilts/:q/export`.
+- **Seam cut-over**: `seam import cutover <id>` ends a followed import for good: one last pass, a check that the git remote has nothing the import lacks, then the lines take merges in Seam and `main` exports back to the same remote after each merge, continuing git's history. It refuses and changes nothing if git moved. The day's steps are in `docs/seam-cutover.md`.
+- **Squares close themselves while git leads**: during a followed import, a square whose diff someone applied in git and pushed is closed as merged by the next follow pass (`merged.how = matched`), with the git commit it became. A square whose diff was edited on the way is closed by an admin with `seam square merged <square> --as <sha>` (also `seam_square_merged` and `POST /v1/quilts/:q/squares/:s/merged`).
+- **Busy lines no longer drop merges**: a merge waiting behind many others on the same line for more than 10 seconds was ended as if its server had died; it now keeps itself alive while it waits.
+- **A Settings tab for each repo on seam.heyquilt.com**: admins set the export to a git remote there (address, lines, releases, the credential's name) or turn it off; everyone who can read the repo sees whether it is up to date, what was pushed last and the last error.
+- **Seam asks your test runners to run checks.** A line's policy can name who runs each check (`seam line require main --checks ci --runners ci=agent:ci`). Seam then sends them `check.requested` when a square gets a new commit, when it asks to merge, and after each merge on the line; runners can also list what's waiting with `seam checks --state queued`. Only a named runner's result counts; anyone else's is kept as advisory.
+- **Seam says which tests a change touches.** A line's policy can list where its tests live (`seam line require main --tests "test/**"`), and each check request then names the tests the change reaches through its imports (JavaScript, TypeScript, Python), or says "run everything" when a lockfile, build file or CI config changed. Checks can also be set to run only before or only after a merge (`--tiers e2e=post_merge`); after a merge everything always runs.
+- **Seam cancels test runs nobody needs and can run a check again.** When a square gets a newer commit, the run on the old one is cancelled and its runner told to stop (after merges, the oldest run still finishes). `seam check rerun ci --square <square>` (or `--line main`) asks the runners to run a check again.
+- **`seam runner` runs your checks on your own machine.** `seam runner --check ci --run "npm test"` picks up the checks Seam asks its key to run, runs each on its commit in a fresh folder, and reports pass or fail with a link to the log; a run Seam cancels is stopped. docs/seam-runner.md says how to keep one running on a small Fly machine.
+- **Seam has its own accounts.** Seam can sign people in with an account of its own, apart from heyquilt.com, and checks those sign-ins itself; `GET /v1/me` says who you are to Seam. Accounts with heyquilt.com keep working as they do.
+- **`seam login` signs in to Seam itself, and agents get Seam keys.** `seam login` (seam 0.26.0) links your computer to your Seam account on seam.heyquilt.com; `seam agent new <name>` (or Your agents on the site) makes an agent with its own key, which `seam agent key` replaces and `seam agent revoke` ends. If you signed in with an older seam, run `seam logout` and `seam login` once.
+- **Apps can connect to Seam with your permission.** Seam is now an OAuth 2 provider: an app (Quilt is one) sends you to seam.heyquilt.com, you see what it asks for (one quilt or all of them, read or change) and Allow or Deny, and it gets a token that reaches only that. `seam oauth client new <name> --redirect <uri>` registers an app (seam 0.26.0); revoking it ends every token it holds.
+- **Your Seam history stays yours.** Sign in to Seam with the email of your heyquilt.com account and you keep the same member, with every patch you made; `seam agent relink` brings your old agents over with theirs (seam 0.25.0).
+- **Seam runs as its own service.** Seam has its own server at `api.seam.heyquilt.com`, apart from Quilt's; the `seam` command (0.22.0) and seam.heyquilt.com talk to it, and the old address keeps answering by passing Seam's requests on, so nothing you made stops working. `seam serve` runs a Seam server of your own from Seam's source.
+- **Seam's Your repos page says what importing does**, and how to install `seam` first.
+
 ## 0.3.121 — 2026-10-26
 
 - **Shown with the AI tool you really use.** When you haven't picked a tool in Settings, Quilt guessed it from which tool's folder changed last, and Quilt itself changes Cursor's and Windsurf's folders when it connects them, so a Claude Code user could show up as Windsurf. It now goes by what each tool writes as you use it (chats, sessions, editor state), and as soon as your AI connects to a session you're shown with that one. Saving your colour no longer pins the guess as your pick.

package/bin/quilt.js

@@ -144,6 +144,7 @@ async function main () {
       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()
     case 'stop': return stopAll()
@@ -241,8 +242,11 @@ async function apiCmd () {
     // Its own machines through Fly's Machines API (QUILT_API_FLY_TOKEN): more as load climbs, fewer as it drops (src/api/scaler.js).
     apiFly: (await import('../src/api/api-machines.js')).apiFlyFromEnv(env),
     ...(env.QUILT_API_MAX_MACHINES ? { maxMachines: Number(env.QUILT_API_MAX_MACHINES) } : {}),
-    // Quilt source control (src/quilts/): off unless QUILT_SOURCE is set (src/quilts/setup.js).
-    quilts: await (await import('../src/quilts/setup.js')).quiltsFromEnv(env, { memory: !!values.memory, log: console.log }),
+    // Seam is its own service (docs/seam-service.md): its old routes here go on to it.
+    ...(env.QUILT_SEAM_URL !== undefined ? { seamUrl: env.QUILT_SEAM_URL } : {}),
+    ...(env.QUILT_SEAM_CLIENT_ID ? { seamClientId: env.QUILT_SEAM_CLIENT_ID } : {}),
+    ...(env.QUILT_SEAM_SITE_URL ? { seamSiteUrl: env.QUILT_SEAM_SITE_URL } : {}),
+    ...(env.QUILT_SEAM_CONNECT_SECRET ? { seamConnectSecret: env.QUILT_SEAM_CONNECT_SECRET } : {}),
     // Voice: Cloudflare TURN for calls on networks that block a direct line, Workers AI for transcripts; each off when not set.
     voice: {
       turnKeyId: env.CLOUDFLARE_TURN_KEY_ID || '',
@@ -578,6 +582,23 @@ async function doSetup () {
   console.log('\nAn AI tool that was already open picks up the "quilt" MCP server when it restarts.')
 }
 
+// `quilt session migrate [--dry-run]` (plans/quilt-source-control/16): what making this folder's
+// session a quilt (Seam) would do, read only, or, without --dry-run, the move itself. The relay
+// does both, behind QUILT_SOURCE_URL there, and only for the session's owner. --switch then moves
+// the session's files into its squares (layout 3); --back returns it to its branches. `follow <folder>`
+// then makes that folder follow this branch's square live (session-follow.js).
+async function sessionCmd () {
+  if (argv[0] === 'follow') {
+    if (!argv[1]) fail('Usage: quilt session follow <folder>')
+    return simple('/quilt-follow', { dir: path.resolve(argv[1]) }, (r) => r.text)
+  }
+  if (argv[0] !== 'migrate') fail('Usage: quilt session migrate [--dry-run | --switch | --back] | quilt session follow <folder>')
+  if (argv.includes('--dry-run')) return simple('/quilt-plan', {}, (r) => r.text)
+  if (argv.includes('--switch')) return simple('/quilt-switch', {}, (r) => r.text)
+  if (argv.includes('--back')) return simple('/quilt-unswitch', {}, (r) => r.text)
+  return simple('/quilt-migrate', {}, (r) => r.text)
+}
+
 async function daemonOrFail () {
   const { findDaemon, call } = await import('../src/control.js')
   const d = findDaemon()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyquilt",
-  "version": "0.3.121",
+  "version": "0.3.122",
   "description": "Real-time, tool-agnostic pair vibe coding: sync a project folder live between collaborators using any AI coding tool.",
   "author": {
     "name": "Daniel Carmichael",
@@ -37,6 +37,7 @@
   "dependencies": {
     "@fontsource/ibm-plex-mono": "^5.3.0",
     "@fontsource/poppins": "^5.3.0",
+    "@heyquilt/seam": "^0.17.0",
     "@modelcontextprotocol/sdk": "^1.30.1",
     "@noble/hashes": "^2.4.0",
     "@supabase/supabase-js": "^2.117.2",

package/src/api/memory-store.js

@@ -55,7 +55,7 @@ export function createMemoryStore ({ now = Date.now } = {}) {
   const hostedRooms = new Map() // "account\nroom" -> { account, room, addedAt }
   const hostedWebhooks = new Map(); const resumeSignatures = new Map()
   // Secrets (20261018000000_secrets.sql): only what the vault sealed.
-  const secretRows = new Map(); const secretDataKeys = new Map(); const secretSettingsRows = new Map()
+  const seamLinks = new Map(); const secretRows = new Map(); const secretDataKeys = new Map(); const secretSettingsRows = new Map()
   const secretTickets = new Map(); const secretRuns = new Map(); const secretAsks = new Map(); const secretUses = []
   const scopeKey = (scopeType, scopeId) => `${scopeType}\n${scopeId}`
   // A secret as the API's routes see it: never its sealed value (secretSealed reads that, for the vault).
@@ -1227,6 +1227,10 @@ export function createMemoryStore ({ now = Date.now } = {}) {
       if (!secretDataKeys.has(k)) secretDataKeys.set(k, { scopeType, scopeId, version, sealedKey, provider, createdAt: now() })
       return copy(secretDataKeys.get(k))
     },
+    // "Connect Seam" (routes/seam-connect.js): the person's Seam tokens, one row per Quilt user.
+    async seamLink (userId) { return copy(seamLinks.get(userId)) || null },
+    async putSeamLink (userId, link) { const row = { userId, access: link.access, refresh: link.refresh, scope: link.scope || '', expiresAt: link.expiresAt, connectedAt: link.connectedAt ?? now() }; seamLinks.set(userId, copy(row)); return copy(row) },
+    async deleteSeamLink (userId) { seamLinks.delete(userId) },
     async secretSettings (scopeType, scopeId) {
       return copy(secretSettingsRows.get(scopeKey(scopeType, scopeId))) || { scopeType, scopeId, inheritOff: false, inheritOffBy: null, inheritOffAt: null, agentsOn: false, agents: 'all', updatedAt: null }
     },

package/src/api/routes/seam-connect.js

@@ -0,0 +1,103 @@
+// "Connect Seam": a Quilt person links their own Seam account to Quilt, the way any app connects
+// to Seam (Seam's OAuth 2, authorization code with PKCE). Quilt never shares accounts with Seam:
+// it keeps the person's Seam token and calls Seam's HTTP API with it. Off unless Quilt is
+// registered as a Seam app (seamClientId, env QUILT_SEAM_CLIENT_ID).
+//
+// The PKCE verifier is never stored: `state` carries who asked and until when, signed with
+// Quilt's secret, and the verifier is an HMAC of the state, so any API machine can finish it.
+import crypto from 'node:crypto'
+import { HttpError, Raw } from '../http.js'
+
+export const CONNECT_MS = 10 * 60_000
+const REFRESH_EARLY_MS = 60_000
+
+const b64 = (b) => Buffer.from(b).toString('base64url')
+const mac = (secret, text) => crypto.createHmac('sha256', secret).update(text).digest('base64url')
+const same = (a, b) => a.length === b.length && crypto.timingSafeEqual(Buffer.from(a), Buffer.from(b))
+const page = (status, title, text) => new Raw(status, `<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font:16px system-ui;margin:4em auto;max-width:32em"><h1>${title}</h1><p>${text}</p></body>`, 'text/html; charset=utf-8')
+
+export function seamConnectRoutes ({ store, person, now = Date.now, apiUrl, seamUrl, seamSiteUrl = 'https://seam.heyquilt.com', clientId, secret, fetch = globalThis.fetch, log = () => {} }) {
+  if (!clientId || !secret || !seamUrl || !store.seamLink) return []
+  const seam = String(seamUrl).replace(/\/+$/, '')
+  const site = String(seamSiteUrl).replace(/\/+$/, '')
+  const redirectUri = `${String(apiUrl).replace(/\/+$/, '')}/v1/seam/connect/callback`
+  const verifierOf = (state) => mac(secret, `seam-pkce\0${state}`)
+  const userOf = (p) => p.userId || p.id
+
+  function makeState (userId) {
+    const body = b64(JSON.stringify({ u: userId, e: now() + CONNECT_MS, n: crypto.randomBytes(12).toString('base64url') }))
+    return `${body}.${mac(secret, `seam-state\0${body}`)}`
+  }
+  function readState (state) {
+    const [body, sig] = String(state || '').split('.')
+    if (!body || !sig || !same(sig, mac(secret, `seam-state\0${body}`))) return null
+    try {
+      const s = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'))
+      return s && s.e > now() ? s : null
+    } catch { return null }
+  }
+
+  async function tokenCall (form) {
+    let res
+    try { res = await fetch(`${seam}/oauth/token`, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' }, body: new URLSearchParams({ client_id: clientId, ...form }).toString(), signal: AbortSignal.timeout(10_000) }) } catch { throw new HttpError(503, 'Seam could not be reached; try again') }
+    const data = await res.json().catch(() => null)
+    if (!res.ok || !data?.access_token) return { error: data?.error || `seam_${res.status}`, detail: data?.error_description || '' }
+    return { access: data.access_token, refresh: data.refresh_token, scope: data.scope || '', expiresAt: now() + Number(data.expires_in || 3600) * 1000 }
+  }
+
+  /** The person's Seam access token, refreshed when it is about to end; null when not connected. */
+  async function freshToken (userId) {
+    const link = await store.seamLink(userId)
+    if (!link) return null
+    if (link.expiresAt - REFRESH_EARLY_MS > now()) return link
+    const t = await tokenCall({ grant_type: 'refresh_token', refresh_token: link.refresh })
+    if (t.error) {
+      // Seam ended the grant (revoked on seam.heyquilt.com, or the token was reused): connect again.
+      if (t.error === 'invalid_grant' || t.error === 'invalid_client') { await store.deleteSeamLink(userId); return null }
+      throw new HttpError(503, 'Seam could not refresh your connection; try again')
+    }
+    return store.putSeamLink(userId, { ...t, connectedAt: link.connectedAt })
+  }
+
+  return [
+    // { scope? } → { url }: the page on Seam's site where the person allows Quilt.
+    ['POST', /^\/v1\/seam\/connect$/, async (req, body) => {
+      const p = await person(req)
+      const scope = String(body?.scope || 'quilts:write').trim()
+      const state = makeState(userOf(p))
+      const challenge = crypto.createHash('sha256').update(verifierOf(state)).digest('base64url')
+      const q = new URLSearchParams({ client_id: clientId, redirect_uri: redirectUri, response_type: 'code', scope, state, code_challenge: challenge, code_challenge_method: 'S256' })
+      return { url: `${site}/oauth/authorize?${q}` }
+    }],
+    // Seam sends the browser back here with a code (or error=access_denied).
+    ['GET', /^\/v1\/seam\/connect\/callback$/, async (req) => {
+      const q = new URL(req.url, 'http://x').searchParams
+      const s = readState(q.get('state'))
+      if (!s) return page(400, 'Seam was not connected', 'This link expired or was not made by Quilt. Start again from Quilt.')
+      if (q.get('error')) return page(200, 'Seam was not connected', 'You chose not to connect Seam. You can connect it from Quilt any time.')
+      const t = await tokenCall({ grant_type: 'authorization_code', code: q.get('code') || '', redirect_uri: redirectUri, code_verifier: verifierOf(q.get('state')) })
+      if (t.error) { log(`seam connect: ${t.error} ${t.detail}`); return page(400, 'Seam was not connected', 'Seam did not accept this sign-in. Start again from Quilt.') }
+      await store.putSeamLink(s.u, { ...t, connectedAt: now() })
+      return page(200, 'Seam is connected', 'Quilt can now use Seam as you. You can close this tab.')
+    }],
+    ['GET', /^\/v1\/seam\/connection$/, async (req) => {
+      const link = await store.seamLink(userOf(await person(req)))
+      return link ? { connected: true, scope: link.scope, connectedAt: link.connectedAt } : { connected: false }
+    }],
+    // The person's own Seam token, for their app to call Seam's API with.
+    ['GET', /^\/v1\/seam\/token$/, async (req) => {
+      const link = await freshToken(userOf(await person(req)))
+      if (!link) throw new HttpError(404, 'Seam is not connected: connect it first')
+      return { access_token: link.access, token_type: 'Bearer', expires_at: link.expiresAt, scope: link.scope, seam_url: seam }
+    }],
+    ['DELETE', /^\/v1\/seam\/connection$/, async (req) => {
+      const userId = userOf(await person(req))
+      const link = await store.seamLink(userId)
+      if (link) {
+        await fetch(`${seam}/oauth/revoke`, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ token: link.refresh }).toString(), signal: AbortSignal.timeout(10_000) }).catch(() => {})
+        await store.deleteSeamLink(userId)
+      }
+      return { connected: false }
+    }]
+  ]
+}

package/src/api/routes/session-migrate.js

@@ -0,0 +1,36 @@
+// Making a session a quilt (plans/quilt-source-control/16, "How a session becomes a quilt"):
+// POST /v1/sessions/:room/migrate { dry_run, token, step }. The session's owner, signed in, asks here
+// (step 'switch' moves the session's files into its squares, layout 3; 'unswitch' goes back);
+// the relay machine holding the room does the work (POST /quilt/migrate, with the relay secret),
+// so this is the same operation as the MCP tool and `quilt session migrate`. Seam is called as the
+// owner: with `token` (their Seam sign-in) when given, else the sign-in they used here. The relay
+// refuses while Seam is off for it (QUILT_SOURCE_URL), so nothing changes until that flag is set.
+import { HttpError } from '../http.js'
+
+const ROOM = /^[A-Za-z0-9_-]{1,64}$/
+const NO_SESSION = 'no such session'
+const MIGRATE_TIMEOUT_MS = 5 * 60 * 1000 // a large session's patch 1 and squares take a while
+
+export function sessionMigrateRoutes ({ store, person, bearer, relaySecret, cluster }) {
+  return [
+    ['POST', /^\/v1\/sessions\/([^/]+)\/migrate$/, async (req, body, [room]) => {
+      const account = `person:${(await person(req)).userId}`
+      if (!ROOM.test(room)) throw new HttpError(404, NO_SESSION)
+      const session = await store.sessionByRoom(room).catch(() => null)
+      if (!session) throw new HttpError(404, NO_SESSION)
+      if (session.ownerAccount !== account) throw new HttpError(403, 'Only the session owner can make it a quilt.')
+      if (!relaySecret) throw new HttpError(503, 'the relay is not set up on this server')
+      const dry = body && body.dry_run === true
+      const token = body && typeof body.token === 'string' && body.token ? body.token : bearer(req)
+      const where = await store.relayRoom(room).catch(() => null)
+      const step = body && (body.step === 'switch' || body.step === 'unswitch') ? body.step : null
+      const ask = { room, account, ...(dry ? { dry_run: true } : { token }), ...(step && !dry ? { step } : {}) }
+      try {
+        return await cluster.callRelay((where && where.machineId) || '', 'POST', '/quilt/migrate', ask, { timeoutMs: MIGRATE_TIMEOUT_MS })
+      } catch (err) {
+        const said = String(err.message).replace(/^relay .*? answered \d+: /, '')
+        throw new HttpError(err.status && err.status < 500 ? err.status : 502, said)
+      }
+    }]
+  ]
+}

package/src/api/server.js

@@ -29,6 +29,7 @@ import { githubRoutes } from './routes/github.js'
 import { githubApp, ensureWebhookSecret, redeliverFailed } from './github-app.js'
 import { releaseSource } from './releases.js'
 import { sessionRoutes } from './routes/sessions.js'
+import { sessionMigrateRoutes } from './routes/session-migrate.js'
 import { accessTypeRoutes } from './routes/access-types.js'
 import { grantRoutes } from './routes/grants.js'
 import { sessionInviteRoutes } from './routes/session-invites.js'
@@ -37,6 +38,7 @@ import { workspaceFileRoutes } from './routes/workspace-files.js'
 import { workspaceAgentRoutes } from './routes/workspace-agents.js'
 import { workspaceInviteRoutes } from './routes/workspace-invites.js'
 import { HOSTED_RELAY } from '../settings.js'
+import { seamConnectRoutes } from './routes/seam-connect.js'
 import { roomAccessFrom } from './access.js'
 import { joiningRoom, sessionArg } from '../mcp-room.js'
 import { issueRoutes } from './routes/issues.js'
@@ -47,7 +49,6 @@ import { secretRoutes } from './routes/secrets.js'
 import { voiceRoutes } from './routes/voice.js'
 import { mailRoutes } from './routes/mail.js'
 import { agentWakeRoutes } from './routes/agent-wake.js'
-import { quiltRoutes } from '../quilts/routes.js'
 import { workspaceReach } from './workspace-reach.js'
 import { leader, LEADER_ONLY } from './leader.js'
 import { autoscale } from './autoscale.js'
@@ -73,7 +74,7 @@ const MCP_TIMEOUT_MS = 30 * 1000
 // a change to its grant reaches it as soon as it reaches a connected app.
 const PASS_REUSE_MARGIN_MS = 5 * 60 * 1000
 
-export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, siteUrl, apiUrl = 'https://api.heyquilt.com', mailer = { send: async () => { throw new Error('no mailer configured') } }, now = Date.now, log = () => {}, startLimit = 10, inviteLimit = 10, inviteSendLimit = 20, tokenLimit = 30, joinLimit = 20, trustProxy = false, maxStartKeys = 10_000, passKey = '', passLimit = 60, relayUrl = HOSTED_RELAY, mcpLimit = 600, reportKey = '', reportLimit = 10, slowMs = 2000, pruneEveryMs = 60 * 60 * 1000, keepEventsMs = 30 * 24 * 60 * 60 * 1000, keepIssuesMs = 90 * 24 * 60 * 60 * 1000, pruneStartMs = 10_000, relaySecret = '', workspaces = false, fileStore = null, maxFileBytes = 500 * 1024 * 1024, workspaceQuotaBytes = 5 * 1024 * 1024 * 1024, maxWorkspaceFiles = 2000, webhookFetch = globalThis.fetch, webhookLookup, allowLocalWebhooks = false, github = null, githubFetch = globalThis.fetch, fly = null, aiVmWaitMs = AI_VM_WAIT_MS, aiVmSpareSuspendMs, relayFetch = null, relayFly = null, heavy = null, relayTargets = null, clusterTiming = {}, vaultSecret = '', vaultUrl = 'https://vault.heyquilt.com', allowLocalUpstreams = false, secretWaitMs, voice = {}, voiceFetch = globalThis.fetch, mail = {}, mailFetch = globalThis.fetch, machineId = '', leaderTiming = {}, autoscaleTiming = {}, exit = () => process.exit(0), apiFly = null, maxMachines, quilts = null }) {
+export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, siteUrl, apiUrl = 'https://api.heyquilt.com', mailer = { send: async () => { throw new Error('no mailer configured') } }, now = Date.now, log = () => {}, startLimit = 10, inviteLimit = 10, inviteSendLimit = 20, tokenLimit = 30, joinLimit = 20, trustProxy = false, maxStartKeys = 10_000, passKey = '', passLimit = 60, relayUrl = HOSTED_RELAY, mcpLimit = 600, reportKey = '', reportLimit = 10, slowMs = 2000, pruneEveryMs = 60 * 60 * 1000, keepEventsMs = 30 * 24 * 60 * 60 * 1000, keepIssuesMs = 90 * 24 * 60 * 60 * 1000, pruneStartMs = 10_000, relaySecret = '', workspaces = false, fileStore = null, maxFileBytes = 500 * 1024 * 1024, workspaceQuotaBytes = 5 * 1024 * 1024 * 1024, maxWorkspaceFiles = 2000, webhookFetch = globalThis.fetch, webhookLookup, allowLocalWebhooks = false, github = null, githubFetch = globalThis.fetch, fly = null, aiVmWaitMs = AI_VM_WAIT_MS, aiVmSpareSuspendMs, relayFetch = null, relayFly = null, heavy = null, relayTargets = null, clusterTiming = {}, vaultSecret = '', vaultUrl = 'https://vault.heyquilt.com', allowLocalUpstreams = false, secretWaitMs, voice = {}, voiceFetch = globalThis.fetch, mail = {}, mailFetch = globalThis.fetch, machineId = '', leaderTiming = {}, autoscaleTiming = {}, exit = () => process.exit(0), apiFly = null, maxMachines, seamUrl = 'https://api.seam.heyquilt.com', seamFetch = globalThis.fetch, seamClientId = '', seamSiteUrl = 'https://seam.heyquilt.com', seamConnectSecret = '' }) {
   // PASS_SIGNING_KEY. A bad one should stop the API at start, not fail every pass later.
   if (passKey) passPublicKey(passKey)
   const site = String(siteUrl || '').replace(/\/+$/, '')
@@ -394,7 +395,7 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
     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), ...accessTypeRoutes(ctx), ...grantRoutes({ ...ctx, workspaces }), ...sessionInviteRoutes({ ...ctx, workspaces }), ...issueRoutes(ctx))
+  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), ...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.
@@ -416,16 +417,19 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
   routes.push(...mailRoutes({ ...ctx, passKey, mail, mailFetch, makeLimiter, tellRoom }))
   // How Quilt wakes each agent (routes/agent-wake.js): step 2 of joining.
   routes.push(...agentWakeRoutes({ ...ctx, passKey, mail, mailFetch, makeLimiter }))
-  // Quilt source control (src/quilts/, plans/quilt-source-control/): off unless startApi gets `quilts`.
-  // Seam takes who is calling from us, as a quilt member: { member_id, kind, name, tool?, on_behalf_of? }.
-  const quiltCaller = quilts ? workspaceReach({ ...ctx, passKey }) : null
-  const identifyQuiltMember = async (req) => {
-    const c = await quiltCaller.caller(req)
+  // Seam (src/quilts/, plans/quilt-source-control/) is its own service at seamUrl. This API is its
+  // identity service for Quilt accounts: GET /v1/seam/me says who is calling, as a quilt member
+  // { member_id, kind, name, tool?, on_behalf_of? }, for a person's sign-in, an agent key or a pass.
+  const seamCaller = workspaceReach({ ...ctx, passKey })
+  const identifySeamMember = async (req) => {
+    const c = await seamCaller.caller(req)
     if (c.agent) return { member_id: c.account, kind: 'agent', name: c.agent.name || 'agent', ...(c.agent.provider ? { tool: String(c.agent.provider).toLowerCase() } : {}), ...(c.agent.ownerUserId ? { on_behalf_of: `person:${c.agent.ownerUserId}` } : {}) }
     const p = c.userId && store.profile ? await store.profile(c.userId).catch(() => null) : null
     return { member_id: c.account, kind: 'person', name: (p && p.name) || 'person' }
   }
-  routes.push(...quiltRoutes({ quilts, identify: identifyQuiltMember }))
+  routes.push(['GET', /^\/v1\/seam\/me$/, (req) => identifySeamMember(req)])
+  // "Connect Seam": a person links their own Seam account (Seam's OAuth); off without seamClientId.
+  routes.push(...seamConnectRoutes({ store, person, now, apiUrl: api, seamUrl, seamSiteUrl, clientId: seamClientId, secret: seamConnectSecret || passKey, fetch: seamFetch, log }))
 
   async function openLink (code) {
     const userCode = normalizeUserCode(code)
@@ -488,6 +492,7 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
     try {
       if (pathname.startsWith('/v1/file-data/') && files instanceof DiskStore) return await serveFileData(req, res, send, pathname.slice('/v1/file-data/'.length))
       if (pathname === '/mcp') return await proxyMcp(req, res, send)
+      if (SEAM_PATH.test(pathname)) return await forwardSeam(req, res)
       if (req.method === 'GET' && (pathname === '/v1/releases/latest' || pathname.startsWith('/v1/download/'))) return await serveRelease(req, res, send, pathname)
       const url = new URL(req.url, 'http://x')
       const route = routes.find(([m, re]) => m === req.method && re.test(url.pathname))
@@ -514,6 +519,25 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
     }
   })
 
+  // Seam's routes moved to Seam's own server (docs/seam-service.md): old seam commands and sites
+  // still call them here, so they go on to seamUrl as sent, and Seam's answer comes straight back.
+  async function forwardSeam (req, res) {
+    if (!seamUrl) throw new HttpError(404, 'not found')
+    const headers = {}
+    for (const h of ['authorization', 'content-type', 'accept']) if (req.headers[h]) headers[h] = req.headers[h]
+    const hasBody = !['GET', 'HEAD', 'DELETE'].includes(req.method)
+    let up
+    try {
+      up = await seamFetch(seamUrl.replace(/\/+$/, '') + req.url, { method: req.method, headers, ...(hasBody ? { body: await readRaw(req, SEAM_MAX_BODY), duplex: 'half' } : {}), redirect: 'manual' })
+    } catch (err) {
+      if (err instanceof HttpError) throw err
+      throw new HttpError(502, 'Seam did not answer; try again')
+    }
+    const body = Buffer.from(await up.arrayBuffer())
+    res.writeHead(up.status, { 'content-type': up.headers.get('content-type') || 'application/json', 'cache-control': 'no-store', ...cors(req) })
+    res.end(body)
+  }
+
   // Downloads and the update check (releases.js): public, from the private repository's latest
   // release, read as Quilt's GitHub App. A download is a redirect to GitHub's own short-lived link.
   const releases = releaseSource({ github, fetch: githubFetch, now, apiUrl: api })
@@ -681,6 +705,10 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
 // Which room a hosted agent's MCP request is about: shared with the relay (src/mcp-room.js).
 export { joiningRoom, sessionArg } from '../mcp-room.js'
 
+// Seam's routes, answered by Seam's own server now (forwardSeam). Its biggest body is a pack.
+const SEAM_PATH = /^\/v1\/(quilts|imports|search|signing-keys)(\/|$)/
+const SEAM_MAX_BODY = 96 * 1024 * 1024
+
 function decodePart (s) {
   try { return decodeURIComponent(s) } catch { throw new HttpError(400, 'bad path') }
 }

package/src/api/supabase-store.js

@@ -885,6 +885,16 @@ export function createSupabaseStore ({ url, serviceKey, client }) {
       await one(db.from('secret_data_keys').upsert({ scope_type: scopeType, scope_id: scopeId, version, sealed_key: sealedKey, provider }, { onConflict: 'scope_type,scope_id,version', ignoreDuplicates: true }))
       return rowFrom(await one(db.from('secret_data_keys').select(SECRET_DATA_KEY).eq('scope_type', scopeType).eq('scope_id', scopeId).eq('version', version).single()))
     },
+    // "Connect Seam" (routes/seam-connect.js): the person's Seam tokens, one row per Quilt user.
+    async seamLink (userId) {
+      const r = await one(db.from('seam_links').select('user_id,access_token,refresh_token,scope,expires_at,connected_at').eq('user_id', userId).maybeSingle())
+      return r ? { userId: r.user_id, access: r.access_token, refresh: r.refresh_token, scope: r.scope, expiresAt: Date.parse(r.expires_at), connectedAt: Date.parse(r.connected_at) } : null
+    },
+    async putSeamLink (userId, link) {
+      await one(db.from('seam_links').upsert({ user_id: userId, access_token: link.access, refresh_token: link.refresh, scope: link.scope || '', expires_at: ts(link.expiresAt), connected_at: ts(link.connectedAt ?? Date.now()), updated_at: new Date().toISOString() }, { onConflict: 'user_id' }))
+      return { userId, access: link.access, refresh: link.refresh, scope: link.scope || '', expiresAt: link.expiresAt, connectedAt: link.connectedAt ?? Date.now() }
+    },
+    async deleteSeamLink (userId) { await one(db.from('seam_links').delete().eq('user_id', userId)) },
     async secretSettings (scopeType, scopeId) {
       const r = rowFrom(await one(db.from('secret_scope_settings').select(SECRET_SETTINGS).eq('scope_type', scopeType).eq('scope_id', scopeId).maybeSingle()))
       return r || { scopeType, scopeId, inheritOff: false, inheritOffBy: null, inheritOffAt: null, agentsOn: false, agents: 'all', updatedAt: null }

package/src/connection.js

@@ -382,7 +382,10 @@ export class Connection extends EventEmitter {
         this.noteSynced()
       }
     } else if (type === MSG_BRANCHES) {
-      const { branches, reply, pushed } = JSON.parse(decoding.readVarString(dec))
+      const { branches, reply, pushed, quilt } = JSON.parse(decoding.readVarString(dec))
+      // The session is a quilt (Seam): its link, or null while it is not.
+      const link = quilt && typeof quilt.id === 'string' ? quilt : null
+      if (JSON.stringify(link) !== JSON.stringify(this.quilt || null)) { this.quilt = link; this.emit('quilt', link) }
       // GitHub moved a branch the session follows (the relay heard it from GitHub): look now.
       if (pushed && typeof pushed.branch === 'string') this.emit('pushed', pushed)
       if (reply && this.joining && reply.id === this.joining.id) {

package/src/control.js

@@ -1,5 +1,6 @@
 // Local control API (127.0.0.1 only) so the CLI and the MCP server can talk to
 // a running session. Discovery info is written to .quilt/daemon.json.
+import { readAccount } from './account.js'
 import http from 'node:http'
 import fs from 'node:fs'
 import path from 'node:path'
@@ -106,6 +107,17 @@ export async function startControl (session, extras = {}) {
     // The relay's own list, with where each branch stands with GitHub (quilt_sync_status).
     'GET /sync-status': () => ({ branches: session.branchList || [], mine: session.branchKey ? session.branchKey() : '' }),
     'POST /branches/sync': () => session.syncBranchNow(),
+    // `quilt session migrate --dry-run`: what making the session a quilt would do (the relay's dry run).
+    'POST /quilt-plan': () => session.quiltPlan(),
+    // The quilt this session is (Seam), as the relay last said; null while it is not (session-seam.js).
+    'GET /quilt': () => ({ quilt: session.quilt || null }),
+    // `quilt session migrate`: the relay makes the session a quilt, as its owner (their sign-in).
+    'POST /quilt-migrate': () => session.quiltMigrate(process.env.SEAM_TOKEN || (readAccount() || {}).token),
+    // `quilt session migrate --switch` / `--back`: the session's files into its squares (layout 3), or back.
+    'POST /quilt-switch': () => session.quiltSwitch(process.env.SEAM_TOKEN || (readAccount() || {}).token),
+    'POST /quilt-unswitch': () => session.quiltUnswitch(),
+    // `quilt session follow <folder>`: at layout 3, that folder follows this branch's square, live.
+    'POST /quilt-follow': (b) => session.quiltFollow(process.env.SEAM_TOKEN || (readAccount() || {}).token, b.dir),
     'POST /commit-request': (b) => session.requestCommit(b.message, { files: b.files == null ? null : b.files, description: b.description || '', task: b.task || null, via: b.via ? String(b.via) : null }),
     // quilt_commit: the relay commits the session's copy of the files to GitHub (relay-commit.js).
     'POST /agent-commits': (b) => session.setAgentCommits(b.mode),

package/src/history.js

@@ -252,6 +252,20 @@ export function queryHistory (entries, { path, by, since, task, limit = 50 } = {
   return list
 }
 
+export const LEGACY_DAYS = 90
+
+/**
+ * The chronology once the session became a quilt at `at` (an ISO date, meta.quilt.at): entries from
+ * before then are its legacy tail (plans/quilt-source-control/16), marked `legacy: true` for
+ * LEGACY_DAYS and then left out. Not a quilt (no `at`): the entries as they are.
+ */
+export function legacyTail (entries, { at, now = Date.now() } = {}) {
+  const t = at ? Date.parse(at) : NaN
+  if (!Number.isFinite(t)) return entries
+  if (now - t > LEGACY_DAYS * 24 * 60 * 60 * 1000) return entries.filter((e) => !(e && e.ts < t))
+  return entries.map((e) => e && e.ts < t ? { ...e, legacy: true } : e)
+}
+
 function ago (ts, now) {
   const s = Math.max(0, Math.round((now - ts) / 1000))
   if (s < 60) return `${s}s ago`
@@ -268,7 +282,7 @@ export function formatHistory (list, { withDiff = false, now = Date.now() } = {}
     const span = e.from && e.ts - e.from > 60000 ? ` over ${Math.round((e.ts - e.from) / 60000)}m` : ''
     const what = e.detail ? ` (${e.detail})` : ''
     const task = e.task ? ` for "${e.task.title}" [${e.task.id}]` : ''
-    out.push(`[${ago(e.ts, now)}] ${e.by} ${e.kind} ${e.path}${what}${e.pulled ? ' by pulling from git' : ''}${span}${task}`)
+    out.push(`[${ago(e.ts, now)}] ${e.by} ${e.kind} ${e.path}${what}${e.pulled ? ' by pulling from git' : ''}${span}${task}${e.legacy ? ' (before the session became a quilt)' : ''}`)
     if (withDiff && e.diff) out.push(e.diff, '')
   }
   return out.join('\n').replace(/\n+$/, '')

package/src/mcp.js

@@ -46,6 +46,7 @@ import { CLASH_DESCRIPTION, clashSchema } from './relay-clash.js'
 import { describeSecretNames, SECRET_NAMES_DESCRIPTION, RUN_GUIDE } from './secret-names.js'
 import { appWorkspaces } from './app-workspaces.js'
 import { TRANSCRIPT_DESCRIPTION, renderLines } from './voice.js'
+import { seamGate, seamNote } from './session-seam.js'
 
 // The board's columns, from tasks.js, so this and the hosted MCP (relay-mcp.js) never drift apart.
 const COLUMN_IDS_LIST = COLUMNS.map((c) => c.id)
@@ -221,12 +222,22 @@ export async function runMcp () {
     return `${label ? `Assigned to ${label}.` : 'Unassigned.'}${files}`
   }
 
+  // Seam (plans/quilt-source-control/12, 16): in a session that is a quilt, the GitHub tools
+  // refuse with the Seam tool to use instead, the same for every AI tool (session-seam.js).
+  const quiltNow = async () => {
+    const d = findDaemon(joined ? joined.dir : undefined)
+    if (!d) return null
+    try { return (await call(d, 'GET', '/quilt')).quilt || null } catch { return null }
+  }
+  server.registerTool = seamGate(server.registerTool.bind(server), quiltNow)
+
   server.registerTool('quilt_status', {
     description: 'See who else is in the live session, what they are working on, which files they recently edited or claimed, recent messages, and which open tasks are assigned to you. Call this before starting work.',
     inputSchema: {}
   }, () => withDaemon(async (d) => {
     const st = await call(d, 'GET', '/status')
-    return renderStatus(st, { asAi: taskReader(st).asAi, mentionYours: true })
+    const q = await quiltNow()
+    return (q ? seamNote(q.slug || q.id) + '\n\n' : '') + renderStatus(st, { asAi: taskReader(st).asAi, mentionYours: true })
   }))
 
   server.registerTool('quilt_tasks', {