heyquilt 0.3.122 → 0.3.138

package/src/mcp.js

@@ -46,7 +46,7 @@ import { CLASH_DESCRIPTION, clashSchema } from './relay-clash.js'
 import { describeSecretNames, SECRET_NAMES_DESCRIPTION, RUN_GUIDE } from './secret-names.js'
 import { appWorkspaces } from './app-workspaces.js'
 import { TRANSCRIPT_DESCRIPTION, renderLines } from './voice.js'
-import { seamGate, seamNote } from './session-seam.js'
+import { seamGate, seamNote, seamStatus, seamToolSpec, seamOnly, seamWorkflow, seamRefusal, SEAM_SESSION_TOOLS, GIT_TOOLS } from './session-seam.js'
 
 // The board's columns, from tasks.js, so this and the hosted MCP (relay-mcp.js) never drift apart.
 const COLUMN_IDS_LIST = COLUMNS.map((c) => c.id)
@@ -119,11 +119,25 @@ export const MCP_INSTRUCTIONS =
   MAIL_GUIDE + ' ' +
   TASK_WORKFLOW
 
+/**
+ * The instructions for a folder in a session that is a quilt (session-seam.js): every sentence
+ * about git left out, and how work lands on Seam in its place. Nothing there names git or GitHub.
+ */
+export const mcpQuiltInstructions = (quilt) => `${seamOnly(MCP_INSTRUCTIONS)} ${seamNote(quilt)}`
+
+/** The session this folder is in, as its app says, when it answers at once: whether it is a quilt picks the instructions. */
+async function quiltAtStart () {
+  const d = findDaemon()
+  if (!d) return null
+  try { return (await rawCall(d, 'GET', '/quilt', undefined, { timeoutMs: 1500 })).quilt || null } catch { return null }
+}
+
 export async function runMcp () {
+  const startQuilt = await quiltAtStart()
   const server = new McpServer(
     { name: 'quilt', version: '0.1.0' },
     // The channel capability lets Claude Code (started with the quilt channel) take inbox events as turns.
-    { instructions: MCP_INSTRUCTIONS, capabilities: { resources: { subscribe: true }, experimental: { 'claude/channel': {} } } }
+    { instructions: startQuilt && startQuilt.id ? mcpQuiltInstructions(startQuilt.slug || startQuilt.id) : MCP_INSTRUCTIONS, capabilities: { resources: { subscribe: true }, experimental: { 'claude/channel': {} } } }
   )
 
   // This AI session, by an id of its own, so the app can tell it from the others working through
@@ -200,10 +214,19 @@ export async function runMcp () {
   // When this person lets their AI pick up work by itself: the next task, said as it finishes one.
   const nextUp = async (d) => { try { const n = renderNextTask((await call(d, 'GET', '/duties')).next); return n ? `\n\n➡️ ${n}` : '' } catch { return '' } }
   const gates = (...list) => async (d) => { for (const g of list) { const r = g && await g(d); if (r) return r } return '' }
+  // An AI session started before its session moved into Seam (or back to git) was told the other
+  // way in its instructions, which never change once given: the next answer says the way now, once.
+  let toldQuilt = !!(startQuilt && startQuilt.id)
+  const moved = async () => {
+    const q = await quiltNow()
+    if (q === undefined || !!q === toldQuilt) return ''
+    toldQuilt = !!q
+    return q ? `🧵 Since you started, ${seamNote(q.slug || q.id).replace(/^This/, 'this')} Leave aside what your instructions said about how work lands.\n\n` : '🧵 Since you started, this session went back to its git branches: quilt_status says how work lands now.\n\n'
+  }
   const withDaemon = async (fn, { inbox = true, gate = null } = {}) => {
     const d = findDaemon(joined ? joined.dir : undefined)
     if (!d) return { content: [{ type: 'text', text: NOT_RUNNING + stale() }], isError: true }
-    const before = async () => introduce() + (await notices(d)) + (inbox ? await arrivals(d) : '')
+    const before = async () => introduce() + (await moved()) + (await notices(d)) + (inbox ? await arrivals(d) : '')
     const waiting = async () => { const n = renderQueueNotice(await queuedNow(d)); return n ? `\n\n📥 ${n}` : '' }
     try {
       const refused = gate ? await gate(d) : ''
@@ -222,14 +245,42 @@ export async function runMcp () {
     return `${label ? `Assigned to ${label}.` : 'Unassigned.'}${files}`
   }
 
-  // Seam (plans/quilt-source-control/12, 16): in a session that is a quilt, the GitHub tools
+  // Seam (Seam's plans/quilt-source-control/12, 16): in a session that is a quilt, the GitHub tools
   // refuse with the Seam tool to use instead, the same for every AI tool (session-seam.js).
+  // undefined when the app can't say (none, or no answer): unknown, not "not a quilt".
   const quiltNow = async () => {
     const d = findDaemon(joined ? joined.dir : undefined)
-    if (!d) return null
-    try { return (await call(d, 'GET', '/quilt')).quilt || null } catch { return null }
+    if (!d) return undefined
+    let q = null
+    try { q = (await call(d, 'GET', '/quilt')).quilt || null } catch { return undefined }
+    syncSeamTools(q)
+    return q
+  }
+  // The git-era tools are hidden while the session is a quilt (GIT_TOOLS), and refuse with the Seam tool if called.
+  const gitTools = new Map()
+  const gated = seamGate(server.registerTool.bind(server), quiltNow)
+  server.registerTool = (name, spec, handler) => {
+    const t = gated(name, spec, handler)
+    if (GIT_TOOLS.has(name)) gitTools.set(name, t)
+    return t
+  }
+  // Seam's everyday tools, served by this server itself while the session is a quilt (none
+  // otherwise): the app runs them as this folder's member, on its square (control.js /seam).
+  // The client is told when they come and go, as with the workspace library's tools.
+  const seamTools = new Map()
+  const seamCall = (name, args) => withDaemon(async (d) => {
+    await quiltNow() // the session may have stopped being a quilt: the tool list follows
+    const r = await call(d, 'POST', '/seam', { tool: name, args: args || {} })
+    const text = ((r && r.content) || []).map((c) => c.text || '').join('\n')
+    if (r && r.isError) throw new Error(text)
+    return text
+  }, { gate: name === 'seam_commit' || name === 'seam_merge' ? gateFor(name) : null })
+  const syncSeamTools = (q) => {
+    const on = !!(q && q.id)
+    if (on && !seamTools.size) for (const name of SEAM_SESSION_TOOLS) seamTools.set(name, server.registerTool(name, seamToolSpec(name), (args) => seamCall(name, args)))
+    for (const t of seamTools.values()) if (t.enabled !== on) { if (on) t.enable(); else t.disable() }
+    for (const t of gitTools.values()) if (t.enabled === on) { if (on) t.disable(); else t.enable() }
   }
-  server.registerTool = seamGate(server.registerTool.bind(server), quiltNow)
 
   server.registerTool('quilt_status', {
     description: 'See who else is in the live session, what they are working on, which files they recently edited or claimed, recent messages, and which open tasks are assigned to you. Call this before starting work.',
@@ -237,7 +288,8 @@ export async function runMcp () {
   }, () => withDaemon(async (d) => {
     const st = await call(d, 'GET', '/status')
     const q = await quiltNow()
-    return (q ? seamNote(q.slug || q.id) + '\n\n' : '') + renderStatus(st, { asAi: taskReader(st).asAi, mentionYours: true })
+    const md = renderStatus(st, { asAi: taskReader(st).asAi, mentionYours: true })
+    return q ? `${seamNote(q.slug || q.id)}\n\n${seamStatus(md)}` : md
   }))
 
   server.registerTool('quilt_tasks', {
@@ -292,8 +344,11 @@ export async function runMcp () {
     if (column === 'qa') patch.qaNotes = qaNotes
     if (column === 'done') patch.verified = verified
     const { task, merged, branch } = await call(d, 'POST', '/tasks/update', patch)
+    const q = column === 'doing' || column === 'qa' ? await quiltNow() : null
+    if (q && column === 'doing') return pickupBrief({ ...brief, task: { ...task, comments: brief.task.comments }, workflow: seamWorkflow(TASK_WORKFLOW) })
     if (column === 'doing') return pickupBrief({ ...brief, task: { ...task, comments: brief.task.comments } }) + (branch ? `\nYour folder is on ${branch} now (Quilt made it for this task): commit only the files you change and push there; the pull request opens by itself. Move the task to QA when it is done and tested.` : '')
-    if (column === 'qa') return `Moved "${task.title}" to QA. Notes: ${qaNotesLine(task)}` + (task.pr ? ` Pull request #${task.pr.number} waits for a person to move the task to Done, which merges it.` : '') + await nextUp(d)
+    // In a quilt a pull request from before the switch is git's: the task's work lands with seam_merge.
+    if (column === 'qa') return `Moved "${task.title}" to QA. Notes: ${qaNotesLine(task)}` + (task.pr && !q ? ` Pull request #${task.pr.number} waits for a person to move the task to Done, which merges it.` : '') + await nextUp(d)
     if (column === 'done') return `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)}` + await nextUp(d)
     return `Moved "${task.title}" to ${columnName(task.column)}.`
   }, { gate: gates(gateFor('quilt_move_task'), column === 'done' && queueGate('move the task again')) }))
@@ -730,6 +785,8 @@ export async function runMcp () {
       readerOptions: { chatDir: process.cwd() },
       onLog: (line) => { logs.push(line); if (logs.length > 50) logs.shift() },
       onFatal: async (err) => { logs.push(`stopped: ${err.message}`); await leave() },
+      // A session this agent starts is a quilt from the start when the API says so (src/quilt-default.js).
+      newSession: starting && !inviteServer,
       workspace
     })
     joined = { run, dir, invite: run.invite }
@@ -1052,8 +1109,8 @@ export async function runMcp () {
       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 }) => withDaemon(async (d) => {
-    const { entries } = await call(d, 'POST', '/history', { path: p, by, since, task, limit: limit || 30 })
-    return formatHistory(entries, { withDiff: !!with_diff })
+    const { entries, note } = await call(d, 'POST', '/history', { path: p, by, since, task, limit: limit || 30, with_diff: !!with_diff })
+    return `${formatHistory(entries, { withDiff: !!with_diff })}${note ? `\n\n${note}` : ''}`
   }))
 
   server.registerTool('quilt_partner_feed', {
@@ -1122,12 +1179,30 @@ export async function runMcp () {
     if (d && client && client.name) call(d, 'POST', '/agent', { client: client.name }).catch(() => {}) // says hello too
   }
 
-  await server.connect(new StdioServerTransport())
+  const transport = new StdioServerTransport()
+  await server.connect(transport)
+  // A git-era tool hidden while the session is a quilt, called from a tool list read before the
+  // move (a client that missed the list's change): answered with the Seam way, not "disabled".
+  const onmessage = transport.onmessage
+  transport.onmessage = (msg, extra) => {
+    const name = msg && msg.method === 'tools/call' && msg.params && msg.params.name
+    const t = name && gitTools.get(name)
+    if (!t || t.enabled) return onmessage(msg, extra)
+    quiltNow().then((q) => {
+      const no = q && seamRefusal(name, q.slug || q.id)
+      if (!no) return onmessage(msg, extra)
+      return transport.send({ jsonrpc: '2.0', id: msg.id, result: { content: [{ type: 'text', text: no }], isError: true } })
+    }).catch(() => onmessage(msg, extra))
+  }
   // The workspace library tools arrive a moment later (the client is told the tool list
   // changed), so startup never waits on the API.
   // fromPath reads only from the project: the session's folder, or where the agent runs.
   const projectDirs = () => [joined?.dir, findDaemon(joined ? joined.dir : undefined)?.dir, process.env.QUILT_DIR || process.cwd()].filter(Boolean)
   addWorkspaceTools(server, { projectDirs }).catch(() => {})
+  // In a session that is a quilt, Seam's tools come the same way; looked at again every half minute.
+  quiltNow().catch(() => {})
+  const seamTimer = setInterval(() => quiltNow().catch(() => {}), 30_000)
+  seamTimer.unref()
 }
 
 /**

package/src/merge3.js

@@ -79,7 +79,8 @@ export function hasMarkers (text) {
 /**
  * merge3, plus the clashes where neither side lost anything, resolved the way a person would:
  * - both sides only added lines in the same place (base had nothing there): ours, then theirs,
- *   with lines both start (or end) with written once, so two new sections under the same
+ *   with lines both start (or end) with written once (not a line of only brackets and
+ *   punctuation such as `],`: each block keeps its own), so two new sections under the same
  *   heading become one heading with both sections' lines;
  * - both sides changed the same one-line `import { … } from '…'` of the same module: one import
  *   with every name either side has (a name either side removed stays removed).
@@ -100,12 +101,19 @@ export const mergeAdditive = eolAware(function mergeAdditive (base, ours, theirs
   return { text: out.join('\n'), conflicts }
 })
 
+/**
+ * Whether a line both added blocks start or end with can be written once: one with words in it, or a
+ * blank one. A line of only brackets and punctuation (`],`, `}`, `)`) closes each block, so writing
+ * it once drops one block's closer (two new entries in ci/policy.json came out as invalid JSON).
+ */
+const sharable = (line) => /\w/.test(line) || !line.trim()
+
 /** Two blocks inserted at one place, as one: shared leading and trailing lines once, the middles in order. */
 function addedBoth (a, b) {
   let pre = 0
-  while (pre < a.length && pre < b.length && a[pre] === b[pre]) pre++
+  while (pre < a.length && pre < b.length && a[pre] === b[pre] && sharable(a[pre])) pre++
   let post = 0
-  while (post < a.length - pre && post < b.length - pre && a[a.length - 1 - post] === b[b.length - 1 - post]) post++
+  while (post < a.length - pre && post < b.length - pre && a[a.length - 1 - post] === b[b.length - 1 - post] && sharable(a[a.length - 1 - post])) post++
   return [...a.slice(0, pre), ...a.slice(pre, a.length - post), ...b.slice(pre, b.length - post), ...a.slice(a.length - post)]
 }
 

package/src/now-summary.js

@@ -0,0 +1,113 @@
+// The website dashboard's summary of now (plans/dashboard ticket 9): for one person, what is going on in
+// a session this relay holds. Who is in it and what each AI is doing, the board in brief, the latest
+// file changes, held files and who waits for them, and what needs this person: messages to them not
+// answered, tasks for them, files someone waits for from them, and, for the owner, commit requests and
+// people asking to join. The accounts API asks for it (GET /v1/me/now, every 15 to 30 seconds from the
+// page) and merges what each relay machine says; nothing here is streamed or stored.
+import { waitingOn } from './duties.js'
+import { readTasks, activeTasks } from './tasks.js'
+
+export const NOW_LIMITS = { people: 24, recent: 8, detailRecent: 80, held: 24, needs: 24, text: 160 }
+const EDIT_FRESH_MS = 4 * 60 * 1000 // a peer's edit counts as current this long (as relay-mcp.js)
+
+const clip = (s, n = NOW_LIMITS.text) => {
+  const t = String(s || '').replace(/\s+/g, ' ').trim()
+  return t.length > n ? `${t.slice(0, n - 1)}…` : t
+}
+
+/** The name `account` ('person:<id>') has in `room`, or '' when it isn't the owner or a member. */
+export function nameIn (room, account) {
+  const meta = room && room.meta
+  if (!meta || typeof account !== 'string') return ''
+  if (meta.ownerSub && meta.ownerSub === account) return meta.ownerName || 'owner'
+  const m = meta.members && Object.prototype.hasOwnProperty.call(meta.members, account) ? meta.members[account] : null
+  return m && !m.chat && typeof m.name === 'string' ? m.name : ''
+}
+
+/** The files a peer edited in the last few minutes, newest first. */
+function freshEdits (editing, now) {
+  return Object.entries(editing || {})
+    .filter(([, ts]) => Number.isFinite(ts) && now - ts < EDIT_FRESH_MS)
+    .sort((a, b) => b[1] - a[1])
+    .map(([p]) => p)
+}
+
+/** Who is in the room now, each with what their AI is doing. */
+function peopleIn (room, now) {
+  const out = []
+  const seen = new Set()
+  const states = room.awareness && room.awareness.getStates ? [...room.awareness.getStates().values()] : []
+  for (const s of states) {
+    if (!s || typeof s.name !== 'string' || !s.name || seen.has(s.name)) continue
+    seen.add(s.name)
+    const ag = s.agent || {}
+    const working = ag.sharing !== false && (ag.status === 'working' || (s.work && s.work.state === 'working'))
+    out.push({
+      name: clip(s.name, 64),
+      kind: s.kind === 'agent' ? 'agent' : 'person',
+      tool: clip(ag.tool || s.tool || '', 40),
+      ai: ag.sharing === false ? 'paused' : working ? 'working' : (ag.tool ? 'idle' : ''),
+      focus: clip(s.focus || (s.work && s.work.state === 'working' ? s.work.note : '') || '', 120),
+      editing: freshEdits(s.editing, now).slice(0, 3)
+    })
+  }
+  for (const h of room.hostedOnline ? room.hostedOnline() : []) {
+    if (!h || !h.name || seen.has(h.name)) continue
+    seen.add(h.name)
+    out.push({ name: clip(h.name, 64), kind: h.kind === 'agent' ? 'agent' : 'person', tool: 'hosted', ai: '', focus: '', editing: [] })
+  }
+  return out.slice(0, NOW_LIMITS.people)
+}
+
+/**
+ * The summary of `room` for `account`, or null when the account isn't in it. `now` is the time;
+ * `detail` (one session's page) keeps more of the latest file changes, for its Activity tab.
+ * The room is read through what Room already offers (server.js): meta, awareness, doc, claimList, pendingList.
+ */
+export function nowSummary (room, account, { now = Date.now(), detail = false } = {}) {
+  const me = nameIn(room, account)
+  if (!me) return null
+  const owner = !!(room.meta.ownerSub && room.meta.ownerSub === account)
+  const doc = room.doc
+  const chat = doc ? doc.getArray('chat').toArray() : []
+  const tasks = doc ? activeTasks(readTasks(doc.getMap('tasks'))) : []
+  const claims = room.claimList ? room.claimList() : []
+  const people = peopleIn(room, now)
+
+  const needs = []
+  for (const m of waitingOn(chat.filter((x) => x && (!x.to || x.to === me || x.by === me)), me, { now })) {
+    needs.push({ kind: m.kind, by: clip(m.by, 64), text: clip(m.text), at: m.ts })
+  }
+  for (const t of tasks) {
+    if (t.column === 'todo' && t.assignee === me && !t.forAi) needs.push({ kind: 'task', by: clip(t.by, 64), text: clip(t.title), at: t.ts, task: t.id })
+  }
+  for (const c of claims) {
+    if (c.by === me && c.queue && c.queue.length) needs.push({ kind: 'file', by: clip(c.queue[0].by, 64), text: clip(c.pattern, 200), at: c.queue[0].ts || c.ts, waiting: c.queue.length })
+  }
+  if (owner && doc) {
+    for (const r of doc.getMap('commitRequests').values()) {
+      if (r && r.id && r.state === 'open') needs.push({ kind: 'commit', by: clip(r.by, 64), text: clip(r.message), at: r.ts, files: Array.isArray(r.files) ? r.files.length : 0 })
+    }
+    for (const p of room.pendingList ? room.pendingList() : []) needs.push({ kind: 'join', by: clip(p.name, 64), text: p.kind === 'agent' ? 'An agent asks to join' : 'Asks to join', at: p.since, agent: p.kind === 'agent' })
+  }
+  needs.sort((a, b) => (b.at || 0) - (a.at || 0))
+
+  const byColumn = { todo: 0, doing: 0, qa: 0 }
+  for (const t of tasks) if (t.column in byColumn) byColumn[t.column]++
+  const recent = (doc ? doc.getArray('activity').toArray() : []).filter((x) => x && x.by).slice(-(detail ? NOW_LIMITS.detailRecent : NOW_LIMITS.recent)).reverse()
+    .map((x) => ({ by: clip(x.by, 64), kind: clip(x.kind, 20), path: clip(x.path || x.detail || '', 200), at: x.ts }))
+
+  return {
+    room: room.name,
+    name: clip(room.meta.name || '', 80),
+    me,
+    owner,
+    people,
+    working: people.filter((p) => p.ai === 'working').length,
+    tasks: { open: byColumn.todo + byColumn.doing + byColumn.qa, ...byColumn, mine: tasks.filter((t) => t.column !== 'done' && t.assignee === me).length },
+    recent,
+    held: claims.slice(0, NOW_LIMITS.held).map((c) => ({ path: clip(c.pattern, 200), by: clip(c.by, 64), box: !!c.box, waiting: (c.queue || []).map((q) => clip(q.by, 64)) })),
+    needs: needs.slice(0, NOW_LIMITS.needs),
+    at: now
+  }
+}

package/src/pathrules.js

@@ -20,6 +20,8 @@ export const CHAT_FILES = 'Chat files'
 // copies of the project.
 export const ALWAYS_IGNORED = [
   '.git', '.quilt', '.cowove', 'node_modules', '.DS_Store', 'Thumbs.db', '.claude/worktrees',
+  // A Seam block's own record (a folder checked out with seam checkout): Seam's, never the session's.
+  '.seam',
   `/${CHAT_FILES}`,
   // Each person's own Claude Code settings (permissions, Quilt's hooks) stay on their machine.
   '.claude/settings.local.json',
@@ -66,6 +68,16 @@ export function makeIgnore (texts = []) {
   }
 }
 
+/** The folders a .gitmodules text names as submodules (`path = …`), as safe relative paths. */
+export function submodulePathsIn (text) {
+  const out = []
+  for (const m of String(text || '').matchAll(/^\s*path\s*=\s*(.+?)\s*$/gm)) {
+    const p = m[1].replace(/^"(.*)"$/, '$1').replace(/\/+$/, '')
+    if (isSafeRelPath(p)) out.push(p)
+  }
+  return out
+}
+
 export function isIgnored (ig, rel) {
   if (!rel || rel === '.') return false
   // Check every ancestor directory so "dist/" also excludes "dist/a/b.js".

package/src/protocol.js

@@ -17,7 +17,7 @@ export const MSG_ADMIN = 14 // client (owner) -> relay: JSON { id, op: 'approve'
 export const MSG_MEMBERS = 15 // relay -> client: JSON { members, sessionName, pending?, reply?: { id, ok, error } }
 export const MSG_PASS = 16 // client -> relay: JSON { pass }: a fresh session pass, sent at least every 5 minutes
 export const MSG_BRANCH = 17 // client -> relay: JSON { id, op: 'join'|'confirm'|'remove', branch, base?, adopt?, sv? }
-export const MSG_BRANCHES = 18 // relay -> client: JSON { branches, reply?: { id, op, ok, error?, branch?, created?, base? } }
+export const MSG_BRANCHES = 18 // relay -> client: JSON { branches, quilt?, shadow?, reply?: { id, op, ok, error?, branch?, created?, base? } }
 
 // Every sync message names its document: the room's (chat, tasks, the feed, commit requests,
 // activity) is '', a branch's (its files) is the branch key. Git never allows an empty branch name.
@@ -25,7 +25,15 @@ export const ROOM_DOC = ''
 
 // What this app can do, sent when it connects. The relay turns away apps without what a session needs.
 // branch-diffs: this app reads a branch document that holds only what differs from git (branch-view.js).
-export const FEATURES = 'large-files,branches,branch-diffs'
+// quilts: this app works in a session whose files are in its squares' live documents (layout 3,
+// Seam's plans/quilt-source-control/16 flag 4: sent by every app before anyone opens a block).
+// quilt-folders: this app's folder follows its branch's square in place at layout 3 (session-follow.js);
+// an app with `quilts` but not this (0.3.125) kept syncing to the read-only branch documents.
+// quilt-moves: this app's folder follows a square whose base moves (main brought in): it re-projects onto
+// the new head, says which head each edit was made on, and takes in only its own edits. The relay brings
+// main into a square only when every folder on it can follow that (server.js outdatedOn); 0.3.133 and
+// 0.3.134, which can but don't say so, are known by their asking to bring main in.
+export const FEATURES = 'large-files,branches,branch-diffs,quilts,quilt-folders,quilt-moves'
 
 // WebSocket close codes the relay uses to refuse a client for good.
 export const CLOSE_AUTH_FAILED = 4401

package/src/quilt-default.js

@@ -0,0 +1,84 @@
+// New sessions are quilts from the start (Seam's plans/quilt-source-control/16, flags order 8,
+// QUILT_SOURCE_DEFAULT=1 on the accounts API): the app that starts a session (the desktop app,
+// `quilt start`, or an AI's quilt_start_session; every tool goes through the same Session) makes it
+// a quilt without history as soon as the folder's files have reached the relay: patch 1 holds them
+// (binaries and modes too), and the room moves to layout 3 with a square for the folder.
+//
+// Nothing is lost when it can't: a folder with a git remote is not made a quilt here (16: a room
+// with a git remote becomes a quilt only with its history, which flag 9's "Make this a quilt"
+// starts), and any failure leaves the session a working git-mode session, with the reason said to
+// the owner and their AIs and `quilt session migrate` to try again by hand.
+import { execFileSync } from 'node:child_process'
+import { apiUrl } from './account.js'
+
+const FEATURES_TIMEOUT_MS = 5000
+const SYNC_TRIES = 20
+const SYNC_WAIT_MS = 500
+
+/** Whether the accounts API at `api` has new sessions start as quilts (GET /v1/features `quilt_source_default`). False when it can't say. */
+export async function quiltDefaultOn ({ api = apiUrl(), fetch: fetchImpl = globalThis.fetch } = {}) {
+  try {
+    const res = await fetchImpl(`${String(api).replace(/\/+$/, '')}/v1/features`, { signal: AbortSignal.timeout(FEATURES_TIMEOUT_MS) })
+    if (!res.ok) return false
+    const f = await res.json()
+    return !!(f && f.quilt_source_default === true)
+  } catch { return false }
+}
+
+/** Whether the folder at `root` is a git repository with a remote (its history belongs in the quilt: 16 "With history"). */
+export function folderHasGitRemote (root) {
+  try {
+    return execFileSync('git', ['--no-optional-locks', 'remote'], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 10_000 }).trim().length > 0
+  } catch { return false }
+}
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+/**
+ * Makes the new session `session` a quilt (migrate, then the layout-3 switch) as its owner, once.
+ * Resolves to { done: true, quilt } or { done: false, why }; never throws.
+ */
+export async function startAsQuilt (session, { flagOn = quiltDefaultOn, credential, hasRemote = folderHasGitRemote, syncTries = SYNC_TRIES, syncWaitMs = SYNC_WAIT_MS } = {}) {
+  const skip = (why) => ({ done: false, why })
+  try {
+    if (!(await flagOn())) return skip('off')
+    if (session.stopped) return skip('stopped')
+    if (session.quilt) return skip('already a quilt')
+    if (session.root && hasRemote(session.root)) {
+      session.log('🧵 this folder has a git remote, so the new session stays on git: it becomes a quilt with its history later (Make this a quilt).')
+      return skip('git remote')
+    }
+    if (session.branchForm === 'diff') return skip('diff branch')
+    // The folder's files are its patch 1: they must all be on the relay first.
+    let synced = false
+    for (let i = 0; i < syncTries && !synced && !session.stopped; i++) {
+      if (session.ready && !session.seeding) {
+        try { session.flushPending?.() } catch {}
+        try { await session.conn.confirmBranch(); synced = true; break } catch {}
+      }
+      await wait(syncWaitMs)
+    }
+    if (session.stopped) return skip('stopped')
+    if (!synced) throw new Error("the folder's files had not all reached the relay")
+    if (session.quilt) return skip('already a quilt')
+    const token = await credential()
+    if (!token) throw new Error('no sign-in to reach Seam with')
+    const m = await session.quiltMigrate(token)
+    await session.quiltSwitch(token)
+    // The folder equals patch 1, so the switch opened no square for it: one is opened now, as the
+    // owner, and the folder follows it (16: a square for the session's first folder). Should that
+    // fail, the session is a quilt still, and the folder's first edit asks for its square (readOnly).
+    for (let i = 0; i < syncTries * 4 && !session.stopped && !(session.quilt && session.quilt.layout === 3); i++) await wait(syncWaitMs / 4)
+    const branch = typeof session.branchKey === 'function' ? session.branchKey() : session.branch
+    if (session.quilt && session.quilt.layout === 3 && !(session.quilt.live || {})[branch]) {
+      try { await session.openBranchSquare(branch, { quiet: false, token }) } catch (err) { session.log(`🧵 couldn't open a square for this folder yet (${err.message}); its first edit asks again.`) }
+    }
+    session.log(`🧵 new session: its code is in Seam from the start (quilt ${(m.quilt && m.quilt.slug) || ''}, patch 1).`)
+    return { done: true, quilt: m.quilt }
+  } catch (err) {
+    const why = String((err && err.message) || err)
+    session.log(`🧵 this new session's code could not go into Seam (${why}); the session works as before, on git. The owner can try again with: quilt session migrate`)
+    if (session.notice) { try { session.notice(`This new session's code could not go into Seam (${why}), so it stays on git for now. The session owner can try again with \`quilt session migrate\`.`) } catch {} }
+    return skip(why)
+  }
+}

package/src/quilt-history.js

@@ -0,0 +1,106 @@
+// quilt_history in a session linked to a quilt (Seam's plans/quilt-source-control/16, step 1
+// "Shadow", and after the session became a quilt): the chronology is Seam's log (the commits and
+// patches, imported from git or made in Seam) plus the session's own live record of changes not
+// committed yet (the branch document's `history`, history.js), oldest first, newest kept.
+//
+// Quilt reads Seam over its HTTP API (a client with the @heyquilt/seam quiltClient shape: `log`,
+// `show`), as the member (Session.seamMember) or, on the relay, with the room's read token. When
+// Seam can't be read, the session's own record is shown with a note, never an error: the tool
+// worked before the link and keeps working without Seam. The same for every AI tool: this runs
+// behind quilt_history in both MCP servers (mcp.js through the folder's daemon, relay-mcp.js).
+import { MAX_DIFF_CHARS, queryHistory } from './history.js'
+
+/**
+ * The quilt a room's chronology reads from: `{ id, slug, at?, shadow? }`, or null. A quilt the
+ * session became (meta.quilt_id), or the quilt it shadows while git is still the authority
+ * (meta.quiltShadow, 16 step 1: an import following the session's git remote). Only with Seam
+ * on (QUILT_SOURCE_URL), so every other session reads its own record exactly as before.
+ */
+export function historyQuilt (meta, env = process.env) {
+  if (!env || !env.QUILT_SOURCE_URL || !meta) return null
+  if (typeof meta.quilt_id === 'string' && meta.quilt_id) {
+    const q = meta.quilt || {}
+    return { id: meta.quilt_id, slug: q.slug || '', ...(q.at ? { at: q.at } : {}) }
+  }
+  const s = meta.quiltShadow
+  if (s && typeof s.id === 'string' && s.id) return { id: s.id, slug: s.slug || '', shadow: true }
+  return null
+}
+
+/** The part of a path or glob Seam's log can filter by: a file, or the folder before the first wildcard. */
+export function seamPathOf (p) {
+  const s = String(p || '').replace(/\\/g, '/').replace(/^\.\//, '')
+  if (!s) return ''
+  const wild = s.search(/[*?[{]/)
+  if (wild < 0) return s.replace(/\/+$/, '')
+  const dir = s.slice(0, wild)
+  return dir.includes('/') ? dir.slice(0, dir.lastIndexOf('/')) : ''
+}
+
+const MAX_SHOWN = 10 // commits whose diffs are read when asked for them
+
+/**
+ * The quilt's log as chronology entries, oldest first: one per commit, `{ seam: true, commit,
+ * short, patch, by, ts, message, files, task, diff }`. `since` is a timestamp. Throws what Seam
+ * said when it can't be read.
+ */
+export async function seamHistory (seam, quilt, { path = '', by, since, task, limit = 30, withDiff = false, rev = 'main' } = {}) {
+  const p = seamPathOf(path)
+  const r = await seam.log(quilt, { rev, limit: Math.min(Number(limit) || 30, 200), ...(p ? { paths: [p] } : {}), ...(by ? { author: by } : {}), ...(typeof since === 'number' ? { since: String(Math.floor(since)) } : {}), ...(task ? { task } : {}) })
+  const out = []
+  for (const c of (r && r.commits) || []) {
+    if (!c || !c.id) continue
+    const a = c.author || {}
+    out.push({
+      id: `seam:${c.id}`,
+      seam: true,
+      commit: c.id,
+      short: c.short || c.id.slice(0, 12),
+      ...(c.patch && c.patch.patch_no != null ? { patch: { line: c.patch.line || rev, no: c.patch.patch_no } } : {}),
+      by: String(a.name || a.member_id || ''),
+      ts: Number(c.at ?? c.authored_at) || 0,
+      message: String(c.message || '').split('\n')[0].slice(0, 200),
+      files: Number(c.files) || (Array.isArray(c.changes) ? c.changes.length : 0),
+      task: c.task_id ? { id: String(c.task_id), title: '' } : null,
+      path: p,
+      diff: ''
+    })
+  }
+  if (withDiff) {
+    for (const e of out.slice(0, MAX_SHOWN)) {
+      try {
+        const s = await seam.show(quilt, e.commit, { format: 'unified', ...(p ? { paths: [p] } : {}) })
+        const text = ((s && s.diff && s.diff.files) || []).map((f) => f.patch || (f.binary ? `${f.path}: binary` : '')).filter(Boolean).join('\n')
+        e.diff = text.length > MAX_DIFF_CHARS ? `${text.slice(0, MAX_DIFF_CHARS)}\n… (diff truncated)` : text
+      } catch { e.diff = '' }
+    }
+  }
+  return out.sort((x, y) => x.ts - y.ts)
+}
+
+/**
+ * The chronology of a linked session: the quilt's log (`seam`, a client) and the session's own
+ * record (`entries`, history.js), filtered by `query` (path, by, since timestamp, task, limit,
+ * withDiff), oldest first, the newest `limit` kept. A change git pulled into the session is the
+ * log's (an imported patch) and is left out of the session's record when the log answered, so it
+ * is not counted twice (16: "entries with `pulled` or `seed` are dropped", here only `pulled`:
+ * a seed is the session's first copy, which the log has no entry for). Returns { list, note }:
+ * `note` says why the log is missing, when it is.
+ */
+export async function linkedHistory ({ seam, quilt, entries = [], query = {} }) {
+  const { path = '', by, since, task, limit = 30, withDiff = false } = query
+  let fromSeam = []
+  let note = ''
+  if (!seam) note = `Seam's log for ${quilt.slug || quilt.id} was not read: the session has no read token for it (its owner links it again); this is the session's own record.`
+  else {
+    try { fromSeam = await seamHistory(seam, quilt.id, { path, by, since, task, limit, withDiff }) } catch (err) { note = `Seam's log for ${quilt.slug || quilt.id} could not be read (${String(err.message || err).slice(0, 200)}); this is the session's own record.` }
+  }
+  return { list: mergeLinked(entries, fromSeam, { ...query, logRead: !note }), note }
+}
+
+/** The session's own entries (filtered by `query`; git's pulls left out when `logRead`) with the log's, oldest first, the newest `limit`. */
+export function mergeLinked (entries, fromSeam, { path = '', by, since, task, limit = 30, logRead = true } = {}) {
+  const own = queryHistory(logRead ? entries.filter((e) => !(e && e.pulled)) : entries, { path, by, since, task, limit: 0 })
+  const list = [...own, ...(fromSeam || [])].sort((a, b) => a.ts - b.ts)
+  return limit && list.length > limit ? list.slice(-limit) : list
+}