heyquilt 0.3.122 → 0.3.140

package/src/relay-mcp.js

@@ -10,7 +10,6 @@
 // The older link-based server (handleAgentMcp) is kept for relays without sign-in.
 import { authorOf } from './ui/chat.js'
 import { projectRules, renderRules } from './project-rules.js'
-import { cleanGit, branchBoard, branchesMarkdown } from './branches.js'
 import crypto from 'node:crypto'
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
@@ -27,28 +26,25 @@ import { applyTextDiff } from './textdiff.js'
 import { parseInvite } from './ui/invite.js'
 import { scanInbox, renderInbox } from './inbox.js'
 import { withContext, queryConversation, renderConversation, CONVERSATION_DESCRIPTION } from './conversation.js'
-import { cleanFiles, describeCommitRequests, REQUEST_COMMIT_DESCRIPTION, MAX_REQUEST_FILES } from './commit.js'
-import { commitRequestMessage } from './commit-request.js'
-import { GIT_COMMIT_DESCRIPTION, gitCommitSchema, agentPrefix, slug } from './github-commit.js'
-import { liveSyncOn, agentCommitRefusal, ownFiles } from './relay-outbound.js'
-import { syncStatusText, SYNC_STATUS_DESCRIPTION } from './sync-words.js'
-import { clashAction, CLASH_DESCRIPTION, clashSchema } from './relay-clash.js'
-import { agentCommitsOf, repoRecordFor, POLICY_WORDS, pullRequestsFor, mergeForMember, describePulls, describeMerge, PULLS_DESCRIPTION, MERGE_DESCRIPTION, mergeSchema, agentsCanCommit, unpublishedFor, unpublishedRefusal, finishTaskFor, gitCommitFor, describeGitCommit, gitStatusFor, describeGitStatus, gitLogFor, describeGitLog, gitDiffFor, describeGitDiff, GIT_STATUS_DESCRIPTION, GIT_LOG_DESCRIPTION, GIT_DIFF_DESCRIPTION, GIT_REVERT_DESCRIPTION } from './relay-commit.js'
 import { UpdateCheck } from './update-check.js'
 import { TASK_WORKFLOW, pickupBrief, doneRefusal, verifiedEnough, verifiedLine, qaRefusal, qaNotesEnough, qaNotesLine, pickChecklist, MAX_VERIFIED } from './agent-task-workflow.js'
 import { HistoryLog, queryHistory, parseSince, formatHistory, currentTask, lineDiff, legacyTail } from './history.js'
+import { linkedHistory } from './quilt-history.js'
 import { changeRefusal, TALK_REFUSED } from './session-access.js'
 import { MIGRATE_SESSION_DESCRIPTION, describeQuiltPlan } from './session-quilt.js'
 import { chatAbout, renderChatAbout, waitingOn, needsNoReply, renderUnanswered, heldRefusal, queuedFor, renderQueueNotice, renderQueued, answered, unaddressed, CHAT_RULES, RE_HELP, replyFor, renderReplied, PERSON_CHAT, PERSON_INBOX } from './duties.js'
 import { describeSubscription, describeWebhookTest, COALESCE_HELP, WEBHOOK_EVENTS } from './webhooks.js'
 import { registerWorkspaceTools, bytesFetcher, WORKSPACE_GUIDE_HOSTED } from './workspace-tools.js'
 import { DEFAULT_KEY, validBranchKey } from './branchdocs.js'
-import { LOAD_FILES } from './relay-upstream.js'
 import { isDiff, hasEntry, listPaths, readPath, readPaths, textOf, notePresent, removePath, baseOf, gitForSync } from './branch-view.js'
 import { hostedRooms, hostedIn, newHosted } from './hosted-agents.js'
 import { turnSyncStep, ROOM_KEY } from './relay-turn-sync.js'
 import { describeSecretNames, SECRET_NAMES_DESCRIPTION } from './secret-names.js'
-import { quiltOf, seamRefusal, seamNote } from './session-seam.js'
+import { quiltOf, seamRefusal, seamNote, seamStatus, seamFileRefusal, seamToolSpec, runSessionSeamTool, seamOnly, seamWorkflow, SEAM_SESSION_TOOLS, SEAM_GUIDE_HOSTED, GIT_TOOLS } from './session-seam.js'
+import { seamAccess } from './seam-access.js'
+import { releaseInSeam } from './seam-claims.js'
+import { releaseWords } from './release-words.js'
+import { LAYOUT_QUILT } from './session-layout3.js'
 import { TRANSCRIPT_DESCRIPTION, renderLines, readLines, inVoice, transcribeSetting, voiceStatusLines } from './voice.js'
 
 const FEED_CAP = 300
@@ -95,8 +91,6 @@ export const HOSTED_INSTRUCTIONS =
   'Do not edit files someone else has claimed: a refused write tells you who holds the file; ask for it in its file queue with quilt_request_file (a title, and up to 300 characters on what you plan) and carry on with other work: you are woken when it is handed to you. ' +
   'When someone waits in the queue for a file you hold, every answer says so: finish your change, then hand it off with quilt_handoff and your context (what you changed, what is left). You cannot finish a task or release the file before. A claim whose holder does nothing for 20 minutes goes to the next in its queue. ' +
   'Read what people said about a file before you change it: quilt_read_messages, and each write tells you what was said about that file. ' +
-  'On a branch that follows a GitHub repository, what you write stays in a box until you commit it (quilt_git_commit): everyone sees the change, but it is in nobody else\'s folder, so nobody else\'s git can commit it. Committing opens the box by itself; releasing everything does not. ' +
-  'quilt_unpack shares a box early when someone needs it: decide yourself, and ask your person first for a large, risky or critical change or when the project\'s rules say so. A file boxed by someone else (quilt_status lists Boxed work, and quilt_read_file says so) is their unfinished work: do not build on it; ask for it with quilt_request_file. ' +
   'This rule is enforced for agents: while someone who messaged or mentioned you waits for an answer, writes, claims and task changes are refused until you answer with quilt_message. ' +
   PERSON_CHAT + ' ' +
   'Everyone sees your changes on their own disk within moments. ' +
@@ -106,11 +100,7 @@ export const HOSTED_INSTRUCTIONS =
   'You can be in several sessions at once (quilt_join_session each): every tool then takes session: <id> (quilt_session_info lists them; a webhook event or inbox entry says which session it is from), and a call that names none is refused, so an answer never lands in the wrong session. ' +
   'You are connected over HTTP, so you show as online for 30 minutes after each tool call; while idle, people reach you in the way you chose with quilt_wake. ' +
   'HTTP is only for an agent with no computer. If you can run shell commands anywhere (a computer, a cloud machine, a sandbox), you must use the Quilt CLI there instead (`quilt agent join`, then `quilt join <invite> --agent <your name>`): files sync to disk and you show as live. ' +
-  'A session has a branch for each git branch its members work on, each with its own files: quilt_status and quilt_branches list them and who is on each, and your first call on files puts you on the busiest one, where you stay until you pick another with quilt_git_branch (create: true loads a branch that is on GitHub but not yet in the session, at its latest commit; any other new branch starts from a copy of the files you have). ' +
-  'Commits pushed or merged on GitHub come into your branch by themselves: through a member\'s folder on it when one is online and can fetch, otherwise the relay brings them in from GitHub about every 10 minutes. quilt_sync_branch asks for that now (at most once a minute per branch), for example after a PR merged. ' +
-  'When those commits and the session\'s uncommitted work changed the same files, Quilt merges them on its own (where both changed the same lines, the newer edit stays, and whoever wrote the other lines is told): there is never a merge for you to do. ' +
-  'A private repository needs a read-only GitHub token on the relay: when quilt_status says the relay can\'t read it, ask the session owner (quilt_github_token sets it, owner only). You have no folder here, so git is the quilt_git_* tools: taking a task (quilt_move_task to doing) puts you on a branch of your own, quilt/<you>/<task>; quilt_git_commit commits your changed files there and opens the pull request tied to the task; quilt_git_status says where you stand, quilt_git_diff what differs from GitHub, quilt_git_log what was committed, quilt_git_revert puts GitHub\'s version of a file back. The session\'s branch itself is open to agents only when the owner lets agents push to any branch. Work only in the session has not shipped: commit before you move a task to QA. Done merges the task\'s pull request once its checks pass: a person moves it to Done, or you when the owner lets agents commit to any branch. quilt_git_pull_requests lists open pull requests with their checks; quilt_git_merge merges one (agents: when the owner lets agents commit to any branch). When agents may not commit, ask a person with quilt_request_commit. Pushes and merges on GitHub reach the session within seconds. ' +
-  'When a branch syncs with GitHub (quilt_git_status and quilt_branches say so), pushes and merges on GitHub come into the session by themselves, and nothing goes to GitHub until someone commits: quilt_git_commit commits your own changes (with_others: true takes others\' changes in the same files too, as co-authors). A file GitHub and the session both changed is held, and its merger proposes the merge with quilt_clash (the reviewer accepts). Releasing a file only lets go of your claim: it doesn\'t publish anything by itself. ' +
+  'A session has a branch for each branch its members work on, each with its own files: your first call on files puts you on the busiest one. A session in Seam keeps its work in squares: the seam_* tools commit, merge and read history. ' +
   MAIL_GUIDE + ' ' +
   TASK_WORKFLOW
 
@@ -127,21 +117,6 @@ const REMOVED = 'You are no longer in that session. Ask for a new invite and cal
 const NEEDS_ROOM_PASS = 'Reconnecting you to the session. Call the same tool again.'
 
 const id = () => crypto.randomBytes(8).toString('hex')
-const BRING_IN_NOTE = 'Commits pushed or merged elsewhere come into the session by themselves: the folder of a member on that branch fetches about once a minute and brings them in. While no folder on a branch can (none online, or only ones that can\'t fetch, are held or diverged, or are a viewer\'s), the relay brings them in from GitHub itself, about every 10 minutes; quilt_sync_branch asks it to look now.'
-
-/** For a hosted agent: what the relay does about new commits on its branch, and when it last looked; or ''. */
-function relayStatus (room, key) {
-  const rec = room.meta && room.meta.upstreams ? room.meta.upstreams[room.resolveKey ? room.resolveKey(key) : key] : null
-  if (!rec || !rec.repo) return ''
-  const up = rec.name || 'its upstream'
-  if (!rec.checkedAt) return `The relay brings commits from ${up} into \`${key}\` while no folder on it is online; it hasn't looked yet.`
-  const bits = [`The relay last checked ${up} for new commits ${ago(rec.checkedAt)}.`]
-  if (rec.brought && rec.brought.at) bits.push(`It brought in ${rec.brought.count} commit${rec.brought.count === 1 ? '' : 's'} (${rec.brought.files} file${rec.brought.files === 1 ? '' : 's'}) ${ago(rec.brought.at)}.`)
-  if (rec.clash) bits.push(`Its clash with ${up} is task ${rec.clash.task} on the board.`)
-  if (rec.problem) bits.push(`Note: ${rec.problem}.`)
-  return bits.join(' ')
-}
-
 /** The chat `me` can see: public messages, and direct ones to or from them. */
 const chatFor = (doc, me) => doc.getArray('chat').toArray().filter((m) => m && m.id && (!m.to || m.to === me || m.by === me))
 
@@ -154,10 +129,17 @@ function takeStock (doc, me) {
 const linkInboxes = new WeakMap()
 const text = (t) => ({ content: [{ type: 'text', text: t }] })
 const fail = (t) => ({ content: [{ type: 'text', text: t }], isError: true })
+// A session that is a quilt, by its quilt's name (its slug; its id before the relay knows one), or null.
+const quiltName = (room) => { const q = quiltOf(room.meta); return q ? ((room.meta.quilt && room.meta.quilt.slug) || q) : null }
 // quilt_status in a session that is a quilt starts with how work goes there (session-seam.js).
+// Any other answer, the first in a session that is a quilt for this agent: its instructions may be from before the move.
+const withSeamLead = (r, quilt) => {
+  if (r && typeof r.then === 'function') return r.then((x) => withSeamLead(x, quilt))
+  return r && Array.isArray(r.content) ? { ...r, content: [{ type: 'text', text: `🧵 ${seamNote(quilt, { hosted: true })} This is how work lands here, whatever your instructions said before.` }, ...r.content] } : r
+}
 const withSeamNote = (r, quilt) => {
   if (r && typeof r.then === 'function') return r.then((x) => withSeamNote(x, quilt))
-  return r && Array.isArray(r.content) ? { ...r, content: [{ type: 'text', text: seamNote(quilt) }, ...r.content] } : r
+  return r && Array.isArray(r.content) ? { ...r, content: [{ type: 'text', text: seamNote(quilt, { hosted: true }) }, ...r.content.map((c) => c && c.type === 'text' ? { ...c, text: seamStatus(c.text) } : c)] } : r
 }
 
 function ago (ts) {
@@ -193,29 +175,11 @@ function sessionTools (server, ctx) {
   }
   // Files, claims and history are a branch's: the agent's own (hosted agents can choose one), or the session's active branch.
   const branchOf = (room) => ctx.branch ? ctx.branch(room) : room.activeBranch ? room.activeBranch() : null
-  /**
-   * An agent without a folder taking a task goes onto a branch of its own for it (quilt/<agent>/<task>,
-   * a copy of the default branch's files), as a folder agent's checkout does. Stays on a branch of its own
-   * that still has an open task; nothing when agents may not commit, or this relay has no branch documents.
-   */
-  const branchForHostedTask = (room, task) => {
-    if (ctx.kind !== 'agent' || !ctx.setBranch || !task || !task.title || room.meta.layout !== 2) return null
-    if (!agentsCanCommit(room, room.defaultKey)) return null
-    const prefix = agentPrefix(me)
-    const here = branchOf(room) || room.defaultKey
-    if (here.startsWith(prefix) && readTasks(room.doc.getMap('tasks')).some((t) => t && !t.archived && t.column !== 'done' && t.pr && t.pr.branch === here)) return null
-    let name = `${prefix}${slug(task.title)}`
-    for (let n = 2; room.meta.branches[room.resolveKey(name)] && n < 50; n++) name = `${prefix}${slug(task.title)}-${n}`
-    try {
-      if (here !== room.defaultKey) ctx.setBranch(room, room.defaultKey, {})
-      ctx.setBranch(room, name, { create: true, by: me, editor: true })
-      return name
-    } catch { return null }
-  }
   // The branch document the agent works on (its store entry), or null for a room without branch documents.
   // The session's default branch may always start; any other new branch only for someone who may change files.
   const branchEntry = (room) => {
-    if (!room.branchDoc) return null
+    // At layout 3 there are no branch documents to work on: every tool but the file tools works on the room.
+    if (!room.branchDoc || room.meta.layout === LAYOUT_QUILT) return null
     const key = branchOf(room)
     const editor = room.resolveKey(key) === room.defaultKey || ctx.access(room)?.role !== 'viewer'
     return room.branchDoc(key, { by: me, editor })
@@ -224,13 +188,16 @@ function sessionTools (server, ctx) {
     // Hosted agents are in several sessions at once: `session` says which this call is about.
     const { session, ...args } = given || {}
     return stale(await ctx.withSession((room) => {
-    // A hosted agent with no branch of its own is pinned to the active branch by its first call
-    // on files, so a read and the write after it never land on two different branches.
-    if (ctx.pin && FILE_TOOLS.has(name)) ctx.pin(room)
     // A session that is a quilt has no GitHub path for agents: each GitHub tool names its Seam tool.
-    const quilt = quiltOf(room.meta)
-    const refused = seamRefusal(name, quilt)
+    // At layout 3 its files are in squares, not branches: the file tools name Seam's (quilt_history reads Seam's log, quilt_project_rules main's rules).
+    const quilt = quiltName(room)
+    // quilt_release lets go of the agent's claims in Seam then (seam-claims.js), when it reaches Seam.
+    const seamRelease = name === 'quilt_release' && !!(ctx.seam && ctx.seam())
+    const refused = seamRefusal(name, quilt, { hosted: true }) || (quilt && room.meta.layout === LAYOUT_QUILT && FILE_TOOLS.has(name) && name !== 'quilt_history' && name !== 'quilt_project_rules' && !seamRelease ? seamFileRefusal(quilt) : null)
     if (refused) return fail(refused)
+    // A hosted agent with no branch of its own is pinned to the active branch by its first call
+    // on files, so a read and the write after it never land on two different branches.
+    if (ctx.pin && FILE_TOOLS.has(name) && room.meta.layout !== LAYOUT_QUILT) ctx.pin(room)
     // The audit trail: which tool, on what (a path, a pattern or a task id; never contents).
     const caller = ctx.who(room)
     if (caller && caller.id && room.audit) {
@@ -247,7 +214,9 @@ function sessionTools (server, ctx) {
     room.auditAs = caller && caller.id
     try {
       const r = queueNote(room, fn(args || {}, parts))
-      return name === 'quilt_status' && quilt ? withSeamNote(r, quilt) : r
+      // The first answer in a session that is a quilt says how work lands there (quilt_status always does).
+      const once = quilt && ctx.seamOnce ? ctx.seamOnce(room) : false
+      return name === 'quilt_status' && quilt ? withSeamNote(r, quilt) : once ? withSeamLead(r, quilt) : r
     } finally { room.auditAs = prev }
     }, session))
   })
@@ -274,13 +243,6 @@ function sessionTools (server, ctx) {
     for (const h of room.hostedOnline ? room.hostedOnline() : []) if (h.name !== me && !out.some((p) => p.name === h.name)) out.push({ name: h.name, kind: h.kind, tool: 'hosted', hosted: true })
     return out
   }
-  // Each member's folder tells the room its git (branch, upstream, the repository's branches): one list.
-  const branchesOf = (room) => {
-    const members = []
-    for (const st of room.awareness.getStates().values()) if (st && st.name && st.git) members.push({ name: st.name, git: cleanGit(st.git) })
-    for (const p of peers(room)) if (p.persona) members.push({ name: p.name, git: null, persona: true })
-    return branchBoard(members, room.branchList ? room.branchList() : [])
-  }
   // Claims as people see them: an older app's AI session ("Dana · login", of: Dana) is its person.
   const claimsOf = (room) => (room.claimList ? room.claimList(branchOf(room)) : []).map((c) => (c.of || (c.queue || []).some((r) => r && r.of) ? { ...c, by: c.of || c.by, queue: (c.queue || []).map((r) => (r && r.of ? { ...r, by: r.of } : r)) } : c))
   // Claims are per branch: who the agent is, on the branch it works on.
@@ -312,7 +274,8 @@ function sessionTools (server, ctx) {
   // Claims follow this agent's writes: a file it changes that nobody holds is claimed for it, and let
   // go when it hasn't written the file for a while (it has no end of turn Quilt can see).
   const autoHeld = new Map() // `${roomId}\0${rel}` -> timer
-  const boxable = (room, branch) => !!(room.meta && repoRecordFor(room, branch || room.defaultKey))
+  // Boxes opened when a commit to the branch's repository landed: no session commits to git now.
+  const boxable = () => false
   const roomKey = (room) => `${room.id || room.name || ''}\0${branchOf(room)}` // claims held per branch
   const autoClaim = (room, rel) => {
     const key = `${roomKey(room)}\0${rel}`
@@ -356,11 +319,18 @@ function sessionTools (server, ctx) {
       with_diff: z.boolean().optional().describe('Include each change\'s diff (capped per change)'),
       limit: z.number().int().min(1).max(200).optional().describe('How many of the newest matching changes (default 30)')
     }
-  }, ({ path: p, by, since, task, with_diff, limit }, { room }) => {
+  }, async ({ path: p, by, since, task, with_diff, limit }, { room }) => {
     const from = parseSince(since)
     if (from === undefined) return fail('since: use a duration like 2h or 3d, "today", "yesterday", or a date.')
     const q = process.env.QUILT_SOURCE_URL && room.meta && room.meta.quilt_id ? room.meta.quilt : null
-    const list = queryHistory(legacyTail(historyOf(room).entries(), { at: q && q.at }), { path: p ? cleanPath(p) : '', by, since: from ?? undefined, task, limit: limit || 30 })
+    const own = legacyTail(historyOf(room).entries(), { at: q && q.at, history: !!(q && q.history) })
+    // Linked to a quilt (16: the session became one, or shadows one in step 1): Seam's log plus this record.
+    const link = room.quiltHistoryLink ? room.quiltHistoryLink() : null
+    if (link) {
+      const r = await linkedHistory({ seam: link.seam, quilt: link.quilt, entries: own, query: { path: p ? cleanPath(p) : '', by, since: from ?? undefined, task, limit: limit || 30, withDiff: !!with_diff } })
+      return text(`${formatHistory(r.list, { withDiff: !!with_diff })}${r.note ? `\n\n${r.note}` : ''}`)
+    }
+    const list = queryHistory(own, { path: p ? cleanPath(p) : '', by, since: from ?? undefined, task, limit: limit || 30 })
     return text(formatHistory(list, { withDiff: !!with_diff }))
   })
 
@@ -393,42 +363,19 @@ function sessionTools (server, ctx) {
     if (away.length) lines.push('', '## Away (agents that work in turns, between turns: they read what you write at their next turn)', ...away.map((m) => `- ${m.name} (agent) · last here ${ago(m.lastSeen)}`))
     const all = claimsOf(room)
     const bxs = all.filter((c) => c.box)
-    if (bxs.length) lines.push('', '## Boxed work', ...bxs.map((c) => `- ${c.pattern}: ${c.by === me ? 'your unfinished work, in nobody else\'s folder until you commit it (quilt_git_commit) or quilt_unpack it' : `${c.by}'s unfinished work: not in anyone else's folder until they commit or unpack it`}`))
+    if (bxs.length) lines.push('', '## Boxed work', ...bxs.map((c) => `- ${c.pattern}: ${c.by === me ? 'your unfinished work, in nobody else\'s folder until you commit it or quilt_unpack it' : `${c.by}'s unfinished work: not in anyone else's folder until they commit or unpack it`}`))
     const cl = all.filter((c) => !c.box)
     lines.push('', '## Claimed files', ...(cl.length ? cl.map((c) => `- ${c.pattern} by ${c.by}${c.note ? ` (${c.note})` : ''}${c.queue.length ? ` · waiting: ${c.queue.map((r) => `${r.by} ("${r.title}")`).join(', ')}` : ''}`) : ['- None.']))
     const acts = activity.toArray().filter(Boolean).slice(-12).reverse()
     lines.push('', '## Recent file changes', ...(acts.length ? acts.map((x) => x.kind === 'pulled' ? `- ${x.by} pulled ${x.detail || 'commits'} (${ago(x.ts)})` : x.kind === 'brought' ? `- ${x.by} brought in ${x.detail || 'commits'}${x.branch ? ` on ${x.branch}` : ''} (${ago(x.ts)})` : x.kind === 'switched' ? `- ${x.by} switched to ${x.branch} (${ago(x.ts)})` : `- ${x.by} ${x.kind} ${x.path} (${ago(x.ts)})`) : ['- None yet.']))
     const msgs = chat.toArray().filter(visible).slice(-8)
     lines.push('', '## Recent messages', ...(msgs.length ? msgs.map(fmtMsg) : ['- None.']))
-    const asked = [...doc.getMap('commitRequests').values()].filter((r) => r && r.id && r.state === 'open').sort((x, y) => x.ts - y.ts)
-    if (asked.length) lines.push('', '## Commit requests', ...asked.map((r) => `- [${r.id}] ${r.by === me ? 'you' : r.by} (${ago(r.ts)}): ${r.message}${Array.isArray(r.files) ? ` (${r.files.length} files)` : ''}${r.error ? `. Last try: ${r.error}` : ''}`))
     lines.push('', '## Tasks', taskMarkdown(readTasks(doc.getMap('tasks')), me, { tool: ctx.tool(), asAi: false, mentionYours: true }))
-    const br = branchesOf(room)
-    if (br.length) {
-      lines.push('', '## Branches', branchesMarkdown(br, { limit: 6, mine: branchOf(room) }))
-      if (ctx.branch) lines.push('Work on another branch with quilt_git_branch.')
-      // Hosted agents learn when the relay last looked for new commits on their branch (relay-upstream.js).
-      const said = relayStatus(room, branchOf(room))
-      if (said) lines.push(said)
-    }
     if (ctx.webhook) { const w = ctx.webhook.get(); lines.push('', w ? (w.email ? 'Quilt wakes you by email (quilt_wake changes it).' : `Webhook: Quilt POSTs to ${w.url} on ${w.events.join(', ')}.`) : 'No webhook or email wake: choose how Quilt wakes you with quilt_wake.') }
     return text(lines.join('\n') + ctx.warn(room))
   })
 
-  tool('quilt_sync_status', {
-    description: SYNC_STATUS_DESCRIPTION,
-    inputSchema: {}
-  }, (_, { room, branch }) => text(syncStatusText(room.branchList ? room.branchList() : [], { mine: branch ? branch.key : '' })))
-
-  tool('quilt_branches', {
-    description: 'The session\'s git branches: which branch each member\'s folder is on, which AI sessions and worktrees work on which branch, how each stands against its upstream (behind, ahead, diverged), and who committed last.',
-    inputSchema: {}
-  }, (_, { room }) => {
-    const br = branchesOf(room)
-    return text(`${branchesMarkdown(br, { limit: 40 })}\n\n${BRING_IN_NOTE}`)
-  })
-
-  // Seam (plans/quilt-source-control/16), behind QUILT_SOURCE_URL: what making this session a
+  // Seam (Seam's plans/quilt-source-control/16), behind QUILT_SOURCE_URL: what making this session a
   // quilt would do. Only the dry run: the move itself is the owner's, from the app.
   if (process.env.QUILT_SOURCE_URL) {
     tool('quilt_migrate_session', {
@@ -490,6 +437,8 @@ function sessionTools (server, ctx) {
     : pickChecklist(files.get('AGENTS.md')?.toString(), files.get('CLAUDE.md')?.toString())
   /** The project's rules (project-rules.js) on the agent's branch, a diff branch's from git where the session left them. */
   const rulesFor = async (room, branch, files) => {
+    // In squares (layout 3): main's rules on Seam, read with the room's read token (the branch documents are as they were at the move).
+    if (room.meta.layout === LAYOUT_QUILT && quiltOf(room.meta)) return rulesOnSeam(room)
     if (!branch || !isDiff(branch)) return projectRules({ list: [...files.keys()], read: (p) => files.get(p)?.toString() ?? null })
     const list = [...(await listPaths(room, branch.key, branch)).keys()]
     const got = new Map()
@@ -502,6 +451,20 @@ function sessionTools (server, ctx) {
     }
     return projectRules({ list, read: (p) => got.get(p) ?? null })
   }
+  const rulesOnSeam = async (room) => {
+    const seam = room.quiltReadClient ? room.quiltReadClient() : null
+    if (!seam) throw new Error(`The session has no read token for ${quiltName(room)}, so its rules can't be read here: its owner links it to Seam again. Meanwhile read AGENTS.md with seam_cat.`)
+    const q = room.meta.quilt_id
+    const list = ((await seam.tree(q, 'main')).entries || []).filter((e) => e && e.path && e.mode !== 'dir').map((e) => e.path)
+    const got = new Map()
+    for (let round = 0; round < 4; round++) {
+      const asked = new Set()
+      const r = projectRules({ list, read: (p) => { if (got.has(p)) return got.get(p); asked.add(p); return null } })
+      if (!asked.size) return r
+      for (const p of asked) got.set(p, await seam.cat(q, 'main', p).then((x) => Buffer.from(x.content || '', 'base64').toString('utf8'), () => null))
+    }
+    return projectRules({ list, read: (p) => got.get(p) ?? null })
+  }
   tool('quilt_move_task', {
     description: 'Move a task on the shared board. "doing" when you start it: you get a briefing (its files, recent changes to them, claims, the project\'s checks). ' +
       '"qa" when you finish implementing and testing: requires `qaNotes` (what changed and how you self-validated); without it the move is refused. ' +
@@ -514,11 +477,6 @@ function sessionTools (server, ctx) {
     }
   }, async ({ id, column, qaNotes, verified }, { room, doc, files, branch }) => {
     { const w = waitRefusal(doc, 'quilt_move_task', room); if (w) return fail(w) }
-    // An agent's finished work goes to git before QA, when it can commit itself (relay-commit.js); Done merges the task's pull request.
-    if (column === 'qa' && ctx.kind === 'agent' && !Object.values(room.meta && room.meta.upstreams || {}).some((rec) => rec && rec.clash && rec.clash.task === id)) {
-      const u = await unpublishedFor(room, { key: branch ? branch.key : DEFAULT_KEY, who: me, task: id, column }, { fetch: room.githubFetch })
-      if (u.unpublished.length) return fail(unpublishedRefusal(readTasks(taskMap(doc)).find((t) => t.id === id), u.unpublished, column, []))
-    }
     const err = writable(room)
     if (err) return fail(err)
     try {
@@ -527,11 +485,6 @@ function sessionTools (server, ctx) {
       if (column === 'qa' && !qaNotesEnough(qaNotes)) return fail(qaRefusal({ task: cur, checklist: await checklistOf(files, room, branch) }))
       if (column === 'done' && !verifiedEnough(verified)) return fail(doneRefusal({ task: cur, checklist: await checklistOf(files, room, branch) }))
       { const q = (column === 'done' || column === 'qa') && renderQueued(queuedFor(claimsOf(room), me), 'move the task again'); if (q) return fail(q) }
-      let merged = null
-      if (column === 'done' && cur.column !== 'done') {
-        const f = await finishTaskFor(room, { who: { name: me, kind: ctx.kind || 'human', access: ctx.access(room) }, key: branch ? branch.key : DEFAULT_KEY, task: id }, { fetch: room.githubFetch })
-        merged = f.merged
-      }
       const patch = { id, column }
       if (column === 'qa') patch.qaNotes = qaNotes
       if (column === 'done') patch.verified = verified
@@ -541,11 +494,11 @@ function sessionTools (server, ctx) {
         const all = historyOf(room).entries()
         const history = (tf.length ? all.filter((e) => tf.includes(e.path)) : all).slice(-8)
         const claims = claimsOf(room).filter((c) => !tf.length || tf.some((f) => globMatcher(c.pattern)(f)))
-        const onto = branchForHostedTask(room, task)
-        return text(pickupBrief({ task: { ...task, comments: readComments(doc.getMap('taskComments'), task.id) }, history, claims, checklist: await checklistOf(files, room, branchEntry(room)), me }) + (onto ? `\nYou are on ${onto} now (Quilt made it for this task, a copy of ${room.defaultKey}'s files): write your files here and quilt_git_commit them; the pull request opens by itself. Move the task to QA when it is done and tested.` : ''))
+        if (quiltOf(room.meta)) return text(pickupBrief({ task: { ...task, comments: readComments(doc.getMap('taskComments'), task.id) }, history, claims, checklist: await checklistOf(files, room, null), me, workflow: seamWorkflow(TASK_WORKFLOW, { hosted: true }) }))
+        return text(pickupBrief({ task: { ...task, comments: readComments(doc.getMap('taskComments'), task.id) }, history, claims, checklist: await checklistOf(files, room, branchEntry(room)), me }))
       }
       if (column === 'qa') return text(`Moved "${task.title}" to QA. Notes: ${qaNotesLine(task)}`)
-      if (column === 'done') return text(`Moved "${task.title}" to Done.${merged ? ` Merged pull request #${merged.number} (${merged.head} → ${merged.base}) as ${String(merged.sha).slice(0, 7)}.` : ''} Verified: ${verifiedLine(task)}`)
+      if (column === 'done') return text(`Moved "${task.title}" to Done. Verified: ${verifiedLine(task)}`)
       return text(`Moved "${task.title}" to ${columnName(task.column)}.`)
     } catch (e) { return fail(e.message) }
   })
@@ -797,247 +750,6 @@ function sessionTools (server, ctx) {
     return text(msgs.length ? msgs.map(fmtMsg).join('\n') : 'No messages yet.')
   })
 
-  // ------------------------------------------------------ commit timing --
-  // The same requests as a folder's quilt_request_commit (Session.requestCommit): a message to
-  // whoever commits, so viewers and members who may not post are refused.
-  const commitMap = (doc) => doc.getMap('commitRequests')
-  const commitState = (room, doc) => {
-    const busy = []
-    for (const st of room.awareness.getStates().values()) {
-      if (!st || !st.name || st.name === me) continue
-      const a = st.agent
-      if (a && a.sharing !== false && a.status === 'working') busy.push(`${st.name}'s ${a.tool || 'AI'} is working`)
-      else if (st.work && st.work.state === 'working') busy.push(`${st.name} is working${st.work.note ? `: ${String(st.work.note).slice(0, 200)}` : ''}`)
-    }
-    const requests = [...commitMap(doc).values()].filter((r) => r && r.id).sort((a, b) => a.ts - b.ts)
-    return { busy, open: requests.filter((r) => r.state === 'open'), recent: requests.filter((r) => r.state === 'done').slice(-5) }
-  }
-  const describeCommits = (c) => [
-    c.busy.length ? `⏳ Still working: ${c.busy.join('; ')}` : '✅ Everyone else\'s AI is idle: a good moment to commit.',
-    describeCommitRequests(c)
-  ].join('\n')
-
-  tool('quilt_request_commit', {
-    description: REQUEST_COMMIT_DESCRIPTION,
-    inputSchema: {
-      message: z.string().max(500).optional().describe('The commit message: what the change does (a task\'s title by default)'),
-      files: z.array(z.string().max(1024)).max(500).optional().describe('The files you changed, relative to the project\'s top folder (deleted ones too)'),
-      task: z.string().max(40).optional().describe('The task this work was for: its title is the message and its changes the files, unless you give them')
-    }
-  }, ({ message, files, task }, { room, doc, fdoc }) => {
-    { const w = waitRefusal(doc, 'quilt_request_commit', room); if (w) return fail(w) }
-    const err = writable(room)
-    if (err) return fail(err)
-    const a = ctx.access(room)
-    if (a && a.role === 'viewer') return fail('Viewers can\'t ask for commits.')
-    if (ctx.kind === 'agent' && agentsCanCommit(room, branchOf(room) || DEFAULT_KEY)) return fail('Commit it yourself: quilt_git_commit (the files you changed and a message) commits them to the branch you are on, with nobody else needed; on a branch of your own the pull request opens by itself. Asking a person is for when agents may not commit here.')
-    if (a && a.talk === false) return fail(TALK_REFUSED)
-    const t = task ? readTasks(taskMap(doc)).find((x) => x.id === String(task)) : null
-    if (task && !t) return fail(`No task ${task} on the board.`)
-    const msg = String(message || (t ? t.title : '')).trim().slice(0, 500)
-    if (!msg) return fail('Say what the commit is for.')
-    let list = cleanFiles(files || [])
-    if (files && files.length && !list.length) return fail('None of those are files in the project (give paths relative to its top folder).')
-    if (!list.length) {
-      // What was changed for the task, or by this agent, on record in the branch's history.
-      for (const e of fdoc.getArray('history').toArray()) {
-        if (!e || e.pulled || typeof e.path !== 'string') continue
-        if (t ? e.task && e.task.id === t.id : e.by === me) { if (!list.includes(e.path)) list.push(e.path) }
-      }
-      if (t) for (const f of t.files || []) if (!list.includes(f)) list.push(f)
-      list = cleanFiles(list.slice(-MAX_REQUEST_FILES))
-    }
-    if (!list.length) return fail(t ? `Task ${t.id} has no changed files on record: give them in files.` : 'Quilt has no changes of yours on record: give the files in files.')
-    const key = branchOf(room)
-    const r = { id: crypto.randomBytes(6).toString('hex'), by: me, message: msg, ...(key ? { branch: key } : {}), ts: Date.now(), state: 'open', files: list, ...(t ? { task: { id: t.id, title: t.title } } : {}) }
-    // The session owner is told with a direct message, as from a folder (commit-request.js).
-    const note = commitRequestMessage(r, { owner: room.meta && room.meta.ownerName, id: id(), defaultBranch: DEFAULT_KEY })
-    doc.transact(() => {
-      const map = commitMap(doc)
-      map.set(r.id, r)
-      if (note) {
-        const chat = doc.getArray('chat')
-        chat.push([note])
-        if (chat.length > 500) chat.delete(0, chat.length - 500)
-      }
-      const done = [...map.values()].filter((x) => x && x.state === 'done').sort((x, y) => x.ts - y.ts)
-      for (const x of done.slice(0, Math.max(0, done.length - 100))) map.delete(x.id)
-    }, AGENT)
-    return text(`Asked for a commit [${r.id}] of ${list.length} file${list.length === 1 ? '' : 's'}: ${list.slice(0, 12).join(', ')}${list.length > 12 ? ', …' : ''}. ` +
-      'A person with git on this branch commits it from their Quilt; you are told the commit when it is made.')
-  })
-
-  if (ctx.kind) {
-    // Git, for an agent with no folder: the quilt_git_* tools work on the branch the agent is on (its branch document).
-    const whoAmI = (room) => ({ name: me, kind: ctx.kind, access: ctx.access(room) })
-    const keyOf = (branch) => branch ? branch.key : DEFAULT_KEY
-
-    tool('quilt_git_commit', {
-      description: GIT_COMMIT_DESCRIPTION,
-      inputSchema: gitCommitSchema(z)
-    }, async (args, { room, doc, branch }) => {
-      { const w = waitRefusal(doc, 'quilt_git_commit', room); if (w) return fail(w) }
-      // A branch that syncs with GitHub through the relay's mirror: your own changes (or the files named, or the task's)
-      // become one commit now, pushed forward only. Others' changes in those files go in only with with_others.
-      // An agent the owner's policy keeps off this branch commits to a branch of its own instead (below, with its pull request).
-      if (room.outbound && liveSyncOn(room, keyOf(branch)) && !(ctx.kind === 'agent' && agentCommitRefusal(room, keyOf(branch), me))) {
-        const key = keyOf(branch)
-        const own = ownFiles(room, key, { who: me, files: args.files, task: args.task })
-        if (own.refused) return fail(own.refused)
-        const t = args.task ? room.doc.getMap('tasks').get(String(args.task)) : null
-        const message = String(args.message || (t && t.title) || '').trim().slice(0, 2000)
-        if (!message) return fail('Say what the commit does (message).')
-        const r = await room.outbound.flush(key, { message, by: me, only: own.list, own: { who: me, withOthers: args.with_others === true } })
-        if (r.state === 'others') return fail(`These files also hold changes by others that are not in git yet: ${[...r.others].map(([rel, names]) => `${rel} (${names.join(', ')})`).join('; ')}. Leave them out (files), ask those people to commit first, or commit them together with with_others: true (they are named as co-authors).`)
-        const rec = (room.meta.upstreams || {})[key] || {}
-        if (r.state === 'pushed') return text(`Pushed ${r.sha.slice(0, 7)} to ${rec.repo || 'GitHub'} ${rec.ref || key}: "${r.subject}" (${r.changed.length} file${r.changed.length === 1 ? '' : 's'}: ${r.changed.slice(0, 10).join(', ')}${r.changed.length > 10 ? ', …' : ''})${r.live ? `, through pull request work on ${r.live}` : ''}.`)
-        if (r.state === 'nothing') return text(`Nothing to commit: ${own.list.length === 1 ? own.list[0] : 'those files'} on ${key} ${own.list.length === 1 ? 'is' : 'are'} already on GitHub as the session has ${own.list.length === 1 ? 'it' : 'them'}${r.skipped && r.skipped.claimed.length ? ` (held by someone: ${r.skipped.claimed.join(', ')})` : ''}.`)
-        if (r.state === 'paused') return fail(`GitHub can't take the commit right now (${rec.problem || r.why}): Quilt keeps it and makes it when GitHub answers.`)
-        if (r.state === 'protected') return fail(`${rec.ref || key} is protected on GitHub: ${r.why}`)
-        if (r.state === 'refused') return fail(`Not committed: ${r.why}.`)
-        return fail(`Could not push ${key} right now (${r.state}${r.why ? `: ${r.why}` : ''}): try quilt_git_commit again in a moment.`)
-      }
-      if (!room.commitFor) return fail('This relay can\'t commit yet.')
-      try {
-        const r = await gitCommitFor(room, { who: whoAmI(room), key: keyOf(branch), message: args.message, files: args.files, task: args.task, withOthers: args.with_others === true }, { fetch: room.githubFetch, log: room.log || (() => {}) })
-        return text(describeGitCommit(r, { policy: agentCommitsOf(room) }))
-      } catch (err) { return fail(err.message) }
-    })
-
-    tool('quilt_clash', {
-      description: CLASH_DESCRIPTION,
-      inputSchema: clashSchema(z)
-    }, async (args, { room, branch }) => {
-      try {
-        const r = await clashAction(room, { who: { name: me, kind: ctx.kind === 'agent' ? 'agent' : 'human', access: ctx.access(room) }, key: keyOf(branch), action: args.action, path: args.path || '', content: args.content ?? null, checks: args.checks || null, force: args.force === true })
-        return r.ok ? text(r.text) : fail(r.text)
-      } catch (err) { return fail(err.message) }
-    })
-
-    tool('quilt_git_status', {
-      description: GIT_STATUS_DESCRIPTION,
-      inputSchema: {}
-    }, async (_, { room, branch }) => {
-      try { return text(describeGitStatus(await gitStatusFor(room, { who: whoAmI(room), key: keyOf(branch) }, { fetch: room.githubFetch }))) } catch (err) { return fail(err.message) }
-    })
-
-    tool('quilt_git_log', {
-      description: GIT_LOG_DESCRIPTION,
-      inputSchema: { n: z.number().int().min(1).max(50).optional().describe('How many commits (default 10)') }
-    }, async ({ n }, { room, branch }) => {
-      try { return text(describeGitLog(await gitLogFor(room, { key: keyOf(branch), n: n || 10 }, { fetch: room.githubFetch }))) } catch (err) { return fail(err.message) }
-    })
-
-    tool('quilt_git_diff', {
-      description: GIT_DIFF_DESCRIPTION,
-      inputSchema: { files: z.array(z.string().min(1).max(500)).max(20).optional().describe('The files to compare; default: your uncommitted changes') }
-    }, async ({ files: list }, { room, branch }) => {
-      try { return text(describeGitDiff(await gitDiffFor(room, { who: whoAmI(room), key: keyOf(branch), files: list }, { fetch: room.githubFetch, lineDiff }))) } catch (err) { return fail(err.message) }
-    })
-
-    tool('quilt_git_revert', {
-      description: GIT_REVERT_DESCRIPTION,
-      inputSchema: { files: z.array(z.string().min(1).max(500)).min(1).max(20).describe('The files to put back as GitHub has them') }
-    }, async ({ files: list }, { room, doc, fdoc, branch, files, blobs, activity }) => {
-      { const w = waitRefusal(doc, 'quilt_git_revert', room); if (w) return fail(w) }
-      const err = writable(room) || branchWritable(room, branch)
-      if (err) return fail(err)
-      const a = ctx.access(room)
-      if (a && a.role === 'viewer') return fail('You can only view this session; file changes are refused.')
-      try {
-        const d = await gitDiffFor(room, { who: whoAmI(room), key: keyOf(branch), files: list }, { fetch: room.githubFetch, lineDiff })
-        const { githubRepoOf, credentialsFor } = await import('./relay-commit.js')
-        const { githubWriter } = await import('./github-commit.js')
-        const { repo } = githubRepoOf(room, keyOf(branch))
-        const gh = githubWriter({ fetch: room.githubFetch, token: await credentialsFor(room, repo), owner: repo.owner, name: repo.name })
-        const done = []; const skipped = []
-        for (const f of d.files) {
-          const rel = cleanPath(f.path)
-          if (f.note === 'same') { skipped.push(`${rel} (already as on GitHub)`); continue }
-          if (f.note) { skipped.push(`${rel} (${f.note})`); continue }
-          const refusal = a && changeRefusal(a, rel)
-          if (refusal) { skipped.push(`${rel} (${refusal})`); continue }
-          const claim = claimsOf(room).find((c) => c.by !== me && globMatcher(c.pattern)(rel))
-          if (claim) { skipped.push(`${rel} (held by ${claim.by})`); continue }
-          const was = d.head ? await gh.content(d.head, rel) : null
-          const diff = branch && isDiff(branch)
-          let fromGit = null
-          if (diff && !hasEntry(branch, rel) && !branch.gone.has(rel)) { const r = await readPath(room, branch.key, branch, rel); fromGit = r.kind === 'text' ? r.text : null }
-          fdoc.transact(() => doc.transact(() => {
-            const existed = files.has(rel) || blobs.has(rel) || fromGit !== null
-            let before = fromGit || ''
-            if (was === null || was === undefined) {
-              const y = files.get(rel); if (y) before = y.toString()
-              if (diff) removePath(branch, rel, { by: me, base: baseOf(room, branch.key, branch) })
-              else { files.delete(rel); blobs.delete(rel) }
-            } else {
-              blobs.delete(rel)
-              let ytext = files.get(rel)
-              if (!ytext) { ytext = new Y.Text(); if (fromGit) ytext.insert(0, fromGit); files.set(rel, ytext) }
-              if (diff) notePresent(branch, rel, { base: baseOf(room, branch.key, branch) })
-              before = ytext.toString()
-              applyTextDiff(ytext, was.toString('utf8'))
-            }
-            const kind = was == null ? 'deleted' : existed ? 'edited' : 'created'
-            activity.push([{ by: me, path: rel, kind, detail: `reverted to GitHub (${d.against})`, ...(branch ? { branch: branch.key } : {}), ts: Date.now() }])
-            if (activity.length > ACTIVITY_CAP) activity.delete(0, activity.length - ACTIVITY_CAP)
-            historyOf(room).record({ by: me, path: rel, kind, before, after: was == null ? '' : was.toString('utf8'), task: currentTask(readTasks(taskMap(doc)), me) })
-          }, AGENT), AGENT)
-          done.push(rel)
-        }
-        return text(`${done.length ? `Put back as GitHub's ${d.against} has ${done.length === 1 ? 'it' : 'them'}: ${done.join(', ')}.` : 'Nothing reverted.'}${skipped.length ? ` Left alone: ${skipped.join('; ')}.` : ''}`)
-      } catch (err) { return fail(err.message) }
-    })
-
-    tool('quilt_git_pull_requests', {
-      description: PULLS_DESCRIPTION,
-      inputSchema: {}
-    }, async (_, { room, branch }) => {
-      try { return text(describePulls(await pullRequestsFor(room, { key: keyOf(branch) }, { fetch: room.githubFetch }))) } catch (err) { return fail(err.message) }
-    })
-
-    tool('quilt_git_merge', {
-      description: MERGE_DESCRIPTION,
-      inputSchema: mergeSchema(z)
-    }, async (args, { room, doc, branch }) => {
-      { const w = waitRefusal(doc, 'quilt_git_merge', room); if (w) return fail(w) }
-      try {
-        const r = await mergeForMember(room, { who: whoAmI(room), key: keyOf(branch), number: args.number, branch: args.branch, method: args.method, deleteBranch: args.delete_branch, force: args.force === true }, { fetch: room.githubFetch, log: () => {} })
-        return text(describeMerge(r))
-      } catch (err) { return fail(err.message) }
-    })
-
-    tool('quilt_agent_commits', {
-      description: 'Session owner only: git for this session, for everyone in it (people and agents push with git through one GitHub connection, nothing for them to set up). "off": off for everyone (nobody pushes through Quilt; agents ask a person with quilt_request_commit, who commits from the app); "branches" (the default): on, agents push to branches of their own, quilt/<agent>/…, with pull requests for people to merge; "any": on, agents push to any branch, the session\'s own included. People push any branch while it is on. A rule its org, team or workspace sets is a ceiling: you may be stricter, never looser. For a hard limit on main, protect the branch on GitHub.',
-      inputSchema: { mode: z.enum(['off', 'branches', 'any']) }
-    }, ({ mode }, { room }) => {
-      if (!ctx.access(room)?.owner) return fail('Only the session owner decides whether git is on here.')
-      try { return text(`Now ${POLICY_WORDS[room.setAgentCommits ? room.setAgentCommits(mode) : mode]}.`) } catch (err) { return fail(err.message) }
-    })
-  }
-
-  tool('quilt_commit_status', {
-    description: 'Is it a good moment to commit? Lists open commit requests and whose AI is still working (not counting yours).',
-    inputSchema: {}
-  }, (_, { room, doc }) => text(describeCommits(commitState(room, doc))))
-
-  tool('quilt_commit_request_done', {
-    description: 'Close commit requests whose work was committed with git by hand (or isn\'t needed any more). Without an id, every open request is closed.',
-    inputSchema: {
-      id: z.string().max(40).optional().describe('One request id; omit for all open ones'),
-      hash: z.string().max(64).optional().describe('The commit that did it, if you know it')
-    }
-  }, ({ id: one, hash }, { room, doc }) => {
-    { const w = waitRefusal(doc, 'quilt_commit_request_done', room); if (w) return fail(w) }
-    const err = writable(room)
-    if (err) return fail(err)
-    const open = [...commitMap(doc).values()].filter((r) => r && r.state === 'open' && (!one || r.id === one))
-    if (!open.length) return text(one ? `No open commit request ${one}.` : 'No open commit requests.')
-    const h = typeof hash === 'string' && /^[0-9a-f]{7,64}$/.test(hash) ? hash : ''
-    doc.transact(() => { for (const r of open) commitMap(doc).set(r.id, { ...r, state: 'done', doneBy: me, hash: h, doneAt: Date.now() }) }, AGENT)
-    return text(`Marked ${open.length} commit request${open.length === 1 ? '' : 's'} done.`)
-  })
-
   tool('quilt_list_files', {
     description: 'List the shared project files with who is working on them (claims).',
     inputSchema: { under: z.string().optional().describe('Only files under this folder') }
@@ -1166,10 +878,24 @@ function sessionTools (server, ctx) {
     return text(`Claimed ${pattern.trim()}. Release it with quilt_release when done.`)
   })
 
+  const releaseHostedInSeam = async (room, pattern) => {
+    const quilt = quiltName(room) && room.meta.quilt_id
+    const access = ctx.seam && ctx.seam()
+    if (!quilt || !access) return fail(seamFileRefusal(quiltName(room)))
+    try {
+      const asked = room.claimRequest(who(room), { op: 'quilt-claims' })
+      const { gone, ...r } = await releaseInSeam({ access, api: process.env.QUILT_SOURCE_URL, quilt, asked, pattern: pattern ? pattern.trim() : '*' })
+      if (gone.length) room.claimRequest(who(room), { op: 'quilt-released', ids: gone })
+      return text(releaseWords(r, { cli: 'quilt_release' }))
+    } catch (err) { return fail(err.message) }
+  }
+
   tool('quilt_release', {
     description: 'Release a claim (or all of your claims when no pattern is given).',
     inputSchema: { pattern: z.string().optional() }
   }, ({ pattern }, { room }) => {
+    // At layout 3 the claims are Seam's: the agent lets go of its own there, as itself.
+    if (room.meta.layout === LAYOUT_QUILT) return releaseHostedInSeam(room, pattern)
     // Releasing everything keeps boxes: a box opens when it's committed (quilt_git_commit) or unpacked (quilt_unpack).
     const mine = claimsOf(room).filter((c) => c.by === me && (pattern ? c.pattern === pattern.trim() : !c.box))
     // A file someone waits for is handed off, not released.
@@ -1430,6 +1156,13 @@ export function hostedWorkspaceAccess ({ apiUrl, pass, fetch: fetchImpl = global
   return { call, fetchBytes: bytesFetcher(fetchImpl, { timeoutMs: WORKSPACE_TRANSFER_TIMEOUT_MS }), put, saveDir: null, readLocal: null }
 }
 
+/** A request's JSON body, read here (the transport takes it parsed). */
+async function readJsonBody (req) {
+  const chunks = []
+  for await (const c of req) chunks.push(c)
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+}
+
 async function serve (mcp, req, res, body) {
   const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true })
   res.on('close', () => { transport.close().catch(() => {}); mcp.close().catch(() => {}) })
@@ -1446,11 +1179,30 @@ async function serve (mcp, req, res, body) {
  */
 export async function handleHostedMcp ({ req, res, pass, relay, workspaces = null, secrets = null, body = undefined }) {
   const image = String(req.headers['x-quilt-image'] || '').trim()
-  // The library's guide is part of the instructions only when its tools are offered.
-  const mcp = new McpServer({ name: 'quilt', version: '0.2.0' }, { instructions: (workspaces ? `${HOSTED_INSTRUCTIONS}\n\n${WORKSPACE_GUIDE_HOSTED}` : HOSTED_INSTRUCTIONS) })
   const me = pass.name
   const account = `${pass.kind}:${pass.sub}`
   const touched = new Set()
+  // Whether the agent's sessions on this machine are quilts (some, all): an agent whose sessions all
+  // are reads only Seam's way, with no git in its instructions or tool list (session-seam.js).
+  const quilts = (() => {
+    let any = false; let all = true; let seen = 0
+    for (const name of hostedRooms(relay.hosted.get(account))) {
+      if (relay.roomEnded(name)) continue
+      const room = relay.getRoom(name)
+      if (!room || !room.exists) continue
+      touched.add(room)
+      seen++
+      if (quiltOf(room.meta)) any = true; else all = false
+    }
+    return { any, all: any && all && seen > 0 }
+  })()
+  // The library's guide is part of the instructions only when its tools are offered.
+  const base = quilts.all ? `${seamOnly(HOSTED_INSTRUCTIONS)} In a session that is a quilt: ${SEAM_GUIDE_HOSTED}` : HOSTED_INSTRUCTIONS
+  const mcp = new McpServer({ name: 'quilt', version: '0.2.0' }, { instructions: (workspaces ? `${base}\n\n${WORKSPACE_GUIDE_HOSTED}` : base) })
+  // Every tool it registers, so the git-era ones can be left out for an agent whose sessions are all quilts.
+  const registered = new Map()
+  const register = mcp.registerTool.bind(mcp)
+  mcp.registerTool = (name, spec, handler) => { const t = register(name, spec, handler); registered.set(name, t); return t }
   const done = () => { for (const room of touched) if (room && !room.conns.size && room.onEmpty) room.onEmpty() }
   res.on('close', done)
   // Which sessions the agent is in, for the accounts API (x-quilt-rooms), and which one this
@@ -1548,6 +1300,8 @@ export async function handleHostedMcp ({ req, res, pass, relay, workspaces = nul
     multi: true, // every tool takes `session`
     who: () => ({ name: me, id: account }),
     kind: pass.kind === 'agent' ? 'agent' : 'human',
+    // This agent to Seam (its pass, traded for an agent token), for what it does there as itself.
+    seam: () => process.env.QUILT_SOURCE_URL && pass.kind === 'agent' && req.headers['x-quilt-pass'] ? hostedSeam(account, String(req.headers['x-quilt-pass'])) : null,
     access: (room) => room.hostedAccess(pass),
     branch: (room) => room.hostedBranch(account),
     setBranch: (room, key, opts) => room.setHostedBranch(account, key, opts),
@@ -1588,6 +1342,14 @@ export async function handleHostedMcp ({ req, res, pass, relay, workspaces = nul
     } : null,
     updates: relay.updates || null,
     image: () => image,
+    // Whether this agent is yet to be told the Seam way in `room` (once per quilt, kept with its record there).
+    seamOnce: (room) => {
+      const r = hostedIn(relay.hosted.get(account), room.name)
+      if (!r || !room.meta.quilt_id || r.seamTold === room.meta.quilt_id) return false
+      r.seamTold = room.meta.quilt_id
+      relay.saveHosted()
+      return true
+    },
     withSession: (fn, session) => {
       const c = current(session)
       return c.error ? fail(c.error) : fn(c.room)
@@ -1678,88 +1440,6 @@ export async function handleHostedMcp ({ req, res, pass, relay, workspaces = nul
     return text(`Left room ${name}.${left.length ? ` You are still in ${left.join(', ')}.` : ''}`)
   })
 
-  mcp.registerTool('quilt_git_branch', {
-    description: 'Work on another branch of the session: your file tools, claims and history then read and write that branch. quilt_status lists the branches and who is on each. create: true adds a branch that isn\'t in the session yet: one that is on GitHub is loaded at its latest commit (and the relay brings later commits on it in); any other starts from a copy of the files on the one you are on.',
-    inputSchema: {
-      branch: z.string().min(1).max(200).optional().describe('The branch to work on, e.g. quilt/<you>/<topic> or feature/login; without it, the session\'s branches are listed'),
-      create: z.boolean().optional().describe('Add it to the session: from GitHub when it is there, otherwise a copy of your current branch\'s files'),
-      session: SESSION_ARG
-    }
-  }, async ({ branch, create, session }) => {
-    const c = current(session)
-    if (c.error) return fail(c.error)
-    { const no = seamRefusal('quilt_git_branch', quiltOf(c.room.meta)); if (no) return fail(no) }
-    const room = c.room
-    if (!branch) {
-      const members = []
-      for (const st of room.awareness.getStates().values()) if (st && st.name && st.git) members.push({ name: st.name, git: cleanGit(st.git) })
-      const br = branchBoard(members, room.branchList ? room.branchList() : [])
-      return text(br.length ? `${branchesMarkdown(br, { limit: 20, mine: room.hostedBranch(account) })}\nSwitch with quilt_git_branch and a branch name; create: true adds one.` : 'This session has one branch, and you are on it.')
-    }
-    const key = String(branch).trim()
-    const editor = ctx.access(room)?.role !== 'viewer'
-    let gh = null
-    try {
-      if (create && validBranchKey(key) && key !== DEFAULT_KEY && !room.meta.branches[room.resolveKey(key)]) {
-        room.assertMigrated()
-        room.assertBranchRoom(editor, 0) // refused before asking GitHub anything
-        gh = await room.branchFromGitHub(account, key)
-        if (!(gh && gh.state === 'loaded') && room.readyToCut) await room.readyToCut(account)
-      }
-      const r = room.setHostedBranch(account, key, { create: !!create, by: me, editor, github: gh && gh.state === 'loaded' ? gh : null })
-      if (r.created && gh && gh.state === 'loaded' && gh.diff) return text(`Started ${r.branch} from GitHub (${gh.repo} at ${gh.head.slice(0, 7)}). Your file tools, claims and history use ${r.branch} now: files you haven't changed are read from git. People work on it with \`git checkout ${r.branch}\`, and their folder follows. The relay brings new commits on ${gh.upstream.name} in while no folder on it can; quilt_sync_branch asks for them now.`)
-      if (r.created && gh && gh.state === 'loaded') {
-        const n = gh.texts.size + gh.blobs.size
-        const left = gh.skipped.length ? ` ${gh.skipped.length} file${gh.skipped.length === 1 ? ' was' : 's were'} too large for the relay and left out (${gh.skipped.slice(0, 5).join(', ')}${gh.skipped.length > 5 ? ', …' : ''}): a member's folder on it brings ${gh.skipped.length === 1 ? 'it' : 'them'} in.` : ''
-        return text(`Loaded ${r.branch} from GitHub (${gh.repo} at ${gh.head.slice(0, 7)}, ${n} file${n === 1 ? '' : 's'}).${left} Your file tools, claims and history use ${r.branch} now. People work on it with \`git checkout ${r.branch}\`, and their folder follows. The relay brings new commits on ${gh.upstream.name} in while no folder on it can; quilt_sync_branch asks for them now.`)
-      }
-      if (r.created) {
-        const why = !gh ? '' : {
-          'not-github': `The session's repository (${gh.repo}) isn't on GitHub, so the relay can't load ${r.branch} from it: `,
-          'no-branch': `${r.branch} isn't a branch on GitHub (${gh.repo}), so `,
-          private: `The relay can't read ${gh.repo} on GitHub (a private repository needs a read-only token: ask the session owner to add one), so `,
-          'token-refused': `The relay's GitHub token can't read ${gh.repo} (ask the session owner to give it read access), so `,
-          'too-many': `${r.branch} on GitHub has more files than the relay loads at once (${LOAD_FILES}), so `,
-          backoff: 'GitHub asked the relay to slow down, so ',
-          error: `The relay couldn't read ${r.branch} from GitHub (${gh.message || 'no answer'}), so `
-        }[gh.state] || ''
-        const said = `Started ${r.branch} from ${r.from}, with a copy of its files. Your file tools, claims and history use ${r.branch} now. It isn't in git yet: people work on it with \`git checkout -b ${r.branch}\` (or \`git checkout ${r.branch}\` once it is pushed), and their folder follows.`
-        return text(why ? `${why}${said[0].toLowerCase()}${said.slice(1)}` : said)
-      }
-      return text(`You are on ${r.branch} now: your file tools, claims and history use it.`)
-    } catch (e) { return fail(e.message) }
-  })
-
-  mcp.registerTool('quilt_sync_branch', {
-    description: 'Bring commits made outside the session (a PR merged on GitHub, a push) into your branch now. A member\'s folder on the branch that can fetch does this about once a minute; otherwise the relay asks GitHub itself, about every 10 minutes, and this asks it now (at most once a minute per branch). It never merges git history: files that clash with the session\'s work become one task on the board for one agent to merge.',
-    inputSchema: { session: SESSION_ARG }
-  }, async ({ session }) => {
-    const c = current(session)
-    if (c.error) return fail(c.error)
-    { const no = seamRefusal('quilt_sync_branch', quiltOf(c.room.meta)); if (no) return fail(no) }
-    const room = c.room
-    if (room.meta.layout !== 2 || !room.syncUpstreamNow) return fail('This session has no branches on the relay.')
-    try {
-      const key = room.hostedBranch(account)
-      const r = await room.syncUpstreamNow(key)
-      return text(r.said)
-    } catch (e) { return fail(e.message) }
-  })
-
-  mcp.registerTool('quilt_github_token', {
-    description: 'Session owner only: set (or clear, with an empty token) the GitHub token the relay uses to bring commits in from a private repository while no folder can, to load branches from it, and, when it can write, to commit members\' work (quilt_commit). A fine-grained token for the repository with "Contents: Read" brings commits in; "Contents: Read and write" and "Pull requests: Read and write" let agents commit and open pull requests, within what quilt_agent_commits allows. It stays on the relay: it is never shown again, in any answer, status or log.',
-    inputSchema: { token: z.string().max(300).describe('The token (github_pat_… or ghp_…), or "" to remove it'), session: SESSION_ARG }
-  }, ({ token, session }) => {
-    const c = current(session)
-    if (c.error) return fail(c.error)
-    { const no = seamRefusal('quilt_github_token', quiltOf(c.room.meta)); if (no) return fail(no) }
-    if (!c.access || !c.access.owner) return fail('Only the session owner can set the GitHub token: ask them.')
-    try {
-      const r = c.room.setGithubToken(token)
-      return text(r.githubToken ? 'Saved the GitHub token on the relay. It looks at the session\'s branches again now.' : 'Removed the GitHub token.')
-    } catch (e) { return fail(e.message) }
-  })
-
   // Secrets: names only. A hosted agent runs no commands, so it uses none (the answer says so).
   mcp.registerTool('quilt_secret_names', {
     description: `${SECRET_NAMES_DESCRIPTION} You are a hosted agent: you run no commands, so you can't use secrets yourself; this tells you which exist.`,
@@ -1808,11 +1488,53 @@ export async function handleHostedMcp ({ req, res, pass, relay, workspaces = nul
   }
 
   sessionTools(mcp, ctx)
+  // Seam's tools for an agent in a session that is a quilt (session-seam.js), as itself: its
+  // pass, traded once for an agent token of its own (seam-access.js). Only while one of its
+  // sessions here is a quilt, so every other agent's tool list stays as it was.
+  const rawPass = String(req.headers['x-quilt-pass'] || '')
+  // Hidden from the list, but a call still answers with the Seam way: an agent's client keeps the
+  // list it read before its session moved into Seam, and a hidden tool would answer only "disabled".
+  if (quilts.all) {
+    if (body === undefined && req.method === 'POST') {
+      try { body = await readJsonBody(req) } catch { res.writeHead(400, { 'content-type': 'application/json' }); res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32700, message: 'Parse error' }, id: null })); return }
+    }
+    const calls = [].concat(body || []).some((m) => m && m.method === 'tools/call')
+    if (!calls) for (const [name, t] of registered) if (GIT_TOOLS.has(name)) t.disable()
+  }
+  if (process.env.QUILT_SOURCE_URL && pass.kind === 'agent' && rawPass && quilts.any) {
+    const seam = hostedSeam(account, rawPass)
+    for (const name of SEAM_SESSION_TOOLS) {
+      const spec = seamToolSpec(name, { hosted: true })
+      mcp.registerTool(name, { ...spec, inputSchema: spec.inputSchema.extend({ session: SESSION_ARG }) }, async ({ session, ...args } = {}) => {
+        const c = current(session)
+        if (c.error) return fail(c.error)
+        const quilt = quiltOf(c.room.meta)
+        if (!quilt) return fail('This session is not a quilt: its source control is git, as quilt_status says.')
+        let client
+        try { client = (await seam.client(quilt)).client } catch (e) { return fail(e.message) }
+        return runSessionSeamTool(name, args, { client, quilt, hosted: true })
+      })
+    }
+  }
   // The library works whether or not the agent is in a session (it never touches relay.hosted).
   if (workspaces) registerWorkspaceTools(mcp, { ...hostedWorkspaceAccess(workspaces), webhook: false })
   await serve(mcp, req, res, body)
 }
 
+// Each hosted agent's way into Seam, kept between its requests (each is a new MCP server): the
+// agent token it traded its pass for lasts hours, while passes last minutes.
+const hostedSeams = new Map() // account -> { access, pass }
+function hostedSeam (account, pass) {
+  let e = hostedSeams.get(account)
+  if (!e) {
+    e = { pass }
+    e.access = seamAccess({ api: () => process.env.QUILT_SOURCE_URL, credential: async () => `QuiltPass ${e.pass}` })
+    hostedSeams.set(account, e)
+  }
+  e.pass = pass
+  return e.access
+}
+
 /**
  * Handles one MCP request (stateless: a fresh server per request) for the older
  * link-based flow: a browser's token tied to a room by /agent/link.