heyquilt 0.3.121 → 0.3.138

package/src/ui-server.js

@@ -15,7 +15,6 @@ 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'
@@ -28,6 +27,7 @@ import { effectiveAccess, builtinType } from './session-access.js'
 import { cleanSessionName, BAD_SESSION_NAME, SESSION_NAME_MAX } from './session-name.js'
 import { personPasses, personApiAuth } from './pass-source.js'
 import { INVALID_INVITE } from './ui/invite.js'
+import { seamResultWords } from './ui/seam-model.js'
 import { loadIdentity } from './identity.js'
 import { currentVersion, localReleases, latestRelease, compareVersions, downloadUrl, seenVersion, markSeen, hiddenUpdate, hideUpdate } from './releases.js'
 import { createReporter } from './report.js'
@@ -45,6 +45,9 @@ 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."
+// 16's R2: no New session from GitHub. Said to an older window that still offers it.
+export const GITHUB_GONE = 'Starting a session from GitHub is gone: start one from a folder (a new session\'s code is committed in Seam from the start), and bring a repository\'s history into Seam with seam github import.'
+const STATUS_PUSH_MS = 500 // a session's status goes to the window at most this often when the session changes it
 // 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'])
 
@@ -58,7 +61,7 @@ function profile () {
   return {
     name: account ? account.account.name : os.userInfo().username,
     tool: s.tool || guessTool(),
-    // No tool picked in Settings: the shown one is a guess, and the AI that connects replaces it.
+    // No tool picked in Settings: the shown one is a guess, which saving a colour doesn't pin.
     toolGuessed: !s.tool,
     color: s.color || null,
     joinDir: s.joinDir || '~/quilt',
@@ -120,6 +123,11 @@ function updateProfile (b) {
     patch.autoModel = m || undefined
   }
   if ('autoFiles' in b) patch.autoFiles = b.autoFiles ? true : undefined
+  // Whether a run of the person's AI may merge a square under its line's policy (Seam, 12): never unless they say so.
+  if ('autoMerge' in b) {
+    if (!['never', 'policy'].includes(b.autoMerge)) throw httpError(400, 'Pick Never, or When the line\'s rules allow it.')
+    patch.autoMerge = b.autoMerge === 'policy' ? 'policy' : 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).')
@@ -181,6 +189,7 @@ export const STATIC = {
   '/changes.js': ['changes.js', 'text/javascript; charset=utf-8'],
   '/changes-seen.js': ['changes-seen.js', 'text/javascript; charset=utf-8'],
   '/diffview.js': ['diffview.js', 'text/javascript; charset=utf-8'],
+  '/quiltview.js': ['quiltview.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'],
@@ -193,7 +202,6 @@ export const STATIC = {
   '/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'],
@@ -205,6 +213,8 @@ export const STATIC = {
   '/preview-model.js': ['preview-model.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'],
+  '/seam-model.js': ['seam-model.js', 'text/javascript; charset=utf-8'],
+  '/force-words.js': ['force-words.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'],
   '/sandbox-keys.js': ['sandbox-keys.js', 'text/javascript; charset=utf-8'],
@@ -397,8 +407,20 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
     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))
+  // What the session itself changes (presence, status, access) is sent at most every STATUS_PUSH_MS,
+  // and only to a window that listens: presence alone changes several times a second in a busy room,
+  // and each full status (every task, comment and change) made hundreds of MB a minute of garbage.
+  const pushTimers = new Map()
+  const pushSoon = (id) => {
+    if (pushTimers.has(id) || !runs.has(id)) return
+    const t = setTimeout(() => { pushTimers.delete(id); if (clients.size) pushStatus(id) }, STATUS_PUSH_MS)
+    t.unref?.()
+    pushTimers.set(id, t)
+  }
 
-  async function start ({ mode, dir, tool, invite, prefer, repo, branch, newBranch, base, workspace }) {
+  async function start ({ mode, dir, tool, invite, prefer, workspace }) {
+    // New session from GitHub went in 16's R2: new sessions are quilts (quilt-default.js), and a repository's history comes into Seam by its import.
+    if (mode === 'github') throw httpError(410, GITHUB_GONE)
     const me = profile()
     // Every session signs in to the relay as this computer's account.
     const sessionPasses = accountPasses()
@@ -407,16 +429,6 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
     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'
-    }
-    const toolGuessed = !tool && me.toolGuessed
     tool = tool || me.tool
     prefer = prefer || (me.preferLocal ? 'local' : 'remote')
     if (mode === 'join' && !dir) {
@@ -457,7 +469,6 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
         // The account's name until the first pass names us (the same name, from the API).
         name: me.name,
         tool,
-        toolGuessed,
         color: me.color,
         shareByDefault: me.shareAgent,
         summarizeByDefault: me.summarize,
@@ -471,11 +482,14 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
         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 : '',
+        // A new session is a quilt from the start when the API says so (quilt-default.js).
+        newSession: mode === 'create',
         workspace: workspace || '',
         onLog: log,
         onFatal: async (err) => {
           log(`stopped: ${err.message}`)
-          await stop(id)
+          // Said in the window too (app.js): the relay sent this app away (to update, ended, not let in), or it couldn't go on.
+          await stop(id, err.message)
           // 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')
         }
@@ -495,13 +509,15 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
     }
     runs.set(id, entry)
     const s = entry.run.session
-    s.on('status-changed', () => pushStatus(id))
-    s.on('access', () => pushStatus(id))
+    s.on('status-changed', () => pushSoon(id))
+    s.on('access', () => pushSoon(id))
+    s.on('quilt', () => pushSoon(id))
+    s.on('quilt-shadow', () => pushSoon(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))
+    s.conn.awareness.on('change', () => pushSoon(id))
     // The call (voice.js): who is in it and their call setup, sent only when it changed.
     let voiceWas = ''
     const pushVoice = () => {
@@ -518,7 +534,7 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
     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.
+      // A new session from a folder (New session from GitHub went in 16's R2).
       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)
@@ -537,12 +553,13 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
     return summary(id)
   }
 
-  async function stop (id) {
+  /** `why`: the session stopped by itself (Session 'fatal'), not because someone left it: the window says why. */
+  async function stop (id, why = '') {
     const r = runs.get(id)
     if (!r) return
     runs.delete(id)
     await r.run.stop()
-    broadcast('stopped', { id })
+    broadcast('stopped', { id, ...(why ? { why: String(why).slice(0, 500) } : {}) })
   }
 
   const get = (id) => {
@@ -1032,7 +1049,7 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
     'POST /api/sessions/:id/focus': (b, id) => { get(id).setFocus(b.text); return { ok: true } },
     // Voice (voice.js): the call as this app sees it, and our part in it, from the app window, which does the audio.
     'GET /api/sessions/:id/voice': (b, id) => get(id).voice(),
-    'POST /api/sessions/:id/voice': (b, id) => get(id).setVoice(b.in === false ? null : { muted: b.muted === true, sig: b.sig, transcribing: b.transcribing === true }),
+    'POST /api/sessions/:id/voice': (b, id) => get(id).setVoice(b.in === false ? null : { muted: b.muted === true, sig: b.sig, transcribing: b.transcribing === true, sharing: b.sharing === true }),
     'POST /api/sessions/:id/voice/transcribe': (b, id) => get(id).setVoiceTranscribe(b.on === true),
     'POST /api/sessions/:id/voice/clip': (b, id) => voiceClip(get(id), b),
     'GET /api/sessions/:id/voice/transcript': (b, id, url) => get(id).voiceTranscript({ call: url.searchParams.get('call') || '' }),
@@ -1085,12 +1102,22 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
     '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) => {
+    // In a session linked to a quilt, its History: the live changes, then the patches from Seam's log.
+    'GET /api/sessions/:id/history': async (b, id, url) => {
       const file = String(url.searchParams.get('path') || '')
-      const entries = get(id).history.entries().filter((e) => e.path === file)
+      const s = get(id)
+      const linked = s.quiltLink() ? await s.fileHistory(file) : null
+      if (linked) return { entries: linked.live, patches: linked.patches, quilt: linked.quilt, ...(linked.note ? { note: linked.note } : {}) }
+      const entries = s.history.entries().filter((e) => e.path === file)
       return { entries: queryHistory(entries, { limit: 100 }).reverse() }
     },
+    // A linked session's Blame of a file, one patch of its History, and code search (the relay reads Seam).
+    'GET /api/sessions/:id/blame': (b, id, url) => get(id).quiltBlame(String(url.searchParams.get('path') || '')),
+    'GET /api/sessions/:id/patch': (b, id, url) => get(id).quiltShow(String(url.searchParams.get('commit') || ''), String(url.searchParams.get('path') || '')),
+    'GET /api/sessions/:id/search': (b, id, url) => get(id).quiltSearch(String(url.searchParams.get('q') || '')),
     // Commits pushed or merged elsewhere: fetch and bring them in now (they also come in by themselves).
+    // In a session that moved into Seam: the square panel's Commit and Merge onto main, as this member (control.js seamTool).
+    'POST /api/sessions/:id/seam': (b, id) => squareTool(get(id), b),
     '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'))
@@ -1170,14 +1197,17 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
       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')),
+    // New session from GitHub's lists, gone in 16's R2: an older window that asks is told why.
+    'GET /api/github/status': () => { throw httpError(410, GITHUB_GONE) },
+    'GET /api/github/repos': () => { throw httpError(410, GITHUB_GONE) },
+    'GET /api/github/branches': () => { throw httpError(410, GITHUB_GONE) },
     '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 || ''), { mine: b.mine === true }) } 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) } },
+    // "Make this a quilt" (Seam's plans 16, flag 9): the owner's button. The relay makes the session a quilt and moves it into its squares, as the owner.
+    'POST /api/sessions/:id/quilt-make': async (b, id) => { try { return await get(id).quiltMake(process.env.SEAM_TOKEN || (readAccount() || {}).token) } 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) } },
@@ -1503,6 +1533,28 @@ export function underJoinDir (joinDir, name, message = INVALID_INVITE) {
   return dir
 }
 
+/**
+ * The square panel's buttons (layout 3): seam_commit with a message, or seam_merge (a message for what it
+ * commits first), as this member through Seam's own tools; or open_square, for a folder whose branch has
+ * none (Session.openSquareHere). The answer as { text }, a refusal as a 400.
+ */
+export async function squareTool (s, b) {
+  const tool = String((b && b.tool) || '')
+  if (tool === 'open_square') {
+    if (!s.openSquareHere) throw httpError(409, 'This session\'s code is not in Seam.')
+    try { return { text: (await s.openSquareHere()).text } } catch (err) { throw httpError(400, err.message) }
+  }
+  if (tool !== 'seam_commit' && tool !== 'seam_merge') throw httpError(400, 'The app commits or merges the square, or opens one: seam_commit, seam_merge or open_square.')
+  if (!s.seamTool) throw httpError(409, 'This session\'s code is not in Seam.')
+  const message = b.args && typeof b.args.message === 'string' ? b.args.message.trim().slice(0, 2000) : ''
+  if (tool === 'seam_commit' && !message) throw httpError(400, 'Say what the commit is.')
+  const r = await s.seamTool({ tool, args: message ? { message } : {} })
+  const text = ((r && r.content) || []).map((c) => c.text || '').join('\n').trim()
+  if (r && r.isError) throw httpError(400, text || 'Seam refused.')
+  // Plain words for a person (seam-model.js), not the tool's text an AI reads.
+  return { text: seamResultWords(tool, { structuredContent: r && r.structuredContent, text }) || 'Done.' }
+}
+
 function httpError (status, message) {
   return Object.assign(new Error(message), { status })
 }

package/src/update-check.js

@@ -3,7 +3,31 @@
 // quilt_check_update answers for whatever image the agent names.
 import { currentVersion, latestRelease, compareVersions } from './releases.js'
 
-export const UPDATE_HOW = 'Update Quilt (the desktop app: Settings → About → Update Quilt; the CLI: npm i -g heyquilt, or on a Linux server run its install script again: curl -fsSL https://heyquilt.com/install.sh | sh), then rejoin the session.'
+// How to update each kind of install. Not npm: the heyquilt package there is behind the releases.
+export const UPDATE_STEPS = 'In the desktop app: Settings → About → Update Quilt. On Linux without a desktop: curl -fsSL https://heyquilt.com/install.sh | sh'
+export const UPDATE_HOW = 'Update Quilt (the desktop app: Settings → About → Update Quilt; on Linux without a desktop, run curl -fsSL https://heyquilt.com/install.sh | sh), then rejoin the session.'
+
+/**
+ * What the relay tells an app or CLI too old for a session: only what to do. `version` is the oldest
+ * Quilt the session takes, when there is one. It fits a WebSocket close frame (123 bytes).
+ */
+export const needsUpdateWords = (version = '') => `This session needs ${version ? `Quilt ${version} or later` : 'a newer version of Quilt'}. Update Quilt, then join again.`
+
+const UPDATE_REFUSAL = /\bUpdate Quilt, then join again\./
+
+/** True when a relay's refusal says to update Quilt (needsUpdateWords). */
+export const isUpdateRefusal = (reason) => UPDATE_REFUSAL.test(String(reason || ''))
+
+/**
+ * A refusal to update with how to, for each kind of install. `ascii`: for an HTTP status line, which
+ * older apps read as Latin-1, so an arrow would come out garbled.
+ */
+export function withUpdateSteps (reason, { ascii = false } = {}) {
+  const r = String(reason || '')
+  const head = isUpdateRefusal(r) ? r.slice(0, r.search(UPDATE_REFUSAL)) + 'Update Quilt, then join again.' : r
+  const out = `${head} ${UPDATE_STEPS}`
+  return ascii ? out.replace(/→/g, '>') : out
+}
 
 /** True when `image` looks like a Quilt version. */
 export const validImage = (image) => /^v?\d+\.\d+\.\d+$/.test(String(image || '').trim())

package/src/voice.js

@@ -1,6 +1,6 @@
-// Voice in a session (plans/voice.md). Who is in the call, muted or not, and the call setup
+// Voice in a session (plans/voice.md). Who is in the call, muted or sharing their screen or not, and the call setup
 // (each pair's WebRTC offer and answer) travel in presence, so the relay needs nothing new.
-// The audio itself goes from app window to app window, never through the relay or this
+// The audio (and a shared screen) goes from app window to app window, never through the relay or this
 // process. What people say, when the owner turned transcripts on and they agreed, is kept as
 // lines in the session's document for everyone, agents included, to read.
 import crypto from 'node:crypto'
@@ -50,6 +50,8 @@ export function cleanVoice (raw) {
     call: typeof raw.call === 'string' && CALL.test(raw.call) ? raw.call : '',
     // This person's app sends their speech to the transcript (they agreed, and the owner turned it on).
     ...(raw.transcribing === true ? { transcribing: true } : {}),
+    // This person shares their screen with the call.
+    ...(raw.sharing === true ? { sharing: true } : {}),
     sig
   }
 }
@@ -133,11 +135,14 @@ export function renderLines ({ lines, more, calls }, { tz } = {}) {
 export function voiceView ({ awareness, clientID, members = [], doc }) {
   const me = cleanVoice(awareness.getLocalState()?.voice)
   const peers = []
+  // Everyone in the session now, in voice or not: someone who left voice but not the session hung up.
+  const here = []
   for (const [id, s] of awareness.getStates()) {
     if (id === clientID || !s || !s.name) continue
+    here.push(id)
     const v = cleanVoice(s.voice)
     if (!v) continue
-    peers.push({ id, name: s.name, color: s.color || '', muted: v.muted, since: v.since, call: v.call, ...(v.transcribing ? { transcribing: true } : {}), signal: v.sig[String(clientID)] || null })
+    peers.push({ id, name: s.name, color: s.color || '', muted: v.muted, since: v.since, call: v.call, ...(v.transcribing ? { transcribing: true } : {}), ...(v.sharing ? { sharing: true } : {}), signal: v.sig[String(clientID)] || null })
   }
   peers.sort((a, b) => a.since - b.since || a.id - b.id)
   const t = doc ? transcribeSetting(doc, members) : { on: false }
@@ -149,10 +154,12 @@ export function voiceView ({ awareness, clientID, members = [], doc }) {
     me: clientID,
     in: !!me,
     muted: !!(me && me.muted),
+    sharing: !!(me && me.sharing),
     call,
     since: starts.length ? Math.min(...starts) : 0,
     transcribe: t.on,
     peers,
+    here,
     // The latest lines of the call going on now, as each is written down.
     recent: doc && call ? readLines(doc, { call, limit: RECENT }).lines : [],
     // Every call that has a transcript: when, who spoke, how many lines.
@@ -160,12 +167,12 @@ export function voiceView ({ awareness, clientID, members = [], doc }) {
   }
 }
 
-/** Who is in voice, for status: name -> { muted, transcribing }. */
+/** Who is in voice, for status: name -> { muted, transcribing, sharing }. */
 export function inVoice (awareness, clientID) {
   const out = new Map()
   for (const [id, s] of awareness.getStates()) {
     const v = s && s.name ? cleanVoice(s.voice) : null
-    if (v) out.set(s.name, { muted: v.muted, ...(v.transcribing ? { transcribing: true } : {}), ...(id === clientID ? { me: true } : {}) })
+    if (v) out.set(s.name, { muted: v.muted, ...(v.transcribing ? { transcribing: true } : {}), ...(v.sharing ? { sharing: true } : {}), ...(id === clientID ? { me: true } : {}) })
   }
   return out
 }
@@ -179,6 +186,6 @@ export function voiceStatusLines (people, transcribe) {
   if (!people.length) return []
   return [
     `## In a voice call${transcribe ? ' (transcribed: quilt_voice_transcript reads it)' : ' (not transcribed: ask in chat what was decided)'}`,
-    ...people.map((p) => `- ${p.name}${p.muted ? ' (muted)' : ''}${transcribe && !p.transcribing ? ' (not transcribed)' : ''}`)
+    ...people.map((p) => `- ${p.name}${p.muted ? ' (muted)' : ''}${p.sharing ? ' (sharing their screen)' : ''}${transcribe && !p.transcribing ? ' (not transcribed)' : ''}`)
   ]
 }

package/src/git.js

@@ -1,147 +0,0 @@
-// Git for starting a session from GitHub: checking names, listing repos and
-// branches, cloning. Quilt never commits, pulls or pushes. Wraps the `git`
-// and `gh` CLIs; arguments are always passed as a list, never through a shell.
-import fs from 'node:fs'
-import path from 'node:path'
-import { execFile } from 'node:child_process'
-
-// QUILT_GH lets tests stand in a fake `gh`.
-const GH = () => process.env.QUILT_GH || 'gh'
-const REPO_RE = /^[\w.-]+\/[\w.-]+$/
-// Never stop to ask for a password or open an editor.
-const ENV = { GIT_TERMINAL_PROMPT: '0', GH_PROMPT_DISABLED: '1', GIT_EDITOR: 'true', GH_NO_UPDATE_NOTIFIER: '1' }
-
-/** Runs a command; resolves to stdout, or rejects with a short message from stderr. */
-function run (cmd, args, { cwd, allowFail = false } = {}) {
-  return new Promise((resolve, reject) => {
-    execFile(cmd, args, { cwd, env: { ...process.env, ...ENV }, maxBuffer: 32 * 1024 * 1024, timeout: 5 * 60 * 1000 }, (err, stdout, stderr) => {
-      if (!err) return resolve(stdout)
-      if (allowFail) return resolve(null)
-      if (err.code === 'ENOENT') return reject(new Error(cmd === GH() ? 'The GitHub CLI (gh) is not installed.' : 'git is not installed.'))
-      const e = new Error(shortError(stderr || stdout || err.message))
-      e.stderr = String(stderr || '')
-      e.exitCode = err.code
-      reject(e)
-    })
-  })
-}
-const git = (dir, args, opts) => run('git', args, { cwd: dir, ...opts })
-const gh = (args, opts) => run(GH(), args, opts)
-
-/** The first useful line of a CLI error, without "fatal:"/"error:" noise. */
-function shortError (text) {
-  const lines = String(text).split('\n').map((l) => l.trim()).filter(Boolean)
-  const line = lines.find((l) => /^(fatal|error|remote|GraphQL|HTTP)/i.test(l)) || lines[0] || 'Something went wrong.'
-  return line.replace(/^(fatal|error):\s*/i, '').replace(/^remote:\s*/i, '').slice(0, 300)
-}
-
-/** Throws unless `name` is a valid branch name. */
-export async function checkBranchName (name) {
-  name = String(name || '').trim()
-  if (!name) throw new Error('Enter a branch name.')
-  // Not `--branch`: it expands @{-N} using the current folder's repo, so the
-  // answer would depend on where quilt happens to run.
-  if (name.startsWith('-') || name === 'HEAD' || (await run('git', ['check-ref-format', `refs/heads/${name}`], { allowFail: true })) === null) {
-    throw new Error(`"${name}" isn't a valid branch name.`)
-  }
-  return name
-}
-
-function checkRepo (repo) {
-  repo = String(repo || '').trim()
-  if (!REPO_RE.test(repo) || repo.split('/').some((p) => /^\.+$/.test(p))) throw new Error('Pick a repository (owner/name).')
-  return repo
-}
-
-// --------------------------------------------------------------- GitHub --
-
-/** Is gh installed and signed in? { installed, authenticated, user, message } */
-export async function ghStatus () {
-  const probe = (args) => new Promise((resolve) => {
-    execFile(GH(), args, { env: { ...process.env, ...ENV }, timeout: 20000 }, (err, stdout, stderr) => resolve({ err, text: `${stdout}\n${stderr}` }))
-  })
-  const version = await probe(['--version'])
-  if (version.err && version.err.code === 'ENOENT') return { installed: false, authenticated: false, user: null, message: 'Quilt can\'t list your GitHub repositories on this computer: start from a folder (a clone) instead.' }
-  const out = await probe(['auth', 'status', '--hostname', 'github.com'])
-  if (out.err) return { installed: true, authenticated: false, user: null, message: 'Quilt can\'t list your GitHub repositories on this computer: start from a folder (a clone) instead.' }
-  const user = (out.text.match(/account (\S+)/) || out.text.match(/as (\S+)/) || [])[1] || null
-  return { installed: true, authenticated: true, user, message: null }
-}
-
-/** Your repos, plus your organizations' repos, most recently updated first. */
-export async function listRepos ({ limit = 100 } = {}) {
-  limit = Math.max(1, Math.min(1000, Number(limit) || 100))
-  const fields = ['--json', 'nameWithOwner,description,updatedAt,defaultBranchRef']
-  const parse = (out) => { try { return JSON.parse(out || '[]') } catch { return [] } }
-  const mine = parse(await gh(['repo', 'list', ...fields, '--limit', String(limit)]))
-  const orgs = String(await gh(['api', 'user/orgs', '--jq', '.[].login'], { allowFail: true }) || '').split('\n').filter(Boolean).slice(0, 10)
-  const theirs = await Promise.all(orgs.map((o) => gh(['repo', 'list', o, ...fields, '--limit', String(Math.min(limit, 100))], { allowFail: true }).then(parse)))
-  const seen = new Set()
-  return [...mine, ...theirs.flat()]
-    .filter((r) => r && r.nameWithOwner && !seen.has(r.nameWithOwner) && seen.add(r.nameWithOwner))
-    .sort((a, b) => String(b.updatedAt || '').localeCompare(String(a.updatedAt || '')))
-    .map((r) => ({ name: r.nameWithOwner, description: r.description || '', updatedAt: r.updatedAt || null, defaultBranch: r.defaultBranchRef?.name || null }))
-}
-
-/** Branch names of a GitHub repo, and which one is the default. */
-export async function listBranches (repo) {
-  repo = checkRepo(repo)
-  const [names, def] = await Promise.all([
-    gh(['api', `repos/${repo}/branches`, '--paginate', '--jq', '.[].name']),
-    gh(['api', `repos/${repo}`, '--jq', '.default_branch'])
-  ])
-  const defaultBranch = def.trim() || null
-  const branches = names.split('\n').map((s) => s.trim()).filter(Boolean)
-  // Default branch first, then alphabetical.
-  branches.sort((a, b) => (a === defaultBranch ? -1 : b === defaultBranch ? 1 : a.localeCompare(b)))
-  return { branches, defaultBranch }
-}
-
-async function defaultBranchOf (dir) {
-  const head = await git(dir, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], { allowFail: true })
-  if (head && head.trim()) return head.trim().replace(/^origin\//, '')
-  for (const b of ['main', 'master']) {
-    if ((await git(dir, ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${b}`], { allowFail: true })) !== null) return b
-  }
-  return null
-}
-
-/**
- * Clones `repo` into `dir` (which must be new or empty), then checks out
- * `branch`, or creates `newBranch` from origin/`base` (default: the default branch).
- */
-export async function cloneRepo ({ repo, dir, branch, newBranch, base }) {
-  repo = checkRepo(repo)
-  if (!dir) throw new Error('Choose a folder to clone into.')
-  dir = path.resolve(dir)
-  if (branch) branch = await checkBranchName(branch)
-  if (newBranch) newBranch = await checkBranchName(newBranch)
-  if (base) base = await checkBranchName(base)
-  const existed = fs.existsSync(dir)
-  if (existed && fs.readdirSync(dir).some((f) => f !== '.DS_Store')) {
-    throw new Error(`${path.basename(dir)} already has files in it. Pick an empty or new folder.`)
-  }
-  fs.mkdirSync(path.dirname(dir), { recursive: true })
-  try {
-    await gh(['repo', 'clone', repo, dir])
-    const has = async (b) => (await git(dir, ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${b}`], { allowFail: true })) !== null
-    if (newBranch) {
-      base = base || await defaultBranchOf(dir)
-      if (!base || !(await has(base))) throw new Error(`There's no branch named ${base} on GitHub to start from.`)
-      if (await has(newBranch)) throw new Error(`A branch named ${newBranch} already exists. Use it instead, or pick another name.`)
-      await git(dir, ['checkout', '-q', '--no-track', '-b', newBranch, `origin/${base}`])
-    } else if (branch) {
-      const current = (await git(dir, ['branch', '--show-current'])).trim()
-      if (branch !== current) {
-        if (!(await has(branch))) throw new Error(`There's no branch named ${branch} on GitHub.`)
-        await git(dir, ['checkout', '-q', '-b', branch, '--track', `origin/${branch}`])
-      }
-    }
-    return { dir, branch: (await git(dir, ['branch', '--show-current'])).trim() }
-  } catch (err) {
-    // Only clean up what we made.
-    if (!existed) fs.rmSync(dir, { recursive: true, force: true })
-    else for (const f of fs.readdirSync(dir)) if (f !== '.DS_Store') fs.rmSync(path.join(dir, f), { recursive: true, force: true })
-    throw err
-  }
-}

package/src/quilts/AGENTS.md

@@ -1 +0,0 @@
-The rules for this folder are in `seam/AGENTS.md`: seam is source control for more than Quilt.

package/src/quilts/CLAUDE.md

@@ -1 +0,0 @@
-@../../seam/AGENTS.md