heyquilt 0.3.122 → 0.3.138

package/src/quilt-remote.js

@@ -0,0 +1,78 @@
+// "Make this a quilt" for a session with a git remote (Seam's plans/quilt-source-control/16, flag 9, and
+// "An opt-in team's migration"): the steps the owner's one button runs, in order, each time it is
+// clicked, from where the session stands. Pure: no I/O (test/unit/quilt-remote.test.js).
+//
+//   1. import   Seam imports the GitHub repository and follows it (the owner's Seam GitHub App
+//               installation is the read credential; 16 step 1). The session stays git-mode.
+//   2. link     Once the import follows, the session reads the quilt's log (the shadow link).
+//   3. cut-over In the owner's sitting: main must take pushes from Seam's export only (a ruleset only
+//               the repository's GitHub owner can add: plain steps), then the import is cut over
+//               with export to the same remote on, then the session moves in with its history.
+
+export const SEAM_APP = { id: 5475977, slug: 'seam-by-heyquilt' }
+
+/** owner/name of the session's GitHub remote, from its upstreams (the default branch's first), or null. */
+export function githubRepoOf (upstreams, defaultKey) {
+  const all = Object.entries(upstreams || {})
+  const pick = all.find(([k]) => k === defaultKey) || all[0]
+  const m = pick && /^github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(\.git)?$/.exec(String((pick[1] && pick[1].repo) || ''))
+  return m ? m[1] : null
+}
+
+/** Which of the owner's Seam GitHub installations reaches `repo`, or null. */
+export function installationFor (gh, repo) {
+  const want = String(repo).toLowerCase()
+  return ((gh && gh.installations) || []).find((i) => (i.repos || []).some((r) => String(r.full_name || '').toLowerCase() === want)) || null
+}
+
+/** The step the session is at: 'import' (nothing yet), 'link' (importing), 'cutover' (linked to the quilt that follows). */
+export function remoteStage ({ quiltImport = null, quiltShadow = null }) {
+  if (quiltShadow) return 'cutover'
+  if (quiltImport) return 'link'
+  return 'import'
+}
+
+/** Whether GitHub's rules for main (GET /repos/:o/:r/rules/branches/main) keep everyone but an app from pushing to it. */
+export function mainGuarded (rules) {
+  return Array.isArray(rules) && rules.some((r) => r && r.type === 'update')
+}
+
+/** What the repository's GitHub owner does so only Seam pushes to main (16's cut-over checklist, step 5). */
+export function rulesetSteps (repo) {
+  return [
+    `On GitHub, open https://github.com/${repo}/settings/rules and choose New ruleset, then New branch ruleset.`,
+    'Name it "Seam is the authority on main" and set Enforcement status to Active.',
+    `Under Bypass list, add the app ${SEAM_APP.slug} (Seam), set to Always allow.`,
+    'Under Target branches, add the default branch and the pattern release/**.',
+    'Turn on Restrict updates, Restrict deletions and Block force pushes, then Create.',
+    'Ask everyone to stop pushing to main and wait for CI\'s last run there. Then click Move into Seam now.'
+  ]
+}
+
+/** The ruleset as GitHub's API takes it (for an owner who prefers `gh api -X POST repos/<repo>/rulesets --input`). */
+export function rulesetBody () {
+  return {
+    name: 'Seam is the authority on main',
+    target: 'branch',
+    enforcement: 'active',
+    bypass_actors: [{ actor_id: SEAM_APP.id, actor_type: 'Integration', bypass_mode: 'always' }],
+    conditions: { ref_name: { include: ['~DEFAULT_BRANCH', 'refs/heads/release/**'], exclude: [] } },
+    rules: [{ type: 'update' }, { type: 'deletion' }, { type: 'non_fast_forward' }]
+  }
+}
+
+/** What the owner does when no Seam GitHub installation of theirs reaches the repository. */
+export function installSteps (repo, installUrl = `https://github.com/apps/${SEAM_APP.slug}/installations/new`) {
+  return [
+    'Sign in to Seam at https://seam.heyquilt.com with the same account you use for Quilt.',
+    `Connect GitHub there and install the Seam app on ${repo} (${installUrl}). Seam reads the repository with it, and later pushes main to it.`,
+    'Then click Make this a quilt again.'
+  ]
+}
+
+/** One error whose message is the plain steps, with the steps alone in `steps` (the app lists them). */
+export function stepsError (lead, steps) {
+  const e = new Error(`${lead}\n${steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`)
+  e.steps = steps
+  return e
+}

package/src/relay-commit.js

@@ -17,6 +17,7 @@ import {
 } from './github-commit.js'
 import { readTasks, addTask, updateTask } from './tasks.js'
 import { addComment } from './task-comments.js'
+import { quiltOf } from './session-seam.js'
 
 export { CommitRefused }
 
@@ -566,6 +567,8 @@ export const mergeSchema = (z) => ({
  * connection (or the owner's token) covers the repository. Cheap: from the relay's record.
  */
 export function agentsCanCommit (room, key) {
+  // A session that is a quilt has no GitHub path for anyone's work: it lands with Seam (session-seam.js).
+  if (quiltOf(room.meta)) return false
   if (agentCommitsOf(room) === 'off') return false
   const found = repoRecordFor(room, key)
   if (!found) return false
@@ -676,6 +679,8 @@ export async function finishTaskFor (room, { who, key, task: taskId }, { fetch =
   const map = room.doc.getMap('tasks')
   const task = readTasks(map).find((t) => t.id === taskId)
   if (!task) return { merged: null }
+  // In a quilt a task's work lands with seam_merge: a pull request from before the switch is git's, and stays as it is.
+  if (quiltOf(room.meta)) return { merged: null }
   // A clash task (clash.js) is the merge itself.
   if (Object.values((room.meta && room.meta.upstreams) || {}).some((rec) => rec && rec.clash && rec.clash.task === taskId)) return { merged: null }
   if (!agentsCanCommit(room, key) && !task.pr) return { merged: null }

package/src/relay-lease.js

@@ -1,5 +1,5 @@
 // One live session per repository and branch (plan §8, addendum 16.6). The session that pushes
-// repo@branch holds its lease in the accounts API (git_sync_leases), which works across relay
+// repo@branch holds its lease in the accounts API (relay_leases), which works across relay
 // machines; the relay renews every lease it holds every LEASE_HEARTBEAT_MS, for every session active
 // in the last 24 hours (loaded or not), and keeps the list on its disk so a restart picks them up.
 // A lease lapses LEASE_TTL_MS after its last heartbeat (two missed: a crashed relay's).
@@ -52,9 +52,13 @@ function localStore (now) {
   }
 }
 
+/** A lease's key in the accounts API (relay_leases): "<repo> <branch>". */
+export const leaseKeyOf = (repo, branch) => `${repo} ${branch}`
+
 function apiStore ({ apiUrl, secret, fetch }) {
   const call = async (what, body) => {
-    const res = await fetch(`${String(apiUrl).replace(/\/+$/, '')}/v1/relay/leases/${what}`, { method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${secret}` }, body: JSON.stringify(body) })
+    // `key` (relay_leases, 16 R2) beside repo and branch, which an API from before R2 reads instead: the same lease either way.
+    const res = await fetch(`${String(apiUrl).replace(/\/+$/, '')}/v1/relay/leases/${what}`, { method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${secret}` }, body: JSON.stringify({ key: leaseKeyOf(body.repo, body.branch), ...body }) })
     if (!res.ok) throw new Error(`the accounts API answered ${res.status}`)
     return res.json()
   }

package/src/relay-mcp.js

@@ -37,6 +37,7 @@ import { agentCommitsOf, repoRecordFor, POLICY_WORDS, pullRequestsFor, mergeForM
 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'
@@ -48,7 +49,11 @@ import { isDiff, hasEntry, listPaths, readPath, readPaths, textOf, notePresent,
 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
@@ -154,10 +159,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) {
@@ -215,7 +227,8 @@ function sessionTools (server, ctx) {
   // 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 +237,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 +263,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))
   })
@@ -356,11 +374,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 }))
   })
 
@@ -428,7 +453,7 @@ function sessionTools (server, ctx) {
     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 +515,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 +529,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. ' +
@@ -541,6 +582,7 @@ 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)))
+        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 }) }))
         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.` : ''))
       }
@@ -1166,10 +1208,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 +1486,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 +1509,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 +1630,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 +1672,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)
@@ -1688,7 +1780,7 @@ export async function handleHostedMcp ({ req, res, pass, relay, workspaces = nul
   }, 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 no = seamRefusal('quilt_git_branch', quiltName(c.room), { hosted: true }); if (no) return fail(no) }
     const room = c.room
     if (!branch) {
       const members = []
@@ -1736,7 +1828,7 @@ export async function handleHostedMcp ({ req, res, pass, relay, workspaces = nul
   }, 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 no = seamRefusal('quilt_sync_branch', quiltName(c.room), { hosted: true }); 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 {
@@ -1752,7 +1844,7 @@ export async function handleHostedMcp ({ req, res, pass, relay, workspaces = nul
   }, ({ 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) }
+    { const no = seamRefusal('quilt_github_token', quiltName(c.room), { hosted: true }); 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)
@@ -1808,11 +1900,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.

package/src/relay-outbound.js

@@ -50,7 +50,7 @@ const plural = (k, w) => `${k} ${w}${k === 1 ? '' : 's'}`
 
 /** Whether branch `key` of the room syncs live to GitHub: the mirror is on, the owner hasn't switched it off, and the relay can write to the repository. */
 export function liveSyncOn (room, key) {
-  if (!room.cfg || !room.cfg.gitSync || !room.mirrors || room.meta.githubSync === false) return false
+  if (!room.cfg || !room.cfg.gitSync || !room.mirrors || room.meta.githubSync === false || room.meta.syncStopped) return false
   const rec = upstreamsOf(room)[key]
   if (!rec || !rec.repo || !rec.ref) return false
   // Agents' policy "off" (addendum 16.7): an agent's own branch stays in the session; a person adopts its work (adoptBranch).

package/src/release-words.js

@@ -4,7 +4,7 @@
 
 const list = (xs) => xs.length === 1 ? xs[0] : `${xs.slice(0, -1).join(', ')} and ${xs[xs.length - 1]}`
 
-/** r: { released, held?, branches?, coveredBy?, holder?, yours? }; `cli`: the command to name (quilt release, or quilt_release). */
+/** r: { released, held?, seam? (claims are Seam's: layout 3), branches?, coveredBy?, holder?, yours? }; `cli`: the command to name (quilt release, or quilt_release). */
 export function releaseWords (r, { cli = 'quilt release' } = {}) {
   const n = (r && r.released) || 0
   let s = `Released ${n} claim(s)${r && r.branches && r.branches.length ? ` (on ${list([...new Set(r.branches)])})` : ''}.`
@@ -13,6 +13,6 @@ export function releaseWords (r, { cli = 'quilt release' } = {}) {
       ? ` That path is not a claim of its own: your claim on ${r.coveredBy} covers it. Let go of that with ${cli} ${r.coveredBy}.`
       : ` That path is not a claim of its own: ${r.holder || 'someone'}'s claim on ${r.coveredBy} covers it; only they (or the session owner) can let go of it.`
   }
-  if (r && r.held && r.held.length) s += ` Kept ${r.held.join(', ')}: someone is waiting for ${r.held.length === 1 ? 'it' : 'them'}; hand off with quilt_handoff.`
+  if (r && r.held && r.held.length) s += ` Kept ${r.held.join(', ')}: someone is waiting for ${r.held.length === 1 ? 'it' : 'them'}; ${r.seam ? `hand it on in Seam with a note (seam claim handoff ${r.held[0]} --note "…")` : 'hand off with quilt_handoff'}.`
   return s
 }

package/src/runner.js

@@ -22,6 +22,8 @@ import { keptInProject } from './agent-join.js'
 
 export { JOIN_HOST }
 
+const STATUS_FILE_MS = 1500 // .quilt/STATUS.md is written at most this often
+
 /**
  * An invite link: https://join.heyquilt.com/<room>#<secret> for sessions on Quilt's relay,
  * or https://<relay>/join/<room>#<secret> for any other relay (development relays).
@@ -101,7 +103,7 @@ export async function describeOtherSync (dir) {
  * optionally overrides the relay address given out in invites (e.g. a public
  * tunnel URL when the relay runs on this machine).
  */
-export async function runSession ({ dir, conn, name, tool, toolGuessed = false, color = null, shareByDefault = true, summarizeByDefault = false, joined = false, prefer = 'remote', inviteServer, onLog, onFatal, onDebug, kind = 'human', agentFeed = true, readerOptions = {}, passes = null, identity = null, startName = '', startAgentCommits = '', workspace = '', apiAuth = null }) {
+export async function runSession ({ dir, conn, name, tool, color = null, shareByDefault = true, summarizeByDefault = false, joined = false, prefer = 'remote', inviteServer, onLog, onFatal, onDebug, kind = 'human', agentFeed = true, readerOptions = {}, passes = null, identity = null, startName = '', startAgentCommits = '', newSession = false, workspace = '', apiAuth = null }) {
   dir = path.resolve(dir)
   if (!/^wss?:\/\//.test(conn.server)) throw new Error('The relay address must start with ws:// or wss://')
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
@@ -139,7 +141,7 @@ export async function runSession ({ dir, conn, name, tool, toolGuessed = false,
 
   // An agent whose keys are kept in its project (quilt agent join --here) is in a sandbox that is cleaned up after every run: it works in turns.
   const turns = kind === 'agent' && keptInProject(name)
-  const session = new Session({ dir, ...conn, name, tool, toolGuessed, color, prefer, kind, shareAgent, identity, passes, startName, startAgentCommits, workspace: savedWorkspace, turns })
+  const session = new Session({ dir, ...conn, name, tool, color, prefer, kind, shareAgent, identity, passes, startName, startAgentCommits, newSession, workspace: savedWorkspace, turns, apiAuth })
   const summarizer = () => createSummarizer({ onWarn: (msg) => session.log(`✂️  ${msg}`) })
   if (summarize) session.summarizer = summarizer()
   session.taskTitler = createTaskTitler({ onWarn: (msg) => session.log(`📋 ${msg}`) })
@@ -147,12 +149,24 @@ export async function runSession ({ dir, conn, name, tool, toolGuessed = false,
   if (onDebug) session.on('debug', onDebug)
   session.on('fatal', (err) => onFatal && onFatal(err))
   const statusFile = path.join(dir, '.quilt', 'STATUS.md')
+  // Written at most every STATUS_FILE_MS: each write works out the whole status again.
+  let statusWrite = null
   session.on('status-changed', () => {
-    // Read config fresh: the workspace can change after the session started (the app's
-    // "move to workspace", or a later quilt_start_session call writing it here).
-    try { fs.writeFileSync(statusFile, renderStatus({ ...session.status(), workspace: readConfig(dir)?.workspace })) } catch {}
+    if (statusWrite) return
+    statusWrite = setTimeout(() => {
+      statusWrite = null
+      if (session.stopped) return
+      // Read config fresh: the workspace can change after the session started (the app's
+      // "move to workspace", or a later quilt_start_session call writing it here).
+      try { fs.writeFileSync(statusFile, renderStatus({ ...session.status(), workspace: readConfig(dir)?.workspace })) } catch {}
+    }, STATUS_FILE_MS)
+    statusWrite.unref?.()
   })
 
+  // Work for this person's AI can run on its own here, when they turned that on (autowork.js). It
+  // listens before the session starts: what was written to their cloud AI while it was away arrives
+  // as the session syncs, before start() returns, and is its work.
+  autowork().attach(session)
   try {
     await session.start({ waitTimeoutMs: 15000 })
   } catch (err) {
@@ -164,8 +178,6 @@ export async function runSession ({ dir, conn, name, tool, toolGuessed = false,
   session.on('identity', ({ name }) => saveName(name))
   // apiAuth: { api, token } for the accounts API as this session's person or agent (secrets, `quilt run`).
   const control = await startControl(session, { invite, viewInvite, joined, apiAuth })
-  // Work for this person's AI can run on its own here, when they turned that on (autowork.js).
-  autowork().attach(session)
   remember({ dir, room: conn.room, server: conn.server, name: session.name, tool, kind, workspace: savedWorkspace })
 
   // Every AI tool on this computer can reach Quilt (its MCP server, by absolute path), with nothing to set up.
@@ -198,6 +210,7 @@ export async function runSession ({ dir, conn, name, tool, toolGuessed = false,
       if (stopped) return
       stopped = true
       if (readers) readers.stop()
+      clearTimeout(statusWrite)
       await control.close()
       await session.stop()
     }