heyquilt 0.0.1 → 0.3.90

package/src/ui-server.js

@@ -0,0 +1,1272 @@
+// Local web UI: start/join sessions, chat, share files, see collaborators.
+// Listens on 127.0.0.1 only and requires a per-launch token, so web pages you
+// visit can't drive it.
+import http from 'node:http'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import { runSession, decodeInvite, newConn, readConfig, recentSessions, forgetRecent, rememberWorkspace, forgetWorkspace } from './runner.js'
+import { MAX_SHARED_FILE_BYTES } from './protocol.js'
+import { getSettings, saveSettings, unsupportedRelay, relayUrl } from './settings.js'
+import { PICKUP_MODES, pickupMode } from './tasks.js'
+import { AGENT_COMMITS } from './github-commit.js'
+import * as gitops from './git.js'
+import { execFile } from 'node:child_process'
+import { installedEditors, openIn, copyToClipboard } from './editors.js'
+import { autowork, autoConfig, publicConfig, AUTO_MODES } from './autowork.js'
+import { migrateDir } from './legacy.js'
+import { writePrivateJson } from './private-file.js'
+import { readAccount, saveAccount, workspaceGithub, setWorkspaceGithub, removeWorkspaceGithub, setOrgGithub, clearAccount, clearAccountIf, resumeAccount, startLink, waitForLink, fetchMe, signOut, revokeToken, accountFromProfile, renameSession, createAgentInvite, listAgents, listAccessTypes, listCollaborators, listGrants, putGrant, deleteGrant, inviteToSession, listSessionInvites, cancelSessionInvite, listWorkspaces, listOrgs, createWorkspace, getWorkspace, updateWorkspace, deleteWorkspace, putWorkspaceMember, removeWorkspaceMember, getAgentPlacement, putAgentPlacement, listOrgAgents, putWorkspaceAgent, deleteWorkspaceAgent, createWorkspaceAgentInvite, excludeSessionAgent, listExcludedSessionAgents, listSessionAgents, includeSessionAgent, setSessionWorkspace, moveSessionToWorkspace, listWorkspaceInvites, inviteToWorkspace, cancelWorkspaceInvite, listMyInvites, answerMyInvite, announceSessionStarted, announceWhenReported, listWorkspaceFiles, createWorkspaceFile, confirmWorkspaceFile, workspaceFileDownload, updateWorkspaceFile, deleteWorkspaceFile, createWorkspaceFolder, listWorkspaceFileVersions, githubStatus, githubConnectUrl, aiVmFollow, aiVmUnfollow, aiVmStatus, aiVmConnect, aiVmUpdate, aiVmSignIn, aiVmWake, aiVmDisconnect } from './account.js'
+import { personaName } from './persona.js'
+import { CLOUD_LABEL } from './cloud-ai.js'
+import { effectiveAccess, builtinType } from './session-access.js'
+import { cleanSessionName, BAD_SESSION_NAME, SESSION_NAME_MAX } from './session-name.js'
+import { personPasses } from './pass-source.js'
+import { INVALID_INVITE } from './ui/invite.js'
+import { loadIdentity } from './identity.js'
+import { currentVersion, localReleases, latestRelease, compareVersions, downloadUrl, seenVersion, markSeen, hiddenUpdate, hideUpdate } from './releases.js'
+import { createReporter } from './report.js'
+import { queryHistory } from './history.js'
+import { contentDisposition } from './api/file-paths.js'
+
+const TOOL_NAMES = ['Claude Code', 'Cursor', 'Codex', 'xAI', 'Windsurf', 'GitHub Copilot', 'Zed', 'Aider', 'Other']
+const MAX_WS_FILE_BYTES = 500 * 1024 * 1024
+const COLOR_RE = /^#[0-9a-f]{6}$/i
+const THEMES = ['light', 'dark', 'system']
+const SAVE_FAILED = "Quilt couldn't save your sign-in on this computer."
+const SIGNED_OUT_MESSAGE = 'This computer was signed out. Sign in again.'
+const LOCAL_RELAY_GONE = "This session ran on your computer's own relay, which Quilt no longer supports. Your files are untouched."
+// Until this computer is signed in, only these answer.
+const OPEN_ROUTES = new Set(['GET /api/account', 'POST /api/account/start', 'POST /api/account/cancel', 'POST /api/account/signout', 'GET /api/events', 'POST /api/shutdown', 'POST /api/report'])
+
+// The sound switches in Settings, one per event (SOUND_EVENTS in src/ui/sounds.js).
+const SOUND_SETTINGS = ['soundMentions', 'soundLetIn', 'soundTasks']
+
+/** Your profile and preferences, from ~/.quilt/settings.json with sensible defaults. */
+function profile () {
+  const s = getSettings()
+  const account = readAccount()
+  return {
+    name: account ? account.account.name : os.userInfo().username,
+    tool: s.tool || detectTool(),
+    color: s.color || null,
+    joinDir: s.joinDir || '~/quilt',
+    shareAgent: s.shareAgent !== false,
+    summarize: !!s.summarize,
+    preferLocal: !!s.preferLocal,
+    // Quilt pushes your local commits for you on branches that sync with GitHub: off unless you turn it on.
+    pushLocalCommits: s.pushLocalCommits === true,
+    theme: THEMES.includes(s.theme) ? s.theme : 'dark', // dark unless you pick another
+    report: s.report !== false,
+    aiTasks: pickupMode(s.aiTasks),
+    // What agents may commit in sessions you start ('off', 'branches', 'any'); each session's owner can change it there.
+    agentCommits: AGENT_COMMITS.includes(s.agentCommits) ? s.agentCommits : 'branches',
+    // When work comes to your AI (autowork.js): 'chat', 'open' or 'auto', with its model, files and daily cap.
+    auto: publicConfig(autoConfig(s)),
+    // Sounds (src/ui/sounds.js): each on unless switched off.
+    ...Object.fromEntries(SOUND_SETTINGS.map((k) => [k, s[k] !== false]))
+  }
+}
+
+/** Checks and saves profile/preference changes. Returns the new profile. */
+function updateProfile (b) {
+  const patch = {}
+  // Your name is your account's: it's changed on the website.
+  if ('name' in b) throw httpError(400, 'Change your name on heyquilt.com.')
+  if ('tool' in b) {
+    if (!TOOL_NAMES.includes(b.tool)) throw httpError(400, 'Pick an AI tool from the list.')
+    patch.tool = b.tool
+  }
+  if ('color' in b) {
+    if (b.color && !COLOR_RE.test(b.color)) throw httpError(400, 'That color isn\'t valid.')
+    patch.color = b.color || undefined
+  }
+  if ('joinDir' in b) patch.joinDir = String(b.joinDir || '').trim() || undefined
+  if ('shareAgent' in b) patch.shareAgent = b.shareAgent ? undefined : false
+  if ('summarize' in b) patch.summarize = b.summarize ? true : undefined
+  if ('preferLocal' in b) patch.preferLocal = b.preferLocal ? true : undefined
+  if ('pushLocalCommits' in b) patch.pushLocalCommits = b.pushLocalCommits ? true : undefined
+  if ('theme' in b) {
+    if (!THEMES.includes(b.theme)) throw httpError(400, 'Pick Light, Dark or System.')
+    patch.theme = b.theme === 'dark' ? undefined : b.theme
+  }
+  if ('report' in b) patch.report = b.report ? undefined : false
+  if ('aiTasks' in b) {
+    if (!PICKUP_MODES.includes(b.aiTasks)) throw httpError(400, 'Pick Off, Assigned to it, or Assigned and unassigned.')
+    patch.aiTasks = b.aiTasks === 'off' ? undefined : b.aiTasks
+  }
+  if ('agentCommits' in b) {
+    if (!AGENT_COMMITS.includes(b.agentCommits)) throw httpError(400, 'Pick Not at all, To branches of their own, or To any branch.')
+    patch.agentCommits = b.agentCommits === 'branches' ? undefined : b.agentCommits
+  }
+  if ('autoWork' in b) {
+    if (!AUTO_MODES.includes(b.autoWork)) throw httpError(400, 'Pick Leave it for my chat, Open it in my tool, or Work on its own.')
+    patch.autoWork = b.autoWork === 'chat' ? undefined : b.autoWork
+  }
+  if ('autoModel' in b) {
+    const m = String(b.autoModel || '').trim()
+    if (m && !/^[\w.:/-]{1,60}$/.test(m)) throw httpError(400, 'That model name isn\'t valid.')
+    patch.autoModel = m || undefined
+  }
+  if ('autoFiles' in b) patch.autoFiles = b.autoFiles ? true : undefined
+  if ('autoCap' in b) {
+    const n = b.autoCap === '' || b.autoCap === null ? 0 : Number(b.autoCap)
+    if (!Number.isInteger(n) || n < 0 || n > 1e9) throw httpError(400, 'The daily limit is a whole number of tokens (0 for none).')
+    patch.autoCap = n || undefined
+  }
+  for (const k of SOUND_SETTINGS) if (k in b) patch[k] = b[k] ? undefined : false
+  saveSettings(patch) // undefined values clear a setting
+  return profile()
+}
+
+const UI_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'ui')
+const LOGO = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'assets', 'logo.svg')
+// Fonts are bundled from npm so the app works offline and never calls a font CDN.
+const FONT_PACKAGES = ['poppins', 'ibm-plex-mono']
+const require = createRequire(import.meta.url)
+const fontFile = (pkg, file) => {
+  if (!FONT_PACKAGES.includes(pkg) || !/^[a-z0-9-]+\.woff2$/.test(file)) return null
+  const f = path.join(path.dirname(require.resolve(`@fontsource/${pkg}/package.json`)), 'files', file)
+  return fs.existsSync(f) ? f : null
+}
+// Every module src/ui/*.js imports must be listed here, or the page fails to load (test/ui-static-allowlist.test.js).
+export const STATIC = {
+  '/': ['index.html', 'text/html; charset=utf-8'],
+  '/app.js': ['app.js', 'text/javascript; charset=utf-8'],
+  '/app.css': ['app.css', 'text/css; charset=utf-8'],
+  '/common.js': ['common.js', 'text/javascript; charset=utf-8'],
+  '/mark.js': ['mark.js', 'text/javascript; charset=utf-8'],
+  '/invite.js': ['invite.js', 'text/javascript; charset=utf-8'],
+  '/agent-guide.js': ['agent-guide.js', 'text/javascript; charset=utf-8'],
+  '/access-form.js': ['access-form.js', 'text/javascript; charset=utf-8'],
+  '/session.js': ['session.js', 'text/javascript; charset=utf-8'],
+  '/chat.js': ['chat.js', 'text/javascript; charset=utf-8'],
+  '/feed.js': ['feed.js', 'text/javascript; charset=utf-8'],
+  '/tool-logo.js': ['tool-logo.js', 'text/javascript; charset=utf-8'],
+  '/tree.js': ['tree.js', 'text/javascript; charset=utf-8'],
+  '/fileview.js': ['fileview.js', 'text/javascript; charset=utf-8'],
+  '/merges.js': ['merges.js', 'text/javascript; charset=utf-8'],
+  '/catchup.js': ['catchup.js', 'text/javascript; charset=utf-8'],
+  '/home.js': ['home.js', 'text/javascript; charset=utf-8'],
+  '/signin.js': ['signin.js', 'text/javascript; charset=utf-8'],
+  '/changes.js': ['changes.js', 'text/javascript; charset=utf-8'],
+  '/diffview.js': ['diffview.js', 'text/javascript; charset=utf-8'],
+  '/boxes.js': ['boxes.js', 'text/javascript; charset=utf-8'],
+  '/releases.js': ['releases.js', 'text/javascript; charset=utf-8'],
+  '/feed-convs.js': ['feed-convs.js', 'text/javascript; charset=utf-8'],
+  '/loom.js': ['loom.js', 'text/javascript; charset=utf-8'],
+  '/loom-model.js': ['loom-model.js', 'text/javascript; charset=utf-8'],
+  '/rail.js': ['rail.js', 'text/javascript; charset=utf-8'],
+  '/rail-model.js': ['rail-model.js', 'text/javascript; charset=utf-8'],
+  '/loom.css': ['loom.css', 'text/css; charset=utf-8'],
+  '/board.js': ['board.js', 'text/javascript; charset=utf-8'],
+  '/schedule.js': ['schedule.js', 'text/javascript; charset=utf-8'],
+  '/branches.js': ['branches.js', 'text/javascript; charset=utf-8'],
+  '/workspaces.js': ['workspaces.js', 'text/javascript; charset=utf-8'],
+  '/invites.js': ['invites.js', 'text/javascript; charset=utf-8'],
+  '/agent-place.js': ['agent-place.js', 'text/javascript; charset=utf-8'],
+  '/agent-kinds.js': ['agent-kinds.js', 'text/javascript; charset=utf-8'],
+  '/files.js': ['files.js', 'text/javascript; charset=utf-8'],
+  '/csv.js': ['csv.js', 'text/javascript; charset=utf-8'],
+  '/sounds.js': ['sounds.js', 'text/javascript; charset=utf-8'],
+  '/git-rule.js': ['git-rule.js', 'text/javascript; charset=utf-8'],
+  '/cloud-ai.js': ['cloud-ai.js', 'text/javascript; charset=utf-8'],
+  '/cloud-ai-model.js': ['cloud-ai-model.js', 'text/javascript; charset=utf-8']
+}
+
+// The page's Content-Security-Policy: scripts only from our own files (no inline script or
+// event handlers, the second line of defence against injected markup), fonts and the event
+// stream from this server, inline style attributes allowed since the UI sets them, and
+// Google's favicon service (plus its gstatic.com redirect hosts) for provider logos,
+// and https images so ticket notes can show linked screenshots.
+const CSP = [
+  "default-src 'self'",
+  "script-src 'self'",
+  "style-src 'self' 'unsafe-inline'",
+  "img-src 'self' data: https: https://www.google.com https://*.gstatic.com",
+  "font-src 'self'",
+  "connect-src 'self'",
+  "object-src 'none'",
+  "base-uri 'none'",
+  "form-action 'self'",
+  "frame-ancestors 'none'"
+].join('; ')
+
+// preview: for development only (`quilt ui --preview`). Opening the bare address hands out the
+// link, so a dev preview pane can show the app. Any local page could then open it too.
+export async function startUi ({ port = 7420, onShutdown, preview = false, reporter, slowMs = 3000, keepOutMs = 3000 } = {}) {
+  // What this app tells Quilt about itself (see report.js). Off with the "report" setting.
+  reporter = reporter || createReporter({ token: () => readAccount()?.token || null, enabled: () => getSettings().report !== false })
+  // Body fields worth keeping with a route's outcome: which editor, which kind of start. Never free text.
+  const CONTEXT_FIELDS = { 'POST /api/sessions/:id/open-in': ['app'], 'POST /api/sessions': ['mode', 'tool', 'prefer'] }
+  const contextFor = (key, body) => Object.fromEntries((CONTEXT_FIELDS[key] || []).filter((f) => typeof body?.[f] === 'string').map((f) => [f, body[f].slice(0, 40)]))
+  // Not recorded: reports about reports. (The event stream never reaches the dispatch block
+  // below — it returns earlier — so it needs no entry here.)
+  const UNRECORDED = new Set(['POST /api/report'])
+  function recordRoute (key, { startedAt, status, body, error }) {
+    // The reporter's own `enabled()` is the single gate on the "report" setting.
+    if (UNRECORDED.has(key)) return
+    const durationMs = Date.now() - startedAt
+    const outcome = error ? 'error' : durationMs > slowMs ? 'slow' : 'ok'
+    // A successful read (GET) isn't worth a row: the renderer polls and refreshes
+    // constantly, and an `ok` there would just be a usage log nobody was told about.
+    // Every non-GET outcome, and every slow or failed GET, is still kept.
+    if (outcome === 'ok' && key.startsWith('GET ')) return
+    reporter.record({ kind: 'action', name: key, outcome, status, durationMs, message: error ? error.message : '', context: contextFor(key, body) })
+  }
+  const token = crypto.randomBytes(18).toString('base64url')
+  const runs = new Map() // id -> { run, logs: [] }
+  const clients = new Set() // SSE responses
+  let passes = null // this computer's passes, shared by all its sessions
+  let link = null // signing in: what startLink returned, plus { state, error }
+  let signedOutReason = null // 'revoked' once the API turned this computer's token away
+  let checkedToken = false // asked the API about the saved token since the app started
+  let resumeTried = false // tried signing back in with this computer's key since the app started
+  let workspacesOn = false // cached result of the last GET /api/workspaces probe
+
+  const accountPasses = () => {
+    if (passes) return passes
+    const account = readAccount()
+    if (!account) throw Object.assign(httpError(401, 'Sign in to Quilt first.'), { signedOut: true })
+    passes = personPasses({ token: account.token })
+    return passes
+  }
+
+  /**
+   * Forgets this computer's sign-in and stops its sessions. 'revoked': this computer isn't
+   * linked any more. `token`: the one turned away; a newer sign-in saved since is kept.
+   */
+  async function signedOut (reason, token) {
+    // Forget the sign-in first, so a start can't pick it up again while sessions stop.
+    passes = null
+    if (token) clearAccountIf(token)
+    else clearAccount()
+    for (const id of [...runs.keys()]) await stop(id)
+    signedOutReason = reason
+    broadcast('signed-out', { reason })
+  }
+
+  /**
+   * This computer's token was turned away (or it has none): sign back in with its key. The
+   * new sign-in, or null once the API says this computer isn't linked. Offline, the saved
+   * sign-in stands (`fallback`).
+   */
+  async function resume (fallback = null) {
+    try {
+      const back = await resumeAccount()
+      if (back) { passes = null; signedOutReason = null }
+      return back
+    } catch {
+      return fallback
+    }
+  }
+
+  async function accountState () {
+    let account = readAccount()
+    // No sign-in saved (lost, or another app's sign-out): a linked computer just carries on.
+    if (!account && !resumeTried) {
+      resumeTried = true
+      account = await resume()
+      if (account) checkedToken = true
+    }
+    if (account && !checkedToken) {
+      checkedToken = true
+      try {
+        // Picks up a name changed on heyquilt.com, and notices a computer unlinked there.
+        const fresh = { ...account, account: accountFromProfile(await fetchMe({ token: account.token })) }
+        saveAccount(fresh)
+        account = fresh
+      } catch (err) {
+        if (err.status === 401) {
+          const back = await resume(account)
+          if (!back) { await signedOut('revoked', account.token); account = null } else account = back
+        }
+        // Anything else (offline): keep the saved sign-in.
+      }
+    }
+    return {
+      signedIn: !!account,
+      account: account ? account.account : null,
+      reason: account ? null : signedOutReason,
+      link: link ? { state: link.state, userCode: link.userCode, verificationUrl: link.verificationUrl, error: link.error } : null
+    }
+  }
+
+  /** Starts linking this computer; the website approves it, and we collect the token in the background. */
+  async function beginLink () {
+    if (readAccount()) throw httpError(409, 'Already signed in.')
+    // A computer linked before signs straight back in: no browser, no approving it again.
+    try {
+      if (await resumeAccount({ asked: true })) {
+        link = null
+        passes = null
+        signedOutReason = null
+        checkedToken = true
+        broadcast('signed-in', {})
+        return accountState()
+      }
+    } catch {}
+    const identity = loadIdentity()
+    const mine = { ...await startLink({ identity }), state: 'waiting', error: null }
+    link = mine
+    waitForLink({ identity, link: mine, stopped: () => link !== mine }).then((r) => {
+      // Approved after it was cancelled or replaced: don't leave that token live on the server.
+      if (link !== mine) return revokeToken({ token: r.token })
+      // Not saved (or an odd reply), so this computer isn't signed in: don't leave the token live either.
+      const failed = (message) => {
+        revokeToken({ token: r.token })
+        mine.state = 'failed'
+        mine.error = message
+      }
+      let account
+      try { account = accountFromProfile(r.profile) } catch (err) { return failed(err.message) }
+      try {
+        saveAccount({ token: r.token, account, signedInAt: Date.now() })
+      } catch {
+        return failed(SAVE_FAILED)
+      }
+      link = null
+      passes = null
+      signedOutReason = null
+      checkedToken = true
+      broadcast('signed-in', {})
+    }, (err) => {
+      if (link !== mine) return
+      mine.state = err.expired ? 'expired' : err.denied ? 'denied' : 'failed'
+      mine.error = err.message
+    })
+    return accountState()
+  }
+
+  const idFor = (dir) => crypto.createHash('sha1').update(path.resolve(dir)).digest('hex').slice(0, 10)
+  // Recent sessions not open now. Ones that ran on another relay are marked: they can't reopen.
+  const recentList = () => recentSessions().filter((r) => !runs.has(idFor(r.dir))).map((r) => ({ ...r, unsupported: unsupportedRelay(r.server) }))
+  const broadcast = (type, data) => {
+    const frame = `event: ${type}\ndata: ${JSON.stringify(data)}\n\n`
+    for (const res of clients) res.write(frame)
+  }
+  const summary = (id) => {
+    const r = runs.get(id)
+    return { id, dir: r.run.dir, invite: r.run.invite, viewInvite: r.run.viewInvite, status: r.run.session.status(), logs: r.logs.slice(-80), workspace: readConfig(r.run.dir)?.workspace || '' }
+  }
+  const pushStatus = (id) => runs.has(id) && broadcast('session', summary(id))
+
+  async function start ({ mode, dir, tool, invite, prefer, repo, branch, newBranch, base, workspace }) {
+    const me = profile()
+    // Every session signs in to the relay as this computer's account.
+    const sessionPasses = accountPasses()
+    // Signing out (or in again) replaces `passes`, so a start that outlives the sign-in it began under can tell.
+    const current = () => passes === sessionPasses
+    const outlived = () => readAccount()
+      ? httpError(409, 'Your sign-in changed while this session was starting. Start it again.')
+      : Object.assign(httpError(401, 'Sign in to Quilt first.'), { signedOut: true })
+    if (mode === 'github') {
+      // Clone first, then start a normal session on the clone.
+      const repoName = String(repo || '').split('/').pop()
+      dir = path.resolve(expandHome(dir || underJoinDir(me.joinDir, repoName || 'repo', 'That repository name is not valid.')))
+      if (runs.has(idFor(dir))) throw httpError(400, 'A session is already running in that folder.')
+      await gitops.cloneRepo({ repo, dir, branch, newBranch, base })
+      if (!current()) throw outlived()
+      mode = 'create'
+    }
+    tool = tool || me.tool
+    prefer = prefer || (me.preferLocal ? 'local' : 'remote')
+    if (mode === 'join' && !dir) {
+      const inv = decodeInvite(invite || '')
+      dir = underJoinDir(me.joinDir, inv.room)
+    }
+    if (!dir) throw new Error('Choose a project folder.')
+    dir = path.resolve(expandHome(dir))
+    const id = idFor(dir)
+    if (runs.has(id)) return summary(id)
+
+    let conn
+    let inviteServer
+    if (mode === 'join') {
+      conn = decodeInvite(invite || '')
+    } else if (mode === 'rejoin') {
+      const saved = readConfig(dir)
+      if (!saved) throw new Error('No previous session in that folder.')
+      if (unsupportedRelay(saved.server)) throw httpError(400, LOCAL_RELAY_GONE)
+      conn = { server: saved.server, room: saved.room, secret: saved.secret, ...(saved.viewSecret ? { viewSecret: saved.viewSecret } : {}) }
+      inviteServer = unsupportedRelay(saved.inviteServer) ? undefined : saved.inviteServer
+      tool = tool || saved.tool
+    } else {
+      conn = newConn()
+    }
+
+    const entry = { logs: [] }
+    const log = (line) => {
+      entry.logs.push({ ts: Date.now(), line })
+      if (entry.logs.length > 200) entry.logs.shift()
+      broadcast('log', { id, ts: Date.now(), line })
+    }
+    entry.log = log
+    try {
+      entry.run = await runSession({
+        dir,
+        conn,
+        // The account's name until the first pass names us (the same name, from the API).
+        name: me.name,
+        tool,
+        color: me.color,
+        shareByDefault: me.shareAgent,
+        summarizeByDefault: me.summarize,
+        joined: mode === 'join',
+        prefer: prefer === 'local' ? 'local' : 'remote',
+        inviteServer,
+        passes: sessionPasses,
+        // A new session is named after its folder (the owner can rename it later).
+        startName: mode === 'create' ? cleanSessionName([...path.basename(dir)].slice(0, SESSION_NAME_MAX).join('')) || '' : '',
+        // Your default for what agents may commit, set on the new room once the relay makes you its owner.
+        startAgentCommits: mode === 'create' ? me.agentCommits : '',
+        workspace: workspace || '',
+        onLog: log,
+        onFatal: async (err) => {
+          log(`stopped: ${err.message}`)
+          await stop(id)
+          // Only this sign-in's passes may sign it out: a stale session's 401 is about a token already gone.
+          if (err.signedOut && current()) await signedOut('revoked')
+        }
+      })
+    } catch (err) {
+      if (!current()) throw outlived()
+      if (err.signedOut) {
+        await signedOut('revoked')
+        throw Object.assign(httpError(401, err.message), { signedOut: true })
+      }
+      throw err
+    }
+    if (!current()) {
+      // Signed out while it was starting: it must not keep running on the old sign-in.
+      await entry.run.stop().catch(() => {})
+      throw outlived()
+    }
+    runs.set(id, entry)
+    const s = entry.run.session
+    s.on('status-changed', () => pushStatus(id))
+    s.on('access', () => pushStatus(id))
+    s.on('message', (m) => broadcast('message', { id, message: m }))
+    s.on('agent-feed', (entries) => broadcast('feed', { id, entries }))
+    s.on('file-changed', (e) => broadcast('file-changed', { id, ...e }))
+    // Presence changes (e.g. focus, recently edited files) also refresh the view.
+    s.conn.awareness.on('change', () => pushStatus(id))
+    // The person's cloud AI, when they connected one, joins the sessions they join.
+    followWithCloudAi(entry.run.invite, log)
+    if (workspace && mode === 'create') {
+      // Put the new room in its workspace before anyone else connects. A failure is logged, never
+      // fatal, and the session is outside any workspace here too, as it is on the API.
+      // mode was reassigned to 'create' for github clones above, so this covers both.
+      const linked = await asAccount((token) => setSessionWorkspace({ token, id: workspace, room: conn.room })).then(() => true, (err) => {
+        log(`could not add this session to its workspace: ${err.message}`)
+        forgetWorkspace(entry.run.dir)
+        return false
+      })
+      // Then hand its link to the agents that join it by themselves, in the background: the
+      // session never waits for this, and a failure is only logged.
+      if (linked) {
+        const link = entry.run.invite
+        announceWhenReported(() => asAccount((token) => announceSessionStarted({ token, id: workspace, room: conn.room, link })), {
+          alive: () => runs.get(id) === entry && current(),
+          log
+        }).catch(() => {})
+      }
+    }
+    return summary(id)
+  }
+
+  async function stop (id) {
+    const r = runs.get(id)
+    if (!r) return
+    runs.delete(id)
+    await r.run.stop()
+    broadcast('stopped', { id })
+  }
+
+  const get = (id) => {
+    const r = runs.get(id)
+    if (!r) throw httpError(404, 'That session is not running.')
+    return r.run.session
+  }
+
+  /**
+   * The owner renames a session: on the relay, so everyone in it sees the new name, then on
+   * heyquilt.com. Until the relay has reported a new session there (within a minute) the
+   * website answers 404, and the relay's own report carries the new name instead.
+   */
+  async function rename (id, raw) {
+    const s = get(id)
+    if (!s.isOwner) throw httpError(403, 'Only the session owner can rename it.')
+    const name = cleanSessionName(raw)
+    if (!name) throw httpError(400, BAD_SESSION_NAME)
+    await s.rename(name)
+    try {
+      await renameSession({ token: readAccount()?.token, room: s.room, name })
+    } catch (err) {
+      if (err.status !== 404) throw httpError(502, `Renamed here, but heyquilt.com didn't take it: ${err.message}`)
+    }
+    return { name }
+  }
+
+  // Whether this person has a cloud AI (routes/ai-vm.js on the API), as the API last said: work for
+  // their AI is then its, not this computer's (autowork.js). Learnt from each hand-over below.
+  let hasCloudAi = false
+  autowork().cloudAi = () => hasCloudAi
+  /** Hands a session's link to the person's cloud AI in the background; a failure is only logged. */
+  const followWithCloudAi = (link, log = () => {}) => {
+    if (!readAccount()) return
+    asAccount((token) => aiVmFollow({ token, link })).then((has) => {
+      hasCloudAi = has
+      if (has) log('☁️  your cloud AI is joining this session too')
+    }, (err) => log(`could not tell your cloud AI about this session: ${err.message}`))
+  }
+  // Settings → Your AI: the person's cloud AI, as this computer's account. `vm` is null without one.
+  const CLOUD_TOOLS = ['Claude Code', 'Codex', 'Cursor']
+  const cloudView = (vm) => {
+    hasCloudAi = !!vm
+    if (!vm) return { vm: null }
+    const person = readAccount()?.account?.name || profile().name || 'You'
+    return { vm: { ...vm, name: personaName(person, CLOUD_LABEL) } }
+  }
+  const cloudNone = (err) => { if (err.status === 404) return cloudView(null); throw err }
+  /** What Settings may change: the tool, model, instructions and daily cap (blank is no cap). */
+  const cloudPatch = (b) => {
+    const out = {}
+    if (b.tool !== undefined) out.tool = String(b.tool)
+    if (b.model !== undefined) out.model = String(b.model).trim()
+    if (b.prompt !== undefined) out.prompt = String(b.prompt)
+    if (b.cap !== undefined) {
+      const cap = String(b.cap).trim() === '' ? 0 : Number(b.cap)
+      if (!Number.isInteger(cap) || cap < 0) throw httpError(400, 'The daily cap is a whole number of tokens, or blank for none.')
+      out.cap = cap
+    }
+    return out
+  }
+  const cloudRoutes = {
+    'GET /api/cloud-ai': (b, id, url) => asAccount(async (token) => cloudView(await aiVmStatus({ token, wait: url.searchParams.get('wait') }))),
+    'POST /api/cloud-ai/connect': (b) => {
+      if (!CLOUD_TOOLS.includes(b && b.tool)) throw httpError(400, 'Pick Claude Code, Codex or Cursor.')
+      return asAccount(async (token) => cloudView(await aiVmConnect({ token, tool: b.tool })))
+    },
+    'POST /api/cloud-ai/settings': (b) => { const patch = cloudPatch(b || {}); return asAccount(async (token) => cloudView(await aiVmUpdate({ token, patch }))) },
+    'POST /api/cloud-ai/sign-in': (b) => asAccount(async (token) => aiVmSignIn({ token, ...(b && b.code !== undefined ? { code: String(b.code).trim() } : {}) })),
+    'POST /api/cloud-ai/wake': () => asAccount(async (token) => cloudView(await aiVmWake({ token }))),
+    'POST /api/cloud-ai/disconnect': () => asAccount(async (token) => { await aiVmDisconnect({ token }).catch(cloudNone); hasCloudAi = false; return { ok: true } })
+  }
+
+  /** The person left a session for good: their cloud AI leaves it too. */
+  const unfollowWithCloudAi = (room) => {
+    if (!room || !readAccount() || !hasCloudAi) return
+    asAccount((token) => aiVmUnfollow({ token, room })).catch(() => {})
+  }
+
+  // Agent invites and the list of your agents come from the accounts API, as this computer's account.
+  // A 401 there is checked against /v1/me before it counts: only a token the API no longer knows
+  // signs the app out (an older API that doesn't take the app's token for these yet just errors).
+  const asAccount = async (fn) => {
+    const account = readAccount()
+    if (!account) throw Object.assign(httpError(401, 'Sign in to Quilt first.'), { signedOut: true })
+    try {
+      return await fn(account.token)
+    } catch (err) {
+      if (err.status !== 401) throw err
+      let revoked = false
+      try { await fetchMe({ token: account.token }) } catch (e) { revoked = e.status === 401 }
+      if (!revoked) throw httpError(502, `Quilt's accounts service turned this down: ${err.message}`)
+      // The token is gone, maybe not the link: sign back in with this computer's key and go again.
+      let back
+      try { back = await resumeAccount() } catch (e) { throw httpError(502, `Couldn't sign this computer back in: ${e.message}`) }
+      if (back) { passes = null; signedOutReason = null; return fn(back.token) }
+      await signedOut('revoked', account.token)
+      throw Object.assign(httpError(401, SIGNED_OUT_MESSAGE), { signedOut: true })
+    }
+  }
+
+  // Workspaces live on the accounts API behind a flag: a 404 means off, and the app shows today's home.
+  const workspaceList = () => asAccount(async (token) => {
+    try {
+      const workspaces = await listWorkspaces({ token })
+      workspacesOn = true
+      return { on: true, workspaces }
+    } catch (err) {
+      if (err.status === 404) { workspacesOn = false; return { on: false, workspaces: [] } }
+      throw err
+    }
+  })
+  const needInviteId = (id) => { if (!/^[0-9a-f-]{36}$/i.test(String(id || ''))) throw httpError(400, 'Which invite?'); return String(id) }
+  const needWorkspaceId = (id) => { if (!/^[0-9a-f-]{36}$/i.test(String(id || ''))) throw httpError(400, 'Which workspace?'); return id }
+  const needAgentId = (id) => { if (!/^[0-9a-f-]{36}$/i.test(String(id || ''))) throw httpError(400, 'Which agent?'); return id }
+  const needOrgSlug = (slug) => { if (!/^[a-z0-9][a-z0-9-]{0,63}$/i.test(String(slug || ''))) throw httpError(400, 'Which org?'); return slug }
+  const ofWorkspace = (id) => ({
+    running: [...runs.keys()].filter((k) => (readConfig(runs.get(k).run.dir) || {}).workspace === id),
+    recent: recentList().filter((r) => r.workspace === id)
+  })
+
+  // Access types and invites (the owner's): the API keeps grants, the relay applies them.
+  const ACCOUNT = /^(person|agent):[A-Za-z0-9_-]{1,64}$/
+  const owned = (id) => {
+    const s = get(id)
+    if (!s.isOwner) throw httpError(403, 'Only the session owner can do that.')
+    return s
+  }
+  const admitter = (id) => {
+    const s = get(id)
+    if (!s.canAdmit) throw httpError(403, 'You cannot let people into this session.')
+    return s
+  }
+  const typeById = async (token, typeId) => {
+    // The built-ins are known here, so letting someone in as one works while the API is down.
+    const type = builtinType(typeId) || (await listAccessTypes({ token })).find((t) => t.id === typeId)
+    if (!type) throw httpError(400, 'Pick an access type.')
+    return type
+  }
+  /** Runs `fn` against the API; anything but a 401 (which signs out) becomes a warning instead of an error. */
+  const tryApi = async (fn) => {
+    try { await fn(); return '' } catch (err) {
+      if (err.status === 401) throw err
+      return err.message
+    }
+  }
+
+  /**
+   * Lets someone in as an access type: the grant goes to the API first (so their next pass
+   * carries it), then the relay lets them in with the access it comes to. Someone who isn't
+   * an account (an older app) is still let in, with a warning that nothing was saved.
+   */
+  async function approveAs (id, { key, typeId }) {
+    const s = owned(id)
+    return asAccount(async (token) => {
+      const type = await typeById(token, typeId)
+      let access = effectiveAccess(type, {})
+      let warning = ''
+      if (ACCOUNT.test(String(key))) warning = await tryApi(async () => { access = (await putGrant({ token, room: s.room, account: key, typeId })).access })
+      await s.approve(key, { typeId, access })
+      return warning ? { ok: true, warning: `Let in, but their access wasn't saved on heyquilt.com: ${warning}` } : { ok: true }
+    })
+  }
+
+  /** Changes someone's access type and how it's narrowed: the API, then the relay at once. */
+  async function setAccess (id, { key, typeId, tighten }) {
+    const s = owned(id)
+    if (!ACCOUNT.test(String(key))) throw httpError(400, 'They joined before access types. Change their role instead.')
+    return asAccount(async (token) => {
+      const grant = await putGrant({ token, room: s.room, account: key, typeId, tighten })
+      await s.setMember(key, { access: grant.access })
+      return { grant }
+    })
+  }
+
+  /**
+   * Ends keeping an agent out of a session, and, in a session this computer put in a workspace,
+   * sends that agent the session's link now (when it has a webhook): { ok, notified }. The link
+   * is best effort: the keep-out is gone either way, and a failure is only logged.
+   */
+  async function inviteAgentAgain (id, agentId) {
+    const s = owned(id)
+    await asAccount((token) => includeSessionAgent({ token, room: s.room, agentId }))
+    const r = runs.get(id)
+    const workspace = r && readConfig(r.run.dir)?.workspace
+    if (!workspacesOn || !workspace) return { ok: true, notified: false }
+    const sent = await asAccount((token) => announceSessionStarted({ token, id: workspace, room: s.room, link: r.run.invite, agents: [agentId] }))
+      .catch((err) => { r.log?.(`could not send that agent this session's link: ${err.message}`); return null })
+    return { ok: true, notified: !!sent?.notified?.includes(agentId) }
+  }
+
+  /**
+   * Removes someone, and their grant, so they wait for the owner if they come back. The relay
+   * removes them either way; if the grant couldn't be deleted, their next pass would let them
+   * straight back in, so the owner is told.
+   */
+  async function removeMember (id, key) {
+    const s = owned(id)
+    // With workspaces on, an agent removed from a session in a workspace is also kept out of
+    // this session, so its workspace (or its placement) doesn't let it straight back in. Written
+    // first, so no pass is issued between the removal and the keep-out; never fatal, and given
+    // up after keepOutMs: the removal goes ahead either way, and a failure is only logged.
+    const agent = /^agent:([0-9a-f-]{36})$/i.exec(String(key))
+    const r = runs.get(id)
+    if (workspacesOn && agent && r && readConfig(r.run.dir)?.workspace) {
+      let timer
+      const late = new Promise((resolve, reject) => { timer = setTimeout(() => reject(new Error('Quilt took too long to answer')), keepOutMs) })
+      await Promise.race([asAccount((token) => excludeSessionAgent({ token, room: s.room, agentId: agent[1] })), late])
+        .catch((err) => r.log?.(`could not keep that agent out of this session: ${err.message}`))
+        .finally(() => clearTimeout(timer))
+    }
+    let warning = ''
+    if (ACCOUNT.test(String(key))) {
+      try {
+        warning = await asAccount((token) => tryApi(() => deleteGrant({ token, room: s.room, account: key })))
+      } catch (err) {
+        warning = err.message
+      }
+    }
+    await s.removeMember(key)
+    return warning ? { ok: true, warning: `Removed, but their access is still saved on heyquilt.com, so they can get back in: ${warning}` } : { ok: true }
+  }
+
+  /** Invites someone by email or account. The email carries the session's link: the view link for a view-only type. */
+  async function invite (id, { typeId, to }) {
+    const s = owned(id)
+    const run = runs.get(id).run
+    return asAccount(async (token) => {
+      const type = await typeById(token, typeId)
+      const link = type.files === 'view' && run.viewInvite ? run.viewInvite : run.invite
+      return { invite: await inviteToSession({ token, room: s.room, typeId, to, link }) }
+    })
+  }
+
+  const api = {
+    'GET /api/account': () => accountState(),
+    'GET /api/access-types': () => asAccount(async (token) => ({ types: await listAccessTypes({ token }) })),
+    // Quilt's GitHub App: whether this account connected GitHub, and the link that connects it (opened in the browser).
+    ...cloudRoutes,
+    'GET /api/github': () => asAccount(async (token) => githubStatus({ token })),
+    'POST /api/github/connect': (b) => asAccount(async (token) => ({ url: await githubConnectUrl({ token, repo: b && b.repo, ...(b && ['workspace', 'org'].includes(b.scope) ? { scope: b.scope, id: String(b.id || '') } : {}) }) })),
+    // GitHub for a workspace (plan §2): its connections, access mode, and its org's Require GitHub.
+    'GET /api/workspaces/:id/github': (b, id) => asAccount(async (token) => workspaceGithub({ token, id: needWorkspaceId(id) })),
+    'POST /api/workspaces/:id/github': (b, id) => asAccount(async (token) => setWorkspaceGithub({ token, id: needWorkspaceId(id), ...('access' in b ? { access: String(b.access || ''), repos: Array.isArray(b.repos) ? b.repos.map(String) : [] } : {}), ...('agentCommits' in b ? { agentCommits: String(b.agentCommits || '') } : {}) })),
+    'POST /api/workspaces/:id/github/disconnect': (b, id) => asAccount(async (token) => removeWorkspaceGithub({ token, id: needWorkspaceId(id), connectedBy: b && b.connectedBy ? String(b.connectedBy) : '' })),
+    'POST /api/orgs/:slug/github': (b, slug) => asAccount(async (token) => setOrgGithub({ token, slug: String(slug || ''), ...(b && 'requireGithub' in b ? { requireGithub: b.requireGithub === true } : {}), ...(b && 'agentCommits' in b ? { agentCommits: String(b.agentCommits || '') } : {}) })),
+    'GET /api/collaborators': () => asAccount(async (token) => ({ collaborators: await listCollaborators({ token }) })),
+    'GET /api/sessions/:id/grants': (b, id) => { const s = owned(id); return asAccount(async (token) => ({ grants: await listGrants({ token, room: s.room }) })) },
+    'POST /api/sessions/:id/members/access': (b, id) => setAccess(id, b),
+    'GET /api/sessions/:id/invites': (b, id) => { const s = owned(id); return asAccount(async (token) => ({ invites: await listSessionInvites({ token, room: s.room }) })) },
+    'POST /api/sessions/:id/invites': (b, id) => invite(id, b),
+    'POST /api/sessions/:id/invites/cancel': (b, id) => {
+      const s = owned(id)
+      if (!b.inviteId) throw httpError(400, 'Which invite?')
+      return asAccount(async (token) => { await cancelSessionInvite({ token, room: s.room, id: String(b.inviteId) }); return { ok: true } })
+    },
+    'GET /api/agents': () => asAccount(async (token) => ({ agents: await listAgents({ token }) })),
+    // `global` (workspaces on): a global agent's invite. Without it, the invite as it always was.
+    'POST /api/agent-invites': (b) => asAccount((token) => createAgentInvite({ token, global: workspacesOn && b?.global === true })),
+    'GET /api/workspaces': () => workspaceList(),
+    'GET /api/orgs': () => asAccount(async (token) => ({ orgs: await listOrgs({ token }) })),
+    'POST /api/workspaces': (b) => asAccount(async (token) => ({ workspace: await createWorkspace({ token, name: String(b.name || ''), description: String(b.description || ''), color: String(b.color || ''), org: b.org ? String(b.org) : undefined }) })),
+    'GET /api/workspaces/:id': (b, id) => asAccount(async (token) => ({ ...(await getWorkspace({ token, id: needWorkspaceId(id) })), ...ofWorkspace(id) })),
+    'POST /api/workspaces/:id/update': (b, id) => asAccount(async (token) => ({ workspace: await updateWorkspace({ token, id: needWorkspaceId(id), patch: { name: b.name, description: b.description, color: b.color, archived: b.archived } }) })),
+    'POST /api/workspaces/:id/delete': (b, id) => asAccount(async (token) => { await deleteWorkspace({ token, id: needWorkspaceId(id) }); return { ok: true } }),
+    'POST /api/workspaces/:id/members': (b, id) => asAccount(async (token) => ({ member: await putWorkspaceMember({ token, id: needWorkspaceId(id), account: String(b.account || ''), access: String(b.access || ''), sessions: b.sessions === undefined ? undefined : String(b.sessions) }) })),
+    // Where agents work: an agent's placement (yours), an org's agents, a workspace's say over
+    // an agent placed there, and a link for a new agent that joins the workspace.
+    'GET /api/agents/:id/placement': (b, id) => asAccount(async (token) => ({ placement: await getAgentPlacement({ token, id: needAgentId(id) }) })),
+    'POST /api/agents/:id/placement': (b, id) => asAccount(async (token) => ({ placement: await putAgentPlacement({ token, id: needAgentId(id), placement: { reach: b.reach, workspaceIds: b.workspaceIds, sessions: b.sessions, access: b.access, scopes: b.scopes } }) })),
+    'GET /api/orgs/:slug/agents': (b, slug) => asAccount(async (token) => ({ agents: await listOrgAgents({ token, slug: needOrgSlug(slug) }) })),
+    'POST /api/workspaces/:id/agents/:aid': (b, id, url, aid) => asAccount(async (token) => ({ override: await putWorkspaceAgent({ token, id: needWorkspaceId(id), agentId: needAgentId(aid), sessions: b.sessions, excluded: b.excluded }) })),
+    'POST /api/workspaces/:id/agents/:aid/remove': (b, id, url, aid) => asAccount(async (token) => { await deleteWorkspaceAgent({ token, id: needWorkspaceId(id), agentId: needAgentId(aid) }); return { ok: true } }),
+    'POST /api/workspaces/:id/agent-invites': (b, id) => asAccount(async (token) => ({ link: (await createWorkspaceAgentInvite({ token, id: needWorkspaceId(id), access: String(b.access || 'edit'), sessions: String(b.sessions || 'invited') })).link })),
+    'POST /api/workspaces/:id/members/remove': (b, id) => asAccount(async (token) => { await removeWorkspaceMember({ token, id: needWorkspaceId(id), account: String(b.account || '') }); return { ok: true } }),
+    // Moves a session (a running one by `session`, or any by its folder, `dir`) into the
+    // workspace. Its people and agents come along when you manage the workspace (`added`).
+    'POST /api/workspaces/:id/sessions/move': (b, id) => asAccount(async (token) => {
+      const live = b.session ? runs.get(String(b.session)) : null
+      if (b.session && !live) throw httpError(404, 'That session is not open.')
+      const dir = live ? live.run.dir : path.resolve(expandHome(String(b.dir || '')))
+      const saved = readConfig(dir)
+      if (!saved) throw httpError(404, 'No session in that folder.')
+      const r = await moveSessionToWorkspace({ token, id: needWorkspaceId(id), room: saved.room })
+      writePrivateJson(path.join(dir, '.quilt', 'config.json'), { ...readConfig(dir), workspace: id })
+      rememberWorkspace(dir, id)
+      if (live) { live.run.session.setWorkspace(id); pushStatus(String(b.session)) }
+      return { ok: true, added: r.added, peopleNeedAdmin: r.peopleNeedAdmin }
+    }),
+    'GET /api/workspaces/:id/invites': (b, id) => asAccount(async (token) => ({ invites: await listWorkspaceInvites({ token, id: needWorkspaceId(id) }) })),
+    'POST /api/workspaces/:id/invites': (b, id) => asAccount(async (token) => {
+      const to = b.to && typeof b.to === 'object' ? (b.to.email !== undefined ? { email: String(b.to.email) } : { account: String(b.to.account || '') }) : {}
+      return { invite: await inviteToWorkspace({ token, id: needWorkspaceId(id), to, access: String(b.access || 'edit') }) }
+    }),
+    'POST /api/workspaces/:id/invites/:iid/cancel': (b, id, url, iid) => asAccount(async (token) => { await cancelWorkspaceInvite({ token, id: needWorkspaceId(id), inviteId: needInviteId(iid) }); return { ok: true } }),
+    // Invites waiting for you (workspaces, and sessions with their link); accept or decline them.
+    'GET /api/invites': () => asAccount(async (token) => ({ invites: await listMyInvites({ token }) })),
+    'POST /api/invites/:id/accept': (b, id) => asAccount(async (token) => answerMyInvite({ token, id: needInviteId(id), how: 'accept' })),
+    'POST /api/invites/:id/decline': (b, id) => asAccount(async (token) => answerMyInvite({ token, id: needInviteId(id), how: 'decline' })),
+    'GET /api/workspaces/:id/files': (b, id, url) => asAccount(async (token) => ({ files: await listWorkspaceFiles({ token, id: needWorkspaceId(id), folder: url.searchParams.get('folder') ?? undefined }) })),
+    'GET /api/workspaces/:id/files/:fid/versions': (b, id, url, fid) => asAccount(async (token) => ({ versions: await listWorkspaceFileVersions({ token, id: needWorkspaceId(id), fileId: fid }) })),
+    'POST /api/workspaces/:id/files/:fid/update': (b, id, url, fid) => asAccount(async (token) => ({ file: await updateWorkspaceFile({ token, id: needWorkspaceId(id), fileId: fid, patch: { path: b.path, note: b.note } }) })),
+    'POST /api/workspaces/:id/files/:fid/delete': (b, id, url, fid) => asAccount(async (token) => { await deleteWorkspaceFile({ token, id: needWorkspaceId(id), fileId: fid }); return { ok: true } }),
+    'POST /api/workspaces/:id/folders': (b, id) => asAccount(async (token) => ({ file: await createWorkspaceFolder({ token, id: needWorkspaceId(id), path: String(b.path || '') }) })),
+    'POST /api/account/start': () => beginLink(),
+    'POST /api/account/cancel': () => { link = null; return accountState() },
+    'POST /api/account/signout': async () => {
+      const account = readAccount()
+      // Forget the sign-in first, so a start can't pick it up again while sessions stop.
+      passes = null
+      link = null
+      clearAccount()
+      for (const id of [...runs.keys()]) await stop(id)
+      await signOut({ token: account?.token })
+      signedOutReason = null
+      return { ok: true }
+    },
+    'GET /api/state': () => ({
+      sessions: [...runs.keys()].map(summary),
+      recent: recentList(),
+      defaults: { home: os.homedir(), cwd: process.cwd(), tools: TOOL_NAMES, editors: installedEditors(), relay: relayUrl() },
+      profile: profile(),
+      maxFileBytes: MAX_SHARED_FILE_BYTES,
+      workspacesOn
+    }),
+    'POST /api/sessions': (b) => start(b),
+    'POST /api/sessions/:id/open-in': async (b, id) => { await openIn(String(b.app || ''), get(id).root); return { ok: true } },
+    'GET /api/sessions/:id/merges': (b, id) => ({ merges: get(id).mergeList() }),
+    // Gathering the project's AI rules into AGENTS.md (project-rules.js): look first, then apply what was shown.
+    'GET /api/sessions/:id/rules/gather': (b, id) => get(id).rulesGatherPlan(),
+    'POST /api/sessions/:id/rules/gather': (b, id) => get(id).applyRulesGather(String(b.key || '')),
+    'POST /api/sessions/:id/merges/resolve': async (b, id) => { const r = await get(id).settleMerge(String(b.id || ''), { how: b.how }); pushStatus(id); return r },
+    'POST /api/sessions/:id/merges/send': async (b, id) => {
+      const s = get(id)
+      const mergeId = String(b.id || '')
+      const { prompt } = await s.sendMerge(mergeId)
+      pushStatus(id)
+      const app = String(b.app || '')
+      // Your AI, working on its own (autowork.js): the run says how it went in chat.
+      if (app === 'auto') {
+        const rec = s.mergeList().find((m) => m.id === mergeId)
+        return { ...autowork().sendMerge(s, { id: mergeId, path: rec ? rec.path : '', prompt }), app }
+      }
+      const { copied, filled } = await openIn(app, s.root, { prompt })
+      return { copied, filled: !!filled, app }
+    },
+    'POST /api/sessions/:id/stop': (b, id) => stop(id).then(() => ({ ok: true })),
+    'POST /api/sessions/:id/say': (b, id) => get(id).say(b.text, { to: b.to || null }),
+    'POST /api/sessions/:id/focus': (b, id) => { get(id).setFocus(b.text); return { ok: true } },
+    // The composer says while someone types (and stops when they clear it or send).
+    'POST /api/sessions/:id/typing': (b, id) => get(id).setTyping(b.on !== false, { to: b.to || null }),
+    'POST /api/sessions/:id/claim': (b, id) => get(id).claim(b.pattern, b.note),
+    'POST /api/sessions/:id/release': async (b, id) => ({ released: await get(id).release(b.pattern) }),
+    'POST /api/sessions/:id/clear-claims': async (b, id) => ({ released: await get(id).clearInactiveClaims() }),
+    'POST /api/sessions/:id/request-file': (b, id) => get(id).requestFile(b.path, { title: b.title, description: b.description }),
+    // Boxes (boxes.js): each one's change, for the people panel; and opening your own early (quilt_unpack).
+    'GET /api/sessions/:id/boxes': (b, id) => get(id).boxes(),
+    'POST /api/sessions/:id/unpack': async (b, id) => { const r = await get(id).unpack(Array.isArray(b.paths) ? b.paths : [b.path]); pushStatus(id); return r },
+    'POST /api/sessions/:id/withdraw-request': async (b, id) => ({ withdrawn: await get(id).withdrawRequest(b.request) }),
+    'POST /api/sessions/:id/handoff': (b, id) => get(id).handoff(b.path, { to: b.to, context: b.context }),
+    'POST /api/sessions/:id/attach-from-workspace': async (b, id) => {
+      const s = get(id)
+      const workspace = (readConfig(s.root) || {}).workspace
+      if (!workspace) throw httpError(400, 'This session is not in a workspace.')
+      const info = await asAccount((token) => workspaceFileDownload({ token, id: workspace, fileId: String(b.fileId || '') }))
+      if (info.size > MAX_SHARED_FILE_BYTES) throw httpError(413, 'That file is too big to send in chat (100 MB at most).')
+      const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'quilt-wsattach-'))
+      try {
+        const file = path.join(dir, path.basename(info.name) || 'file')
+        const r = await fetch(info.url)
+        if (!r.ok) throw httpError(502, `The file could not be fetched (${r.status}).`)
+        // pipeline, not .pipe: a download that breaks off rejects here instead of crashing the app.
+        await pipeline(Readable.fromWeb(r.body), fs.createWriteStream(file)).catch((err) => { throw httpError(502, `The file could not be fetched (${err.message}).`) })
+        return await s.sendFile(file, { to: b.to || null, text: String(b.text || '') })
+      } finally { fs.rmSync(dir, { recursive: true, force: true }) }
+    },
+    'POST /api/sessions/:id/read': (b, id) => { get(id).messages({ limit: 500 }); pushStatus(id); return { ok: true } },
+    'GET /api/sessions/:id/messages': (b, id) => ({ messages: get(id).messages({ limit: 200, markRead: false }) }),
+    'GET /api/sessions/:id/tasks': (b, id) => ({ tasks: get(id).taskList() }),
+    'POST /api/sessions/:id/tasks': (b, id) => ({ task: get(id).addTask(b), tasks: get(id).taskList() }),
+    'POST /api/sessions/:id/tasks/update': async (b, id) => {
+      const s = get(id)
+      const before = s.taskList().find((t) => t.id === b.id) || null
+      // Done merges the task's pull request first (relay-commit.js): refused with the reason when it can't be.
+      const finished = b.column === 'done' && before && before.column !== 'done' ? await s.finishTask(b.id) : null
+      return { task: s.updateTask(b), tasks: s.taskList(), ...(finished && finished.merged ? { merged: finished.merged } : {}) }
+    },
+    'POST /api/sessions/:id/tasks/delete': (b, id) => { get(id).deleteTask(b.id); return { tasks: get(id).taskList() } },
+    'POST /api/sessions/:id/tasks/comment': (b, id) => ({ ...get(id).commentTask(b), tasks: get(id).taskList() }),
+    'GET /api/sessions/:id/feed': (b, id, url) => {
+      const s = get(id)
+      return { entries: s.agentFeedFor(url.searchParams.get('who') || s.name) }
+    },
+    'GET /api/sessions/:id/tree': (b, id) => get(id).tree(),
+    'GET /api/sessions/:id/changes': (b, id) => get(id).changes(),
+    'POST /api/sessions/:id/catch-up/dismiss': (b, id) => { const r = get(id).dismissCatchUp(); pushStatus(id); return r },
+    // One file's changes, newest first, each with its diff (the Changes panel's "What changed").
+    'GET /api/sessions/:id/history': (b, id, url) => {
+      const file = String(url.searchParams.get('path') || '')
+      const entries = get(id).history.entries().filter((e) => e.path === file)
+      return { entries: queryHistory(entries, { limit: 100 }).reverse() }
+    },
+    // Commits pushed or merged elsewhere: fetch and bring them in now (they also come in by themselves).
+    'POST /api/sessions/:id/branches/sync': async (b, id) => { const r = await get(id).syncBranchNow(); pushStatus(id); return r },
+    'GET /api/sessions/:id/file': (b, id, url) => {
+      const f = get(id).readShared(url.searchParams.get('path'))
+      if (!f) throw httpError(404, 'That file is not in this session.')
+      return f
+    },
+    'POST /api/sessions/:id/members/approve': async (b, id) => {
+      if (b.typeId) return approveAs(id, b) // access types: owner only (their types / grants)
+      await admitter(id).approve(b.key, { role: b.role, scopes: b.scopes })
+      return { ok: true }
+    },
+    'POST /api/sessions/:id/members/deny': async (b, id) => (await admitter(id).deny(b.key), { ok: true }),
+    'POST /api/sessions/:id/admit-by': async (b, id) => (await owned(id).setAdmitBy(b.admitBy), { ok: true, admitBy: b.admitBy }),
+    // Owner only: the read-only GitHub token the relay brings commits in with while everyone's offline ('' clears it).
+    'POST /api/sessions/:id/github-token': (b, id) => owned(id).setGithubToken(b.token),
+    'POST /api/sessions/:id/members/set': async (b, id) => (await get(id).setMember(b.key, { role: b.role, scopes: b.scopes }), { ok: true }),
+    'POST /api/sessions/:id/members/remove': (b, id) => removeMember(id, b.key),
+    // Owner only: a link a chat-only AI (ChatGPT, claude.ai, Grok…) works through (chat-links.js).
+    'POST /api/sessions/:id/chat-link': (b, id) => get(id).createChatLink({ name: b.name || 'Chat AI', minutes: b.minutes }),
+    'POST /api/sessions/:id/chat-link/extend': (b, id) => get(id).extendChatLink(String(b.key || ''), b.minutes),
+    // Agents kept out of this session (removing one in a workspace does it), and letting one back in.
+    'GET /api/sessions/:id/agents/excluded': (b, id) => { const s = owned(id); return asAccount(async (token) => ({ agents: await listExcludedSessionAgents({ token, room: s.room }) })) },
+    // The session's People (workspaces on): the agents its workspace invites, Don't invite (a
+    // keep-out) and Invite again, which also hands that agent the session's link now.
+    'GET /api/sessions/:id/agents': (b, id) => { const s = owned(id); return asAccount(async (token) => ({ agents: await listSessionAgents({ token, room: s.room }) })) },
+    'POST /api/sessions/:id/agents/exclude': (b, id) => { const s = owned(id); return asAccount(async (token) => { await excludeSessionAgent({ token, room: s.room, agentId: needAgentId(b.agentId) }); return { ok: true } }) },
+    'POST /api/sessions/:id/agents/include': (b, id) => inviteAgentAgain(id, needAgentId(b.agentId)),
+    'POST /api/sessions/:id/rename': (b, id) => rename(id, b.name),
+    'POST /api/sessions/:id/end': async (b, id) => { const room = get(id).room; await get(id).endForEveryone(); await stop(id); unfollowWithCloudAi(room); return { ok: true } },
+    'POST /api/sessions/:id/summarize': (b, id) => {
+      const r = runs.get(id)
+      if (!r) throw httpError(404, 'That session is not running.')
+      return { on: r.run.session.setSummarize(b.on ? r.run.summarizer() : null) }
+    },
+    'POST /api/sessions/:id/sharing': (b, id) => ({ on: get(id).setAgentSharing(b.on !== false) }),
+    'POST /api/recent/forget': (b) => {
+      const dir = path.resolve(expandHome(String(b.dir || '')))
+      const room = readConfig(dir)?.room
+      forgetRecent(dir)
+      // Left for good: the person's cloud AI leaves it too.
+      unfollowWithCloudAi(room)
+      return { recent: recentList() }
+    },
+    // Release notes and the update check. The newest local notes are "unseen" until the app shows them.
+    'GET /api/version': async () => {
+      const version = currentVersion()
+      const latest = await latestRelease()
+      return {
+        version,
+        releases: localReleases(),
+        unseen: compareVersions(seenVersion(), version) < 0,
+        latest,
+        outOfDate: !!latest && compareVersions(latest.version, version) > 0,
+        barHidden: !!latest && hiddenUpdate() === latest.version, // "Don't show this again" for this release
+        downloadUrl: downloadUrl()
+      }
+    },
+    'POST /api/version/seen': () => { markSeen(currentVersion()); return { ok: true } },
+    'POST /api/version/hide-bar': (b) => {
+      try { hideUpdate(b.version) } catch (err) { throw httpError(400, err.message) }
+      return { ok: true }
+    },
+    'GET /api/settings': () => profile(),
+    // Work on its own: today's runs and tokens; carrying a run's chat on in your tool.
+    'GET /api/autowork': () => autowork().usage(),
+    'POST /api/autowork/take-over': async (b) => {
+      const how = autowork().takeOver(String(b.run || ''))
+      if (!how) throw httpError(404, 'That run has no chat to carry on.')
+      if (how.link) {
+        await new Promise((resolve, reject) => execFile(process.platform === 'win32' ? 'cmd' : 'open', process.platform === 'win32' ? ['/c', 'start', '""', how.link] : [how.link], (err) => err ? reject(err) : resolve()))
+        return { opened: true }
+      }
+      return { copied: await copyToClipboard(how.command), command: how.command }
+    },
+    'POST /api/settings': (b) => updateProfile(b),
+    'POST /api/report': (b) => {
+      reporter.record({ kind: 'error', name: String(b.name || 'renderer').slice(0, 80), outcome: 'error', message: String(b.message || '').slice(0, 500), context: typeof b.context === 'object' && b.context ? b.context : {} })
+      return { ok: true }
+    },
+    'GET /api/github/status': () => gitops.ghStatus(),
+    'GET /api/github/repos': async (b, id, url) => ({ repos: await gitops.listRepos({ limit: url.searchParams.get('limit') || 100 }) }),
+    'GET /api/github/branches': (b, id, url) => gitops.listBranches(url.searchParams.get('repo')),
+    'POST /api/sessions/:id/commit-request': (b, id) => { const r = get(id).requestCommit(b.message, { files: Array.isArray(b.files) ? b.files : null, task: b.task || null, by: b.by ? String(b.by).slice(0, 80) : null }); pushStatus(id); return r },
+    // Commits a request in this folder (commit.js), and what is not committed here yet, by who made it.
+    'POST /api/sessions/:id/commit-session': async (b, id) => { try { return await get(id).commitSessionWork(String(b.message || '')) } finally { pushStatus(id) } },
+    'POST /api/sessions/:id/commit-request/commit': async (b, id) => { try { return await get(id).commitRequest(String(b.id || '')) } finally { pushStatus(id) } },
+    'POST /api/sessions/:id/agent-commits': async (b, id) => { try { return await get(id).setAgentCommits(b.mode) } finally { pushStatus(id) } },
+    'POST /api/sessions/:id/github-sync': async (b, id) => { try { return await get(id).setGithubSync(b.on !== false) } finally { pushStatus(id) } },
+    'POST /api/sessions/:id/large-to-relay': async (b, id) => { try { return await get(id).setLargeToRelay(b.on === true) } finally { pushStatus(id) } },
+    'POST /api/sessions/:id/github/recheck': async (b, id) => { try { return { github: await get(id).githubRecheck() } } finally { pushStatus(id) } },
+    'GET /api/sessions/:id/uncommitted': (b, id) => get(id).uncommittedWork(),
+    'POST /api/sessions/:id/commit-request/done': (b, id) => { const done = get(id).resolveCommitRequests({ ids: b.id ? [String(b.id)] : null }); pushStatus(id); return { done } },
+    'GET /api/fs': (b, id, url) => listDir(url.searchParams.get('path') || os.homedir()),
+    // Reply first, then shut down, so the page hears back before we exit.
+    'POST /api/shutdown': () => {
+      if (!onShutdown) throw httpError(501, 'Shut down is not available here.')
+      setTimeout(onShutdown, 100)
+      return { ok: true }
+    }
+  }
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, 'http://x')
+    const json = (code, body) => { res.writeHead(code, { 'content-type': 'application/json' }); res.end(JSON.stringify(body)) }
+
+    // DNS-rebinding guard: only answer requests addressed to localhost.
+    const host = (req.headers.host || '').replace(/:\d+$/, '')
+    if (!['127.0.0.1', 'localhost', '[::1]'].includes(host)) return json(403, { error: 'forbidden host' })
+
+    if (preview && req.method === 'GET' && url.pathname === '/' && !url.searchParams.get('t')) {
+      res.writeHead(302, { location: `/?t=${token}`, 'cache-control': 'no-store' })
+      return res.end()
+    }
+    if (req.method === 'GET' && STATIC[url.pathname]) {
+      const [file, type] = STATIC[url.pathname]
+      const headers = { 'content-type': type, 'cache-control': 'no-store' }
+      if (url.pathname === '/') headers['content-security-policy'] = CSP
+      res.writeHead(200, headers)
+      const body = fs.readFileSync(path.join(UI_DIR, file))
+      // The theme goes on <html> before anything paints, so dark mode never flashes light.
+      if (url.pathname === '/') return res.end(String(body).replace('<html lang="en">', `<html lang="en" data-theme="${profile().theme}">`))
+      return res.end(body)
+    }
+    const font = req.method === 'GET' && url.pathname.match(/^\/fonts\/([a-z-]+)\/([^/]+)$/)
+    if (font) {
+      const f = fontFile(font[1], font[2])
+      if (!f) return json(404, { error: 'not found' })
+      res.writeHead(200, { 'content-type': 'font/woff2', 'cache-control': 'max-age=31536000, immutable' })
+      return res.end(fs.readFileSync(f))
+    }
+    if (req.method === 'GET' && (url.pathname === '/logo.svg' || url.pathname === '/favicon.svg')) {
+      res.writeHead(200, { 'content-type': 'image/svg+xml' })
+      return res.end(fs.readFileSync(LOGO))
+    }
+
+    const supplied = req.headers['x-quilt-token'] || url.searchParams.get('t')
+    if (supplied !== token) return json(401, { error: 'Open quilt from the link printed by `quilt ui`.' })
+
+    try {
+      if (!OPEN_ROUTES.has(`${req.method} ${url.pathname}`) && !readAccount()) return json(401, { error: 'Sign in to Quilt first.', signedOut: true })
+      if (req.method === 'GET' && url.pathname === '/api/events') return events(req, res)
+
+      let m = url.pathname.match(/^\/api\/sessions\/([a-f0-9]+)\/send$/)
+      if (req.method === 'POST' && m) return json(200, await receiveUpload(req, get(m[1])))
+      m = url.pathname.match(/^\/api\/sessions\/([a-f0-9]+)\/files\/([a-f0-9]+)$/)
+      if (req.method === 'GET' && m) return await serveFile(res, get(m[1]), m[2])
+      const wu = url.pathname.match(/^\/api\/workspaces\/([^/]+)\/upload$/)
+      if (req.method === 'PUT' && wu) return json(200, await receiveWorkspaceUpload(req, wu[1]))
+      const wd = url.pathname.match(/^\/api\/workspaces\/([^/]+)\/files\/([^/]+)\/data$/)
+      if (req.method === 'GET' && wd) return await streamWorkspaceFile(req, res, wd[1], wd[2])
+
+      let pathKey = url.pathname
+        .replace(/^\/api\/sessions\/[a-f0-9]+/, '/api/sessions/:id')
+        .replace(/^\/api\/workspaces\/[^/]+/, '/api/workspaces/:id')
+        .replace(/^\/api\/agents\/[^/]+\//, '/api/agents/:id/')
+        .replace(/^\/api\/orgs\/[^/]+\//, '/api/orgs/:slug/')
+        .replace(/^\/api\/invites\/[^/]+\//, '/api/invites/:id/')
+      const sid = (url.pathname.match(/^\/api\/sessions\/([a-f0-9]+)/) || url.pathname.match(/^\/api\/workspaces\/([^/]+)/) || url.pathname.match(/^\/api\/(?:agents|orgs|invites)\/([^/]+)\//) || [])[1]
+      const fid = (url.pathname.match(/^\/api\/workspaces\/[^/]+\/files\/([^/]+)/) || [])[1]
+      if (fid) pathKey = pathKey.replace(/\/files\/[^/]+/, '/files/:fid')
+      // A workspace's agent (its override): passed where a file id would be.
+      const aid = (url.pathname.match(/^\/api\/workspaces\/[^/]+\/agents\/([^/]+)/) || [])[1]
+      if (aid) pathKey = pathKey.replace(/^(\/api\/workspaces\/:id\/agents)\/[^/]+/, '$1/:aid')
+      // A workspace's invite, the same way.
+      const iid = (url.pathname.match(/^\/api\/workspaces\/[^/]+\/invites\/([^/]+)\//) || [])[1]
+      if (iid) pathKey = pathKey.replace(/^(\/api\/workspaces\/:id\/invites)\/[^/]+/, '$1/:iid')
+      const key = `${req.method} ${pathKey}`
+      const handler = api[key]
+      if (!handler) {
+        reporter.record({ kind: 'http404', name: key.slice(0, 80), outcome: 'error', status: 404 })
+        return json(404, { error: 'not found' })
+      }
+      let raw = ''
+      for await (const chunk of req) raw += chunk
+      const body = raw ? JSON.parse(raw) : {}
+      const startedAt = Date.now()
+      try {
+        const out = await handler(body, sid, url, fid || aid || iid)
+        json(200, out)
+        return recordRoute(key, { startedAt, status: 200, body })
+      } catch (err) {
+        recordRoute(key, { startedAt, status: err.status || 400, body, error: err })
+        throw err
+      }
+    } catch (err) {
+      return json(err.status || 400, { error: err.message, ...(err.signedOut ? { signedOut: true } : {}) })
+    }
+  })
+
+  function events (req, res) {
+    res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' })
+    res.write(': hi\n\n')
+    clients.add(res)
+    const ping = setInterval(() => res.write(': ping\n\n'), 15000)
+    req.on('close', () => { clearInterval(ping); clients.delete(res) })
+  }
+
+  /** A write stream to a temp file whose failures (disk full, permissions) reject the
+   * write or end that meets them, rather than going unhandled and crashing the app. */
+  function tempWriter (file) {
+    const out = fs.createWriteStream(file)
+    let failed = null
+    out.on('error', (err) => { failed = failed || err })
+    const check = () => { if (failed) throw failed }
+    return {
+      async write (chunk) {
+        check()
+        if (!out.write(chunk)) {
+          // Wait for drain, or for the stream to close on an error; whichever fires, drop the other.
+          await new Promise((resolve) => {
+            const done = () => { out.off('drain', done); out.off('close', done); resolve() }
+            out.once('drain', done); out.once('close', done)
+          })
+        }
+        check()
+      },
+      async end () {
+        check()
+        await new Promise((resolve, reject) => out.end((err) => (err || failed ? reject(err || failed) : resolve())))
+      },
+      destroy () { out.destroy() }
+    }
+  }
+
+  async function receiveUpload (req, session) {
+    const name = path.basename(decodeURIComponent(req.headers['x-filename'] || 'file')) || 'file'
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'quilt-up-'))
+    const file = path.join(dir, name)
+    try {
+      let size = 0
+      const out = tempWriter(file)
+      for await (const chunk of req) {
+        size += chunk.length
+        if (size > MAX_SHARED_FILE_BYTES) { out.destroy(); throw httpError(413, 'File is too large.') }
+        await out.write(chunk)
+      }
+      await out.end()
+      const to = req.headers['x-to'] ? decodeURIComponent(req.headers['x-to']) : null
+      const text = req.headers['x-text'] ? decodeURIComponent(req.headers['x-text']) : ''
+      return await session.sendFile(file, { to, text })
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true })
+    }
+  }
+
+  async function serveFile (res, session, msgId) {
+    const msg = session.messages({ limit: 500, markRead: false }).find((m) => m.id === msgId)
+    if (!msg || !msg.file) throw httpError(404, 'No such file.')
+    const local = msg.file.localPath ? path.join(session.root, msg.file.localPath) : await session.fetchFile(msgId)
+    res.writeHead(200, {
+      'content-type': 'application/octet-stream',
+      'content-disposition': `attachment; filename="${msg.file.name.replace(/[^\w.\- ]/g, '_')}"`
+    })
+    fs.createReadStream(local).pipe(res)
+  }
+
+  // A workspace upload from the page: the bytes go to a temp file, the API hands out a signed
+  // link, Node streams the file there, and the API confirms it. The page never talks to storage.
+  async function receiveWorkspaceUpload (req, id) {
+    const account = readAccount()
+    if (!account) throw Object.assign(httpError(401, 'Sign in to Quilt first.'), { signedOut: true })
+    if (Number(req.headers['content-length']) > MAX_WS_FILE_BYTES) throw httpError(413, 'File is too large (500 MB at most).')
+    const filePath = decodeURIComponent(req.headers['x-path'] || '')
+    const note = req.headers['x-note'] ? decodeURIComponent(req.headers['x-note']) : ''
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'quilt-wsup-'))
+    const tmp = path.join(dir, 'upload')
+    try {
+      const hash = crypto.createHash('sha256')
+      let size = 0
+      const out = tempWriter(tmp)
+      for await (const chunk of req) {
+        size += chunk.length
+        if (size > MAX_WS_FILE_BYTES) { out.destroy(); throw httpError(413, 'File is too large (500 MB at most).') }
+        hash.update(chunk)
+        await out.write(chunk)
+      }
+      await out.end()
+      if (!size) throw httpError(400, 'The file is empty.')
+      const mime = String(req.headers['content-type'] || '').split(';')[0] || ''
+      return await asAccount(async (token) => {
+        const { file, upload } = await createWorkspaceFile({ token, id: needWorkspaceId(id), path: filePath, size, mime: mime === 'application/octet-stream' ? '' : mime, sha256: hash.digest('hex'), note })
+        const put = await fetch(upload.url, { method: upload.method, headers: { 'content-type': file.mime || 'application/octet-stream', 'content-length': String(size), ...(upload.headers || {}) }, body: fs.createReadStream(tmp), duplex: 'half' })
+        if (!put.ok) throw httpError(502, `The file could not be stored (${put.status}).`)
+        return { file: await confirmWorkspaceFile({ token, id, fileId: file.id }) }
+      })
+    } finally { fs.rmSync(dir, { recursive: true, force: true }) }
+  }
+
+  /** Streams a workspace file to the page, so previews stay same-origin. */
+  async function streamWorkspaceFile (req, res, id, fileId) {
+    const url = new URL(req.url, 'http://x')
+    const info = await asAccount((token) => workspaceFileDownload({ token, id: needWorkspaceId(id), fileId, version: url.searchParams.get('version') || undefined }))
+    const r = await fetch(info.url)
+    if (!r.ok) { res.writeHead(502, { 'content-type': 'application/json' }); return res.end(JSON.stringify({ error: `The file could not be fetched (${r.status}).` })) }
+    const disposition = url.searchParams.get('download') ? 'attachment' : 'inline'
+    const type = info.mime || 'application/octet-stream'
+    // A stored HTML or SVG opened directly must not run on the app's origin (its URL carries
+    // the token): no sniffing, and a sandbox for every type but PDF, which Chromium won't
+    // render sandboxed. <img>, <video> and <audio> ignore the header.
+    const guard = { 'x-content-type-options': 'nosniff', ...(type.split(';')[0].trim().toLowerCase() === 'application/pdf' ? {} : { 'content-security-policy': 'sandbox' }) }
+    res.writeHead(200, { ...guard, 'content-type': type, ...(info.size ? { 'content-length': String(info.size) } : {}), 'content-disposition': contentDisposition(disposition, info.name), 'cache-control': 'private, max-age=60' })
+    // The headers are out, so a download that breaks off can only cut the response short
+    // (the page sees a failed load); pipeline makes sure that is all it does.
+    await pipeline(Readable.fromWeb(r.body), res).catch(() => res.destroy())
+  }
+
+  const listen = (p) => new Promise((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(p, '127.0.0.1', () => { server.off('error', reject); resolve() })
+  })
+  try { await listen(port) } catch (err) {
+    if (err.code !== 'EADDRINUSE') throw err
+    await listen(0)
+  }
+  const actualPort = server.address().port
+
+  return {
+    url: `http://127.0.0.1:${actualPort}/?t=${token}`,
+    port: actualPort,
+    token,
+    report: (event) => reporter.record(event),
+    flushReports: () => reporter.flush(),
+    close: async () => {
+      link = null
+      for (const id of [...runs.keys()]) await stop(id)
+      for (const res of clients) res.end()
+      await reporter.close()
+      await new Promise((r) => server.close(r))
+    }
+  }
+}
+
+function listDir (p) {
+  const dir = path.resolve(expandHome(p))
+  const entries = fs.readdirSync(dir, { withFileTypes: true })
+  const dirs = entries
+    .filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
+    .map((e) => e.name)
+    .sort((a, b) => a.localeCompare(b))
+  return {
+    path: dir,
+    parent: path.dirname(dir) !== dir ? path.dirname(dir) : null,
+    dirs,
+    hasSession: fs.existsSync(path.join(migrateDir(dir), 'config.json')),
+    isEmpty: entries.filter((e) => e.name !== '.DS_Store').length === 0
+  }
+}
+
+/** The AI coding tool this person most likely uses, from what it has left in their home folder. */
+function detectTool () {
+  const home = os.homedir()
+  // Prefer real usage markers. ~/.claude alone is not enough: Quilt's hooks write
+  // settings there for every session, which made Cursor / xAI / Grok users look like
+  // Claude Code. Transcripts live under .claude/projects.
+  const found = [['.claude/projects', 'Claude Code'], ['.cursor', 'Cursor'], ['.codex', 'Codex'], ['.codeium/windsurf', 'Windsurf']]
+    .map(([dir, tool]) => {
+      try { return { tool, used: fs.statSync(path.join(home, dir)).mtimeMs } } catch { return null }
+    })
+    .filter(Boolean)
+    .sort((a, b) => b.used - a.used)
+  return found[0]?.tool || 'Claude Code'
+}
+
+function expandHome (p) {
+  return p.startsWith('~') ? path.join(os.homedir(), p.slice(1)) : p
+}
+
+/**
+ * The folder for `name` (a room or repo name) inside the join folder. Invites only carry plain
+ * room names, but a name that would land anywhere else (`..`, a path) is refused all the same.
+ */
+export function underJoinDir (joinDir, name, message = INVALID_INVITE) {
+  const root = path.resolve(expandHome(joinDir))
+  const dir = path.resolve(root, String(name))
+  if (path.dirname(dir) !== root) throw httpError(400, message)
+  return dir
+}
+
+function httpError (status, message) {
+  return Object.assign(new Error(message), { status })
+}