heyquilt 0.3.138 → 0.3.140

package/src/ui/session.js

@@ -2,7 +2,7 @@
 // AI conversations at once), one person's AI chat, a shared file or the task board;
 // the team chat on the right.
 import { mountSecrets } from './secrets.js'
-import { TOKEN, I, state, $, esc, basename, bytes, clock, ago, avatar, colorFor, toast, api, ask, remember, recall, AGENT_COMMIT_WORDS, toolsOf, busyPeople, NO_POSTING, ACCOUNT_KEY, loadAccessTypes, typeOptions, accessLine, loadingHtml, loadingNote } from './common.js'
+import { TOKEN, I, state, $, esc, basename, bytes, clock, ago, avatar, colorFor, toast, api, ask, remember, recall, toolsOf, NO_POSTING, ACCOUNT_KEY, loadAccessTypes, typeOptions, accessLine, loadingHtml, loadingNote } from './common.js'
 import { openInvite, renderTabs, markRead, go } from './app.js'
 import { renderFeed } from './feed.js'
 import { renderLoom, resetLoom, focusFile, showsLoom } from './loom.js'
@@ -16,10 +16,9 @@ import { renderFileView, renderFileTabs } from './fileview.js'
 import { rolledOff, diffLines } from './diffview.js'
 import { searchMarkup, searchTabMarkup, liveByPerson, fileReadsNeeded, SEARCH_ICON } from './quiltview.js'
 import { changesMarkup, bindChanges, unbindChanges, changesChanged, fileChanges, loadChanges, changedCount, unseenChanges, markChangesSeen } from './changes.js'
-import { chipCounts } from './changes-seen.js'
 import { quiltMark } from './mark.js'
 import { openSettings } from './home.js'
-import { fileCardHref, renderable, textHtml, mentionAt, mentionCandidates, completeMention, ALL_AGENTS, RELAY_NAME, isRelay, relayPrompts, typingNames, typingHtml, TYPING_MS, foldPersonas, aiOwners, aiName, shownName, ownAiChatter, authorOf } from './chat.js'
+import { fileCardHref, renderable, textHtml, mentionAt, mentionCandidates, completeMention, ALL_AGENTS, RELAY_NAME, isRelay, relayPrompts, typingNames, typingHtml, TYPING_MS, foldPersonas, aiOwners, aiName, shownName, ownAiChatter } from './chat.js'
 import { toolLogo } from './tool-logo.js'
 import { renderBoard, taskNotesModalHtml, openTaskMenu, foldPlan, matchesSearch } from './board.js'
 import { accessFormValues, accessSaveBody, grantsLoading, grantsLoaded, grantsFailed } from './access-form.js'
@@ -27,14 +26,11 @@ import { workspaceFilePicker } from './files.js'
 import { sessionAgentsHtml } from './agent-place.js'
 import { renderCatchUp, bindCatchUp } from './catchup.js'
 import { boxSummary, boxesOf, unplaced, boxesSig, boxListHtml, boxFoldHtml } from './boxes.js'
-import { gitControl, gitStatusParts, gitSegHtml } from './git-rule.js'
 import { inSeam, makeQuiltWords, seamChip, squareCard, squarePanelHtml, seamSettingsHtml, openSquareButton, squaresSideHtml, SEAM_SIDE_HINT } from './seam-model.js'
 import { callButtonMarkup, callPinMarkup, screenStageMarkup, mountCall, unmountCall, renderCall, callCards } from './voice.js'
 
 let current = null // session id being shown
 let timers = []
-let holdNoteTimer = null // shows the "git is busy" note once a hold has lasted HOLD_NOTE_MS
-const HOLD_NOTE_MS = 1000 // a `git add` holds for a moment: no note flashing by for it
 let grantLoad = grantsLoading() // this session's grants (the owner's view, from the API), for the Access sections
 let wsAgents = { id: null, agents: [] } // the agents this session's workspace invites (workspaces on), for its People
 let mounted = null // AbortController for document-level listeners of this mount
@@ -135,7 +131,6 @@ export function mountSession (id) {
           <button class="pop-item" role="menuitem" id="move-ws-btn" hidden>Move to a workspace…</button>
           <button class="pop-item" role="menuitem" data-session-settings>Session settings…</button>
           <button class="pop-item" role="menuitem" data-gather-rules>One set of AI rules…</button>
-          <button class="pop-item" role="menuitem" id="ask-commit">Ask for a commit…</button>
           <div class="pop-sep"></div>
           <button class="pop-item" role="menuitem" id="leave-btn">Leave this session</button>
         </div>
@@ -188,7 +183,6 @@ export function mountSession (id) {
       <main class="ws-main">
         <div class="requests catchup" id="catchup" role="region" aria-label="While you were away" hidden></div>
         <div class="requests square" id="square-card" role="status" aria-label="Seam" hidden></div>
-        <div class="requests github" id="github-card" role="region" aria-label="GitHub" hidden></div>
         <div class="requests" id="requests" hidden></div>
         <div class="ws-mainbar" id="mainbar" hidden>
           <div class="ws-tabs" id="main-tabs" role="tablist"></div>
@@ -229,11 +223,9 @@ export function mountSession (id) {
   }, () => renderMessages())
   bindAccess()
   bindChanges(id, mounted.signal, { onOpen: (path) => openFile(path, { tab: 'changes' }), close: () => setGitOpen(false), onCount: renderGitChip })
-  loadMine(true)
   bindCatchUp($('#catchup'), { sessionId: () => current, onOpen: openFile })
   // Report a bug / Suggest a feature at the bottom of the Boxes pane (feedback.js): onto this session's board.
   bindFeedback($('.ws-boxes'), { session: () => current, where: () => state.sessions.get(current)?.status?.sessionName || 'a session' })
-  bindGithubCard()
   bindSquareCard()
   bindMain()
   bindTreeEvents()
@@ -272,7 +264,6 @@ export function sessionUnmount () {
   unmountCall()
   for (const t of timers) clearInterval(t)
   timers = []
-  clearTimeout(holdNoteTimer)
   if (mounted) mounted.abort()
   mounted = null
   closeTreeMenu()
@@ -298,7 +289,6 @@ export function sessionUpdated (id) {
   if (ws(id).mode === 'tasks') paintBoard()
   scheduleTree()
   changesChanged()
-  loadMine()
 }
 
 export function sessionMessage (id) {
@@ -335,7 +325,6 @@ export function sessionFileChanged (id, { path }) {
   if (id !== current) return
   scheduleTree()
   changesChanged()
-  loadMine()
   const w = ws(id)
   if (w.fileTabs.includes(path)) {
     if (w.mode === 'files' && w.fileSel === path) { refreshFile(path, true); scheduleHistory(path) } else { w.stale[path] = true; histories.delete(fileKey(path)); renderMainBar() }
@@ -418,7 +407,6 @@ function bindTop () {
   }
   $('#invite-btn').onclick = () => openInvite(current)
   bindOpenIn()
-  $('#ask-commit').onclick = askForCommit
   $('#rename-btn').onclick = renameSession
   $('#move-ws-btn').onclick = moveToWorkspace
   bindCommitChip()
@@ -495,8 +483,7 @@ function bindTop () {
 
 /** The Session settings window's controls: your AI chat's sharing, and (for the owner) who can get in and what they may do. */
 function bindSessionSettings (root) {
-  root.addEventListener('change', (e) => { if (e.target.matches('[data-github-sync], [data-large-to-relay]')) gitSettingChange(e) })
-  root.addEventListener('click', (e) => { if (e.target.closest('[data-gh-connect]')) connectGithub(); else if (e.target.closest('[data-make-quilt]')) makeQuilt(e.target.closest('[data-make-quilt]')); else if (e.target.closest('[data-agent-commits]')) gitSettingChange(e) })
+  root.addEventListener('click', (e) => { const b = e.target.closest('[data-make-quilt]'); if (b) makeQuilt(b) })
   root.addEventListener('change', async (e) => {
     if (e.target.matches('[data-share]')) {
       const on = e.target.checked
@@ -571,11 +558,6 @@ function bindSessionSettings (root) {
     loadSessionAgents()
   })
   root.addEventListener('click', async (e) => {
-    if (e.target.closest('[data-gh-clear]')) {
-      try { await api('POST', `/api/sessions/${current}/github-token`, { token: '' }); toast('The relay no longer has a GitHub token') } catch (err) { toast(err.message) }
-      refreshPeople({ force: true })
-      return
-    }
     if (e.target.closest('[data-end-session]')) {
       if (!await ask({ title: 'End this session for everyone?', message: 'Everyone is disconnected, and the session and its stored files are deleted from the relay. Your own folder is not touched.', ok: 'End session', danger: true })) return
       try { await api('POST', `/api/sessions/${current}/end`); toast('Session ended') } catch (err) { toast(err.message) }
@@ -600,21 +582,7 @@ function bindSessionSettings (root) {
       refreshPeople()
     } catch (err) { toast(err.message) } finally { save.disabled = false }
   })
-  root.addEventListener('submit', async (e) => {
-    const f = e.target.closest('.pm-gh')
-    if (!f) return
-    e.preventDefault()
-    const token = f.token.value.trim()
-    if (!token) return toast('Paste a token first')
-    const save = f.querySelector('[type=submit]')
-    save.disabled = true
-    try {
-      await api('POST', `/api/sessions/${current}/github-token`, { token })
-      f.token.value = ''
-      toast('Token saved: the relay brings in commits while everyone\'s offline')
-      refreshPeople({ force: true })
-    } catch (err) { toast(err.message) } finally { save.disabled = false }
-  })
+
 }
 
 function toggleDrawer (which) {
@@ -653,44 +621,6 @@ function agentLine (p) {
 }
 
 // ------------------------------------------------------------- branches --
-let branchSyncing = false
-
-/** One line on how a branch stands against its upstream ('' without one). */
-export function upstreamText (u) {
-  if (!u || !u.name) return ''
-  const n = (k, w) => `${k} ${w}${k === 1 ? '' : 's'}`
-  // A failed fetch: what git last knew is stale, so never "up to date".
-  if (u.fetchOk === false) return `can't fetch ${u.name}: ${u.fetchError || 'git fetch failed'}`
-  const by = u.mergedBy ? `; being merged by ${u.clashMine ? 'your AI' : u.mergedBy}` : ''
-  if (u.diverged) return `diverged from ${u.name}: ${n(u.ahead, 'commit')} here, ${n(u.behind, 'commit')} there${by}`
-  const clash = Array.isArray(u.conflicts) ? u.conflicts.length : u.conflicts
-  if (clash) return `${n(u.behind, 'commit')} behind ${u.name}; ${n(clash, 'file')} clash with the session's work${by}`
-  if (u.waiting) return `${n(u.behind, 'commit')} behind ${u.name}; waiting: ${u.waiting}`
-  if (u.behind) return `${n(u.behind, 'commit')} behind ${u.name}`
-  if (u.ahead) return `${n(u.ahead, 'commit')} ahead of ${u.name}`
-  return `up to date with ${u.name}`
-}
-
-/** Whether the label should draw the eye: this folder is behind and Quilt can't bring it in by itself. */
-export function needsHand (u) {
-  return !!(u && (u.diverged || u.fetchOk === false || (Array.isArray(u.conflicts) ? u.conflicts.length : u.conflicts)))
-}
-
-/**
- * The git panel's head in a session still on git: this folder's branch, how it stands against its
- * upstream, and Check. The list of every branch (the branch menu, src/ui/branches.js) went in 16's R2:
- * which branch a folder is on is git's, and new sessions are quilts.
- */
-export function folderBranchHtml ({ git, syncing = false }) {
-  if (!git) return ''
-  const u = git.upstream
-  return `<div class="br-here br-compact">
-      <div class="br-line">${I.branch}<b class="br-name">${esc(git.key)}</b>${u ? `<span class="br-sub${needsHand(u) ? ' warn' : ''}" title="${esc(upstreamText(u))}">${esc(upstreamText(u))}</span>` : ''}${u ? `<button type="button" class="btn sm ghost br-sync" data-branch-sync ${syncing ? 'disabled' : ''} title="Look for new commits on ${esc(u.name || 'the upstream')}">${I.refresh}<span>${syncing ? 'Checking' : 'Check'}</span></button>` : ''}</div>
-      ${u && Array.isArray(u.conflicts) && u.conflicts.length ? `<ul class="br-clash">${u.conflicts.slice(0, 6).map((c) => `<li><code>${esc(c.path)}</code> ${esc(c.why)}</li>`).join('')}</ul><div class="br-hint">Ask your AI to pull and resolve these: Quilt brings nothing in until they're settled.</div>` : ''}
-      ${u && u.diverged ? '<div class="br-hint">Quilt never merges git history: ask your AI to pull or rebase, and the session takes in the result.</div>' : ''}
-    </div>`
-}
-
 let squareBusy = '' // 'commit' or 'merge' while the square panel's button runs (layout 3)
 
 function renderBranchMenu () {
@@ -712,8 +642,8 @@ function renderBranchMenu () {
     return
   }
   delete menu.dataset.html
-  menu.hidden = !st.git
-  menu.innerHTML = folderBranchHtml({ git: st.git, syncing: branchSyncing })
+  menu.hidden = true
+  menu.innerHTML = ''
 }
 
 /** The square panel's Commit and Merge onto main (layout 3): Seam's own tools, as this member (control.js seamTool). */
@@ -747,15 +677,7 @@ function bindBranchMenu () {
   menu.addEventListener('click', async (e) => {
     // Merge commits what isn't committed yet first: with the words typed in the box, if any.
     if (e.target.closest('[data-square-open]')) { if (!squareBusy) squareAct('open_square'); return }
-    if (e.target.closest('[data-square-merge]')) { if (!squareBusy) squareAct('seam_merge', (menu.querySelector('[data-square-commit] input')?.value || '').trim()); return }
-    if (!e.target.closest('[data-branch-sync]') || branchSyncing) return
-    branchSyncing = true
-    renderBranchMenu()
-    const id = current
-    try { await api('POST', `/api/sessions/${id}/branches/sync`) } catch (err) { toast(err.message) } finally {
-      branchSyncing = false
-      if (id === current && !$('#git-panel').hidden) renderBranchMenu()
-    }
+    if (e.target.closest('[data-square-merge]')) { if (!squareBusy) squareAct('seam_merge', (menu.querySelector('[data-square-commit] input')?.value || '').trim()) }
   })
 }
 
@@ -766,11 +688,8 @@ function renderTop () {
   // Code search, only in a session linked to a quilt (the relay reads Seam for it).
   const search = $('#qt-topsearch')
   if (search) search.hidden = !st.quilt
-  const g = st.git
   const label = $('#git-branch')
   const seam = inSeam(st) ? seamChip(st) : null
-  // In Seam nobody asks a person with git to commit: whoever is on a square commits it.
-  $('#ask-commit').hidden = !!seam
   if (label && seam) {
     // In Seam: the square this folder follows, by the name Seam gives it.
     label.hidden = !seam.label
@@ -778,21 +697,8 @@ function renderTop () {
     label.dataset.title = seam.title
     if (!$('#git-panel').hidden) renderBranchMenu()
   } else if (label) {
-    label.hidden = !g
-    if (g) {
-      // Moving to another branch: said at once. Git busy: only once it has lasted a moment.
-      const held = g.hold ? Date.now() - g.hold.since : 0
-      const note = g.hold && (g.hold.kind === 'switching' || held >= HOLD_NOTE_MS)
-      clearTimeout(holdNoteTimer)
-      if (g.hold && !note) holdNoteTimer = setTimeout(renderTop, HOLD_NOTE_MS - held + 20)
-      const tag = note ? (g.hold.kind === 'switching' ? (g.hold.waiting === 'refused' ? `not syncing · ${esc(g.hold.to || '?')} isn't in the session` : g.hold.waiting === 'retrying' ? `waiting for ${esc(g.hold.to || '?')}…` : `moving to ${esc(g.hold.to || '?')}…`) : g.hold.conflict ? 'paused: resolve the git conflict' : 'syncing paused: git is busy') : ''
-      const up = g.upstream
-      const behind = !tag && up && (up.behind || up.diverged) ? `<span class="tag${needsHand(up) ? ' warn' : ''}">${needsHand(up) ? 'needs a pull' : `${up.behind} behind`}</span>` : ''
-      const full = g.full ? '<span class="tag warn" title="This branch is over the session\'s size limit: new changes aren\'t saved. Start a fresh copy with git checkout -b.">full</span>' : ''
-      label.innerHTML = `${I.branch}<span class="branch-name">${esc(g.key)}</span>${tag ? `<span class="tag" title="${tag}">${tag}</span>` : ''}${behind}${full}`
-      label.dataset.title = g.hold ? (g.hold.kind === 'switching' ? (g.hold.waiting === 'refused' ? `The session can't take ${g.hold.to || 'this branch'}, so this folder isn't syncing. Check out ${g.key} again in git to keep syncing there.` : `You checked out ${g.hold.to || 'another branch'} in git: this folder is moving to that branch's work in the session. The branch it left keeps its own.`) : g.hold.conflict ? `git left a conflict in ${g.hold.conflict.join(', ')} on this computer. Resolve it and git add it; Quilt then shares your resolution.` : 'Quilt waits for git to finish, then catches up.') : `This folder is on ${g.key}${up ? `, ${upstreamText(up)}` : ''}${g.full ? '. Over the size limit: new changes aren\'t saved.' : ''}.`
-    }
-    if (!$('#git-panel').hidden) renderBranchMenu()
+    label.hidden = true
+    label.innerHTML = ''
   }
   const people = [st.me, ...peopleHere(st)]
   const shown = people.slice(0, 4)
@@ -811,7 +717,6 @@ function renderTop () {
   renderAccess()
   renderCatchUp($('#catchup'), st.catchUp, { colors: new Map([st.me, ...st.peers].map((p) => [p.name, p.color])) })
   renderSquareCard()
-  renderGithubCard()
   renderGitChip()
   $('#sess-name').textContent = st.sessionName || basename(sum().dir)
   const me = state.account || {}
@@ -824,161 +729,35 @@ function renderTop () {
   $('#chat-sub').textContent = st.peers.length ? `with ${peopleHere(st).map((p) => p.sessions && p.mine ? 'your AI' : p.name).join(', ')}` : 'just you so far'
 }
 
-// --------------------------------------------------------------- commits --
-// Agents get their own work into git (git from their folders, signed in through the session's GitHub
-// connection; quilt_commit for agents without a folder), within what the owner lets them: picked
-// here. When they can't, they ask (commit.js): in a folder with git each
-// request has a Commit button (exactly its files, then a push). "Not committed yet" shows the
-// uncommitted work here by who made it, so nothing finished sits unshipped unnoticed.
-let commitGithub = null // the owner's GitHub connection (GET /api/github), while the panel is open
-// Your own work not committed here (GET mine-uncommitted: yours and your AIs', each boxed or not),
-// for the git chip's count and the panel. Nobody else's: they commit their own.
-let mineView = { id: null, data: null, at: 0, loading: false, again: false, open: new Set(['boxed']) }
-const MINE_FRESH_MS = 3000 // fetched again at most this often as the session changes
+// --------------------------------------------------------------- source control --
+// The chip in the top bar: in Seam, the square this folder follows and its work not committed yet
+// (the panel commits and merges it); otherwise how many files changed in the session.
 
-function loadMine (force = false) {
-  const id = current
-  if (!id) return
-  if (mineView.id !== id) mineView = { id, data: null, at: 0, loading: false, again: false, open: new Set(['boxed']) }
-  if (mineView.loading) { mineView.again = true; return }
-  const wait = MINE_FRESH_MS - (Date.now() - mineView.at)
-  if (!force && wait > 0) { clearTimeout(loadMine.timer); loadMine.timer = setTimeout(() => loadMine(true), wait); return }
-  mineView.loading = true
-  api('GET', `/api/sessions/${id}/mine-uncommitted`).then((r) => {
-    if (mineView.id !== id) return
-    mineView.data = r && Array.isArray(r.files) ? r : null
-    mineView.at = Date.now()
-    renderGitChip()
-  }, () => {}).finally(() => {
-    if (mineView.id !== id) return
-    mineView.loading = false
-    if (mineView.again) { mineView.again = false; loadMine() }
-  })
-}
-
-/** How many of your own files aren't committed here (null before the first look, or without git). */
-const mineCount = () => (mineView.id === current && mineView.data ? mineView.data.files.length : null)
-/** Session settings: GitHub sync, large files through the relay, and git for this session. */
-async function gitSettingChange (e) {
-  if (e.target.matches('[data-large-to-relay]')) {
-    try {
-      const r = await api('POST', `/api/sessions/${current}/large-to-relay`, { on: e.target.checked })
-      toast(r.largeToRelay ? 'The relay can commit large files on branches that sync with GitHub now.' : 'Large files stay end-to-end encrypted: the relay commits none.')
-    } catch (err) { toast(err.message); renderSessionSettings({ force: true }) }
-    return
-  }
-  if (e.target.matches('[data-github-sync]')) {
-    try {
-      const r = await api('POST', `/api/sessions/${current}/github-sync`, { on: e.target.checked })
-      toast(r.githubSync === false ? 'Sync with GitHub is off for this session.' : 'This session syncs with GitHub.')
-    } catch (err) { toast(err.message); renderSessionSettings({ force: true }) }
-    return
-  }
-  const seg = e.target.closest('[data-agent-commits]')
-  if (!seg || seg.disabled || seg.classList.contains('on')) return
-  seg.closest('.seg').querySelectorAll('button').forEach((b) => { b.classList.toggle('on', b === seg); b.setAttribute('aria-pressed', String(b === seg)) })
-  try {
-    const r = await api('POST', `/api/sessions/${current}/agent-commits`, { mode: seg.dataset.agentCommits })
-    toast(AGENT_COMMIT_WORDS[r.agentCommits])
-  } catch (err) { toast(err.message); renderSessionSettings({ force: true }) }
-}
-
-/** Opens or closes the git panel: this folder's branch, the session against GitHub, and what changed, in one place. */
+/** Opens or closes the source control panel: the square, and what changed, in one place. */
 function setGitOpen (open) {
   const panel = $('#git-panel')
   if (!panel) return
   panel.hidden = !open
   $('#git-chip').setAttribute('aria-expanded', String(open))
-  if (open) { markChangesSeen(); renderBranchMenu(); renderCommitPanel(); loadCommitWork(); loadChanges().then(() => { if (!panel.hidden) markChangesSeen() }); loadMine(true) }
+  if (open) { markChangesSeen(); renderBranchMenu(); renderCommitPanel(); loadChanges().then(() => { if (!panel.hidden) markChangesSeen() }) }
 }
 
 function bindCommitChip () {
   const wrap = $('#git-wrap')
   const chip = $('#git-chip')
-  const panel = $('#commit-panel')
   chip.onclick = () => setGitOpen($('#git-panel').hidden)
   wrap.addEventListener('keydown', (e) => { if (e.key === 'Escape') { setGitOpen(false); chip.focus() } })
   document.addEventListener('mousedown', (e) => { if (!wrap.contains(e.target) && !e.target.closest('.modal, .dialog')) setGitOpen(false) }, { signal: mounted.signal })
-  panel.addEventListener('submit', async (e) => {
-    const form = e.target.closest('[data-commit-session]')
-    if (!form) return
-    e.preventDefault()
-    const btn = form.querySelector('button')
-    const input = form.querySelector('input')
-    btn.disabled = true
-    btn.textContent = 'Committing…'
-    try {
-      const r = await api('POST', `/api/sessions/${current}/commit-session`, { message: input.value, mine: true })
-      toast(r.hash ? `Committed ${r.hash.slice(0, 7)}${r.pushed ? ' and pushed' : `; not pushed: ${r.pushError || 'no upstream'}`}` : 'Already in git')
-      input.value = ''
-      loadMine(true)
-    } catch (err) { toast(err.message) } finally {
-      btn.disabled = false
-      btn.textContent = 'Commit and push'
-    }
-  })
-  // Which of your two lines (boxed, shared) is open stays so across redraws.
-  panel.addEventListener('toggle', (e) => {
-    const d = e.target.closest && e.target.closest('[data-mine-group]')
-    if (d) d.open ? mineView.open.add(d.dataset.mineGroup) : mineView.open.delete(d.dataset.mineGroup)
-  }, true)
-  panel.addEventListener('click', async (e) => {
-    if (e.target.closest('[data-gh-connect]')) { connectGithub(); return }
-    const live = e.target.closest('[data-open-live]')
-    if (live) { live.disabled = true; openLiveSession(live.dataset.openLive).catch((err) => { toast(err.message); live.disabled = false }); return }
-    const b = e.target.closest('[data-done], [data-commit]')
-    if (!b) return
-    b.disabled = true
-    try {
-      if (b.dataset.done) {
-        const id = b.dataset.done === 'all' ? null : b.dataset.done
-        const r = await api('POST', `/api/sessions/${current}/commit-request/done`, id ? { id } : {})
-        toast(r.done === 1 ? 'Closed' : `Closed ${r.done}`)
-      } else if (b.dataset.commit) {
-        b.textContent = 'Committing…'
-        const r = await api('POST', `/api/sessions/${current}/commit-request/commit`, { id: b.dataset.commit })
-        toast(r.hash ? `Committed ${r.hash.slice(0, 7)}${r.pushed ? ' and pushed' : `; not pushed: ${r.pushError || 'no upstream'}`}` : 'Already in git: closed')
-      }
-      loadCommitWork()
-    } catch (err) { toast(err.message); b.disabled = false; loadCommitWork() }
-  })
-}
-
-async function loadCommitWork () {
-  if ($('#git-panel').hidden) return
-  const st = sum().status
-  if (st.access?.owner) { try { commitGithub = await api('GET', '/api/github') } catch { commitGithub = null } }
-  renderCommitPanel()
 }
 
-/**
- * The git chip: this folder's branch, how many files changed in the session, and a dot (with a
- * word when something needs someone) for the session against GitHub. One control for all three,
- * so the top bar has one place for source control.
- */
+/** The source control chip: the square this folder follows (in Seam) and how many files changed. */
 function renderGitChip () {
   const chip = $('#git-chip')
   if (!chip || !sum()) return
   const st = sum().status
-  const open = (st.commits || []).filter((r) => r.state === 'open')
-  const gh = githubStateOf(st)
-  const busy = busyPeople(st)
-  // A branch that syncs live already has what it needs (a connection, or the owner's token).
-  const liveOn = !!(myBranchOf(st)?.relay?.live)
-  const off = !!(myBranchOf(st)?.relay?.sync?.state === 'paused' && /owner turned (live )?sync( with GitHub)? off/.test(myBranchOf(st).relay.sync.why || ''))
-  const needs = gh && gh.state && gh.state !== 'ok' && gh.state !== 'not-github' && !liveOn && !off
-  const live = syncWords(st)
-  const warn = !!(live && live.warn && !open.length)
-  chip.className = `git-chip${open.length && !busy.length ? ' ready' : ''}${(needs && !open.length) || warn ? ' needs' : ''}${!open.length && !needs && !warn ? ' quiet' : ''}`
-  // Words only when someone has to act; otherwise the dot says where the session stands.
-  const say = open.length ? `${open.length === 1 ? 'Commit requested' : 'Commits requested'}${busy.length ? ` · ${busy.length === 1 ? 'someone' : 'people'} working` : ''}`
-    : needs ? 'Connect GitHub' : warn ? live.chip : ''
-  const sayEl = $('#git-say')
-  sayEl.hidden = !say
-  sayEl.textContent = say
-  const dot = $('#git-dot')
-  dot.hidden = !!say || !(live && live.dot)
-  dot.className = `sd${live && live.dot ? ` ${live.dot}` : ''}`
+  chip.className = 'git-chip quiet'
+  $('#git-say').hidden = true
+  $('#git-dot').hidden = true
   const branch = $('#git-branch')
   const seam = inSeam(st) ? seamChip(st) : null
   // In Seam the session's own record of changes stopped at the switch (its branch document is kept read-only):
@@ -992,171 +771,37 @@ function renderGitChip () {
     chip.title = [seam.title, seam.countLine, 'Click for your square.'].filter(Boolean).join('\n')
     chip.setAttribute('aria-label', seam.aria)
     $('#git-panel').setAttribute('aria-label', 'Square')
-    if (!$('#git-panel').hidden) renderCommitPanel()
     return
   }
-  // The number is your own work not committed (once that's known; before that, every file changed in
-  // the session). What others changed since you last opened this panel goes in the tooltip, not the
-  // number, with the session's total.
-  const own = mineCount()
-  const { n, lines: counts } = chipCounts({ own, total: changedCount(), fresh: unseenChanges() })
+  const n = changedCount()
+  const fresh = unseenChanges()
   $('#chg-count').textContent = n
   $('#git-chg').hidden = !n
   $('#git-sep').hidden = branch.hidden || !n
-  const lines = [
-    branch.hidden ? '' : branch.dataset.title,
-    ...counts,
-    open.length ? open.map((r) => `${shownName(authorOf(r), owners(sum()))}: ${r.message}`).join('\n') : live ? live.line : gh ? githubWords(gh) : ''
-  ].filter(Boolean)
-  $('#git-panel').setAttribute('aria-label', 'Branch, GitHub and changes')
-  chip.title = [...lines, 'Click for branches, GitHub and every change.'].join('\n')
-  chip.setAttribute('aria-label', `Source control${branch.hidden ? '' : `: ${st.git.key}`}${n ? own === null ? `, ${n} changed` : `, ${n} of yours not committed` : ''}${say ? `, ${say}` : live ? `, ${live.chip}` : ''}`)
-  if (!$('#git-panel').hidden) renderCommitPanel()
-}
-
-/** Open requests (Commit, Close), the uncommitted work here by who made it, and committing by itself. */
+  $('#git-panel').setAttribute('aria-label', 'Changes')
+  chip.title = [n ? `${n} changed in the session` : '', fresh ? `${fresh} new since you last looked` : '', 'Click for every change.'].filter(Boolean).join('\n')
+  chip.setAttribute('aria-label', `Source control${n ? `, ${n} changed` : ''}`)
+}
+
+/** Nothing of git's to show under the square or the changes. */
 function renderCommitPanel () {
   const panel = $('#commit-panel')
   if (!panel) return
-  const st = sum().status
-  const open = (st.commits || []).filter((r) => r.state === 'open')
-  const fileList = (files) => `<details><summary>${files.length} file${files.length === 1 ? '' : 's'}</summary><ul class="commit-files">${files.map((f) => `<li>${esc(f)}</li>`).join('')}</ul></details>`
-  const req = (r) => {
-    const why = r.error ? `Last try: ${r.error}` : ''
-    return `<li><b>${esc(shownName(authorOf(r), owners(sum())))}</b>${r.task ? ` <span class="hint">· task</span>` : ''}<div>${esc(r.message)}</div>
-      ${Array.isArray(r.files) && r.files.length ? fileList(r.files) : ''}
-      ${why ? `<p class="commit-why">${esc(why)}</p>` : ''}
-      <div class="commit-acts">${st.canCommit ? `<button type="button" class="btn sm" data-commit="${esc(r.id)}">Commit and push</button>` : ''}<button type="button" class="btn sm ghost" data-done="${esc(r.id)}" title="Close it without a commit from Quilt (committed by hand, or not needed)">Close</button></div></li>`
-  }
-  // Only what needs a person: an agent that may not commit itself asked for one, the session's
-  // work not on GitHub yet (and the commit that sends it), or GitHub to connect. Settings
-  // (sync, large files, what agents may commit) live in Session settings.
-  const html = `
-    ${open.length ? `<h4>Asked to be committed</h4><ul class="commit-reqs">${open.map(req).join('')}</ul>` : ''}
-    ${mineHtml(st)}
-    ${gitLineHtml(st)}
-    ${connectHtml(st)}
-    ${open.length > 1 ? '<div class="commit-foot"><button type="button" class="btn sm ghost" data-done="all">Close all</button></div>' : ''}`.trim()
-  panel.hidden = !html
-  // Status comes in often: redrawn only when something in it changed, so an open menu or a
-  // file list someone expanded stays as it is.
-  if (panel.dataset.html === html) return
-  panel.dataset.html = html
-  // A commit message being typed survives the redraw.
-  const typing = panel.querySelector('[data-commit-session] input')
-  const kept = typing ? { value: typing.value, focused: document.activeElement === typing, at: typing.selectionStart } : null
-  panel.innerHTML = html
-  const box = kept && panel.querySelector('[data-commit-session] input')
-  if (box) {
-    box.value = kept.value
-    if (kept.focused) { box.focus(); box.setSelectionRange(kept.at, kept.at) }
-  }
-}
-
-/** This folder's branch in the relay's branch list (or the default branch), or null. */
-function myBranchOf (st) {
-  const list = st.branches || []
-  return (st.git && list.find((x) => x.name === st.git.key)) || list.find((x) => x.default) || null
-}
-
-/** Where this branch stands with GitHub (GitHub as a node: relay-sync.js syncStatus), in a few words, with how to read it. */
-function syncWords (st) {
-  if (inSeam(st)) return null
-  const b = myBranchOf(st)
-  const r = b && b.relay
-  const s = r && r.sync
-  if (!s) return null
-  const name = b.name
-  const at = s.revision ? ` at ${s.revision.slice(0, 7)}` : ''
-  const t = (ms) => new Date(ms).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })
-  if (s.state === 'synced') return { chip: 'Committed', dot: 'ok', line: `${name} is in step with GitHub${at}: everything in the session is committed, and pushes and merges there come in within seconds.`, warn: false }
-  if (s.state === 'github-pending') return { chip: 'Uncommitted changes', dot: 'edit', line: `${name} has GitHub's latest${at}. The session has changes that aren't committed: everyone here has them, and GitHub gets them when someone commits.`, warn: false, pending: true }
-  if (s.state === 'conflict-held') return { chip: 'Merge held', line: `${s.why} on ${name}: the session and GitHub changed the same lines. The merge is on the board; everything else keeps syncing.`, warn: true }
-  if (s.state === 'pr-pending') return { chip: s.pr ? `Through pull request #${s.pr.number}` : 'Through a pull request', line: r.leased ? `${name} syncs with GitHub in another session, so this session's commits go through` : `${name} is protected on GitHub, so the session's commits go through`, pr: s.pr || { number: 0, url: '' }, warn: false, leased: !!r.leased, liveIn: r.liveIn || null }
-  if (s.state === 'offline') return { chip: 'GitHub unreachable', line: `GitHub unreachable since ${s.since ? t(s.since) : 'a moment ago'}: the session keeps working, and GitHub's changes and the commits asked for go when it answers.`, warn: true }
-  if (s.state === 'permission-held') return { chip: 'Sync paused', line: s.why, warn: true }
-  if (/owner turned (live )?sync( with GitHub)? off/.test(s.why || '')) return { chip: 'Not syncing', line: `Sync with GitHub is off for this session: files stay in the session, and people commit with git.`, warn: false, off: true }
-  return { chip: 'Not syncing', line: `${(s.why || `sync of ${name} with GitHub is off`).replace(/^./, (c) => c.toUpperCase())}.`, warn: false, off: true }
-}
-
-/**
- * Your own work not committed here, in two lines (mockup option B): what is boxed (in your folder
- * only so far) and what everyone already has; each opens to its files. Then the commit, which
- * takes only these. Nobody else's work is counted or listed.
- */
-function mineHtml (st) {
-  const files = mineView.id === current && mineView.data ? mineView.data.files : null
-  if (!files) return ''
-  if (!files.length) return '<div class="mw-head"><h4>Not committed</h4></div><p class="mw-none">Nothing of yours: your work here is all in git.</p>'
-  const boxed = files.filter((f) => f.boxed)
-  const shared = files.filter((f) => !f.boxed)
-  const group = (key, list, ico, label, hint) => list.length
-    ? `<details class="mw" data-mine-group="${key}"${mineView.open.has(key) ? ' open' : ''}><summary><span class="mw-ico">${ico}</span><span>${list.length} ${label}</span><span class="hint">${hint}</span></summary><ul>${list.map((f) => `<li><code title="${esc(f.path)}">${esc(f.path)}</code></li>`).join('')}</ul></details>`
-    : ''
-  return `<div class="mw-head"><h4>Not committed</h4></div>
-    ${group('boxed', boxed, I.box, 'boxed', 'only in your folder')}
-    ${group('shared', shared, '<span class="mw-dot"></span>', 'shared', 'everyone has them')}
-    ${st.canCommit ? `<form class="cp-commit" data-commit-session><input class="input" name="message" placeholder="Commit message" aria-label="Commit message" maxlength="500" required autocomplete="off"><button type="submit" class="btn sm primary">Commit and push</button></form>` : ''}`
-}
-
-/** The session against GitHub in a line (the long words on hover), and the commit that sends what isn't there yet. */
-function gitLineHtml (st) {
-  const w = syncWords(st)
-  if (!w || w.off) return ''
-  const b = myBranchOf(st)
-  // Work not on GitHub yet: what is yours shows above (mineHtml); everyone else's is theirs to commit.
-  if (w.pending) return ''
-  const pr = w.pr ? (w.pr.url ? ` · <a href="${esc(w.pr.url)}" target="_blank" rel="noreferrer">pull request #${w.pr.number}</a>` : '') : ''
-  const live = w.liveIn ? ` <button type="button" class="btn sm" data-open-live="${esc(w.liveIn)}">Open the live session</button>` : ''
-  return `<p class="cp-line${w.warn ? ' warn' : ''}" title="${esc(w.line)}">${w.dot ? `<span class="sd ${w.dot}"></span>` : ''}<span>${esc(w.chip)}</span>${pr}${live}</p>`
-}
-
-/** Connect GitHub, while nobody here has (one click, by anyone who can write to the repository). */
-function connectHtml (st) {
-  const gh = githubStateOf(st)
-  if (!gh || !gh.state || gh.state === 'ok' || gh.state === 'not-github' || myBranchOf(st)?.relay?.live) return ''
-  return `<p class="cp-line"><button type="button" class="btn sm" data-gh-connect>${gh.state === 'not-installed' ? 'Add it on GitHub' : 'Connect GitHub'}</button><span class="hint">so git is on for everyone here, agents included</span></p>`
-}
-
-/** What else the git card says under the control: the read-only token, or why git isn't working yet. */
-function agentCommitNote (st) {
-  const gh = githubStateOf(st)
-  if (st.access.githubToken) return 'Agents without a folder commit with the session\'s GitHub token.'
-  if (gh && gh.state && gh.state !== 'ok') return `${esc(githubWords(gh))} Connect GitHub from the branch button in the top bar.`
-  if (!gh) return 'This session doesn\'t follow a GitHub repository yet.'
-  return ''
+  panel.hidden = true
+  panel.innerHTML = ''
+  delete panel.dataset.html
 }
 
-/**
- * Git for this session (mockup option A): one segmented control that fills its card, the rule over the
- * session as a pill (who set it), the choices it doesn't allow greyed with why, and who git works through.
- */
-function gitCardHtml (st) {
-  const by = st.agentCommitsBy
-  const m = gitControl({ value: st.agentCommits || 'branches', rule: by && by.mode ? by : null })
-  const g = st.gitForEveryone
-  const line = g && g.words ? gitStatusParts(g.words) : null
-  const note = agentCommitNote(st)
-  return `<div class="pm-card git-card">
-    <div class="git-head"><h4>This session's source control</h4>${m.rulePill ? `<span class="pill rule">${esc(m.rulePill)}</span>` : '<span class="pill">No rule above it</span>'}</div>
-    ${gitSegHtml(m, { attr: 'data-agent-commits', label: 'This session\'s source control' })}
-    ${line ? `<p class="git-line ${g.policy === 'off' ? 'off' : g.on ? 'ok' : ''}"><b>${esc(line.strong)}</b>${esc(line.rest)}</p>` : ''}
-    ${m.lockedHint ? `<span class="hint">${esc(m.lockedHint)}</span>` : ''}
-    ${note ? `<span class="hint">${note}</span>` : ''}
-  </div>`
-}
-
-/** Session settings, for the owner: syncing with GitHub, large files, and git for this session. */
 /**
  * "Make this a quilt" (Seam's plans/quilt-source-control/16, flag 9), for the session's owner while its
- * code is still on git: one button. With no git remote the relay makes the quilt and moves the files
+ * code is not in Seam yet: one button. With no git remote the relay makes the quilt and moves the files
  * into its squares at once; with one, it becomes a quilt with its history (makeQuiltWords).
  */
 function makeQuiltHtml (st) {
   if (inSeam(st)) return ''
   // Everyone hears that live sync stopped at the forced date; only the owner gets the button.
   if (!st.access?.owner) return st.force && st.force.stopped ? `<div class="pm-section"><div class="pm-title">Seam</div><div class="pm-card git-card"><p class="git-line warn">${esc(st.force.stopped.why || '')}</p></div></div>` : ''
-  const words = makeQuiltWords({ quilt: st.quilt || null, remote: !!githubStateOf(st) || !!(st.git && st.git.upstream), moving: !!st.moving, force: st.force || null, importing: st.importing || null, shadow: st.shadow || null })
+  const words = makeQuiltWords({ quilt: st.quilt || null, remote: !!(st.quilt && st.quilt.hasRemote) || !!(st.force && (st.force.remote || st.force.stopped)), moving: !!st.moving, force: st.force || null, importing: st.importing || null, shadow: st.shadow || null })
   return `<div class="pm-section"><div class="pm-title">Seam</div><div class="pm-card git-card">
     <div class="git-head"><h4>Make this a quilt</h4><span class="pill">Seam</span></div>
     ${words.note ? `<p class="git-line warn">${esc(words.note)}</p>` : ''}
@@ -1186,54 +831,6 @@ async function makeQuilt (btn) {
   } finally { renderSessionSettings({ force: true }) }
 }
 
-function githubSettingsHtml (st) {
-  if (!st.access?.owner) return ''
-  const sync = st.access.githubSync
-  const rows = [
-    sync !== undefined ? `<label class="pm-switch"><span><b>Sync with GitHub</b><small>Pushes and merges on GitHub come into the session within seconds; nothing goes to GitHub until someone commits.</small></span><input type="checkbox" role="switch" data-github-sync ${sync !== false ? 'checked' : ''}></label>` : '',
-    sync !== undefined && sync !== false ? `<label class="pm-switch"><span><b>Let the relay commit large files</b><small>Large files are end-to-end encrypted. On branches that sync with GitHub this lets the relay read them, so a commit can include them.</small></span><input type="checkbox" role="switch" data-large-to-relay ${st.access.largeToRelay ? 'checked' : ''}></label>` : ''
-  ].filter(Boolean).join('')
-  return `<div class="pm-section"><div class="pm-title">GitHub</div>${gitCardHtml(st)}${rows ? `<div class="pm-card pm-settings">${rows}</div>` : ''}</div>`
-}
-
-/** Opens session `room`: the one already open in this app, else a recent one on this computer. */
-async function openLiveSession (room) {
-  for (const [id, s] of state.sessions) if (s && s.status && s.status.room === room) return go(id)
-  const r = (state.recent || []).find((x) => x.room === room)
-  if (!r) { toast('That session isn\'t on this computer: ask its owner for an invite.'); return }
-  const opened = await api('POST', '/api/sessions', { mode: 'rejoin', dir: r.dir })
-  state.sessions.set(opened.id, opened)
-  await go(opened.id)
-}
-
-/** The session's repository on GitHub and whether a member's connection lets agents commit there, from the relay's branch list. */
-function githubStateOf (st) {
-  if (inSeam(st)) return null // GitHub only receives Seam's export of main: nothing to connect or sync here
-  const list = st.branches || []
-  const b = (st.git && list.find((x) => x.name === st.git.key)) || list.find((x) => x.default) || null
-  const r = b && b.relay
-  if (!r || !r.repo || !/^github\.com\//.test(r.repo)) return null
-  return { repo: r.repo.replace(/^github\.com\//, ''), state: r.github ? r.github.state : '', login: r.github ? r.github.login : '' }
-}
-
-/** The connection, in a sentence. */
-function githubWords (gh) {
-  if (!gh) return ''
-  if (gh.state === 'ok') return `Git is on for everyone here, through @${gh.login}'s connection: people and agents push to ${gh.repo} with git, nothing to set up (a short-lived token each), and pushes come in within seconds. To keep a branch safe for good, protect it on GitHub.`
-  if (gh.state === 'not-installed') return `Quilt isn't installed on ${gh.repo} on GitHub yet.`
-  if (gh.state === 'no-access') return `No connected GitHub account (@${gh.login}) may write to ${gh.repo}.`
-  if (gh.state === 'not-connected') return `Nobody here has connected GitHub for ${gh.repo} yet.`
-  return `Checking ${gh.repo}…`
-}
-
-// --------------------------------------------------------- GitHub card --
-// A session on a GitHub repository that no member has connected yet: one card at the top, for
-// people, with the one click that lets agents commit and merge on their own. "Not now" keeps it
-// away for a week; the commit chip still says "Connect GitHub".
-const GH_DISMISS_MS = 7 * 24 * 60 * 60 * 1000
-const ghDismissKey = (repo) => `quilt.github.notnow.${repo}`
-let ghConnecting = null // the repo a Connect click is waiting on (polling the account)
-
 /**
  * In a session that is a quilt at layout 3: one plain line on where this folder's work goes (the
  * square it follows, and how to commit it; session-follow.js), or why an edit reached nobody.
@@ -1250,86 +847,12 @@ function renderSquareCard () {
   el.innerHTML = html
 }
 
-function renderGithubCard () {
-  const el = $('#github-card')
-  if (!el) return
-  const st = sum().status
-  const gh = githubStateOf(st)
-  const dismissed = gh && recall(ghDismissKey(gh.repo))
-  const show = gh && ['not-connected', 'not-installed', 'no-access'].includes(gh.state) && !(dismissed && Date.now() - Number(dismissed) < GH_DISMISS_MS)
-  el.hidden = !show
-  if (!show) { el._html = ''; return }
-  const action = gh.state === 'not-installed' ? 'Add it on GitHub' : 'Connect GitHub'
-  const html = `<div class="gh-card">
-    <div class="gh-text"><b>${esc(gh.state === 'not-installed' ? `Quilt isn't on ${gh.repo} yet` : gh.state === 'no-access' ? `@${gh.login} can't write to ${gh.repo}` : `This session follows ${gh.repo}`)}</b>
-      <span>${esc(gh.state === 'not-installed' ? 'Add the repository to Quilt on GitHub, and agents here commit and merge on their own; pushes come in within seconds.' : gh.state === 'no-access' ? 'Someone whose GitHub account can write to it connects once, and that covers everyone here, agents included.' : 'Connect GitHub once (one click, by anyone whose GitHub account can write to it): agents here then commit and merge on their own, and pushes come in within seconds. Nobody else has to connect.')}</span></div>
-    <div class="gh-acts">${ghConnecting === gh.repo ? `<span class="hint">${loadingNote('Finish on GitHub, then come back…')}</span>` : `<button type="button" class="btn sm primary" data-gh-connect>${action}</button>`}<button type="button" class="btn sm ghost" data-gh-later>Not now</button></div>
-  </div>`
-  if (el._html === html) return
-  el._html = html
-  el.innerHTML = html
-}
-
 /** The square card's button: a folder whose branch has no square opens one (layout 3). */
 function bindSquareCard () {
   const el = $('#square-card')
   if (el) el.addEventListener('click', (e) => { if (e.target.closest('[data-square-open]') && !squareBusy) squareAct('open_square') })
 }
 
-function bindGithubCard () {
-  const el = $('#github-card')
-  if (!el) return
-  el.addEventListener('click', (e) => {
-    if (e.target.closest('[data-gh-connect]')) return connectGithub()
-    const later = e.target.closest('[data-gh-later]')
-    if (!later) return
-    const gh = githubStateOf(sum().status)
-    if (gh) remember(ghDismissKey(gh.repo), String(Date.now()))
-    renderGithubCard()
-  })
-}
-
-/** Opens GitHub's install page for this session's repository, then watches for the connection and tells the relay to look again. */
-async function connectGithub () {
-  const gh = githubStateOf(sum().status)
-  try {
-    const { url } = await api('POST', '/api/github/connect', gh ? { repo: gh.repo } : {})
-    window.open(url, '_blank', 'noopener')
-    toast('Finish on GitHub, then come back')
-  } catch (err) { toast(err.message); return }
-  if (!gh) return
-  ghConnecting = gh.repo
-  renderGithubCard()
-  const id = current
-  const until = Date.now() + 10 * 60 * 1000
-  let was = null
-  try { was = (await api('GET', '/api/github')).login || null } catch {}
-  while (Date.now() < until && current === id && ghConnecting === gh.repo) {
-    await new Promise((r) => setTimeout(r, 3000))
-    let now = null
-    try { now = (await api('GET', '/api/github')).login || null } catch {}
-    if (!now || now === was) continue
-    // Connected (or re-connected): the relay checks the repository again, and the card and chip follow.
-    try {
-      const r = await api('POST', `/api/sessions/${id}/github/recheck`)
-      const s = r && r.github && r.github.state
-      toast(s === 'ok' ? `Connected as @${now}: agents can commit here now` : s === 'not-installed' ? `Connected as @${now}, but ${gh.repo} wasn't picked: add it on GitHub` : s === 'no-access' ? `@${now} can't write to ${gh.repo}` : `Connected as @${now}`)
-    } catch (err) { toast(err.message) }
-    break
-  }
-  if (ghConnecting === gh.repo) ghConnecting = null
-  renderGithubCard()
-}
-
-async function askForCommit () {
-  const message = await ask({ title: 'Ask for a commit', message: 'Of everything you changed that is not in git yet. A person with git on this branch commits it, and you are told the commit.', ok: 'Ask', input: { label: 'What is the commit for?', placeholder: 'Pricing page and download button' } })
-  if (!message) return
-  try {
-    const r = await api('POST', `/api/sessions/${current}/commit-request`, { message: message.trim() })
-    toast(`Asked for a commit of ${r.files.length} file${r.files.length === 1 ? '' : 's'}`)
-  } catch (err) { toast(err.message) }
-}
-
 // ----------------------------------------------------------------- access --
 const roleLabel = (r) => r === 'owner' ? 'Owner' : r === 'viewer' ? 'View only' : 'Can edit'
 const scopesText = (scopes) => (scopes || []).join(', ')
@@ -1485,23 +1008,6 @@ function membersHtml (st, kind = 'people') {
     <div class="pm-foot"><button type="button" class="btn sm ghost danger" data-end-session>End session for everyone</button></div>`
 }
 
-/**
- * The owner's GitHub token: the relay brings commits in from a private repository with it while
- * nobody's folder is online, and commits the work of agents without a folder with it (quilt_commit) when it can write.
- * Never shown back: only whether one is set.
- */
-export function githubTokenHtml (acc) {
-  if (!acc || !acc.owner) return ''
-  const set = !!acc.githubToken
-  return `<div class="pm-section"><div class="pm-title">GitHub token</div>
-    <form class="pm-gh pm-admit" autocomplete="off">
-      <label for="pm-gh-token"><span>GitHub token for this session's repository</span></label>
-      <input class="input" id="pm-gh-token" type="password" name="token" autocomplete="off" spellcheck="false" placeholder="${set ? 'A token is set: paste another to replace it' : 'github_pat_… for this repository'}" aria-label="GitHub token">
-      <div class="pm-gh-row"><button type="submit" class="btn sm">Save token</button>${set ? '<button type="button" class="btn sm ghost" data-gh-clear>Remove token</button>' : ''}</div>
-      <div class="hint">With "Contents: Read" Quilt brings in commits while everyone's offline (private repositories need it). With "Contents: Read and write" (and "Pull requests: Read and write") agents can commit their own work, within what you let them above, without anyone online. It stays on the relay and is never shown to anyone, you included.</div>
-    </form></div>`
-}
-
 /** With workspaces on, the agents this session's workspace invites (and the ones not invited), for its People. */
 async function loadSessionAgents () {
   const id = current
@@ -1908,10 +1414,10 @@ function renderSessionSettings ({ force = false } = {}) {
   const active = box.contains(document.activeElement) && document.activeElement.closest('.pm-member') ? document.activeElement : null
   if (!force && active && box.querySelector('.pm-member.edit')) return
   const refocus = active && active.name ? [active.closest('.pm-member').dataset.key, active.name] : null
-  // In Seam the git and GitHub settings are put away (the relay keeps them for a move back): where the history is instead.
-  const vc = inSeam(st) ? seamSettingsHtml(st) : makeQuiltHtml(st) + githubSettingsHtml(st) + githubTokenHtml(st.access)
+  // Source control is Seam's: where the history is (or, for the owner of a session not in Seam yet, the button that moves it there).
+  const vc = inSeam(st) ? seamSettingsHtml(st) : makeQuiltHtml(st)
   box.innerHTML = ssTab === 'chat' ? sharingHtml(st)
-    : ssTab === 'vc' ? (vc || '<div class="pm-empty">Only the session owner changes how this session works with GitHub.</div>')
+    : ssTab === 'vc' ? (vc || '<div class="pm-empty">Only the session owner sees where this session\'s history is.</div>')
       : membersHtml(st, ssTab)
   if (refocus) [...box.querySelectorAll('.pm-member')].find((f) => f.dataset.key === refocus[0])?.elements?.[refocus[1]]?.focus()
 }