heyquilt 0.3.121 → 0.3.138

package/src/control.js

@@ -1,5 +1,6 @@
 // Local control API (127.0.0.1 only) so the CLI and the MCP server can talk to
 // a running session. Discovery info is written to .quilt/daemon.json.
+import { readAccount } from './account.js'
 import http from 'node:http'
 import fs from 'node:fs'
 import path from 'node:path'
@@ -10,6 +11,14 @@ import { createRun, waitRun, endRun, secretNames, apiCall } from './secrets-clie
 import { runMailTool, MAIL_TOOLS } from './mail-tools.js'
 import { runWakeTool } from './wake-tool.js'
 import { wakeCheck } from './wake.js'
+import { seamAccess, sessionCredential } from './seam-access.js'
+import { runSessionSeamTool } from './session-seam.js'
+import { appSeamUrl } from './seam-url.js'
+import { squareFor } from './session-follow.js'
+import { shareWithPeople } from './session-layout3.js'
+import { QUILT_MOVE_TIMEOUT_MS } from './connection.js'
+import { FEATURES } from './protocol.js'
+import { currentVersion } from './releases.js'
 
 export async function startControl (session, extras = {}) {
   const token = crypto.randomBytes(16).toString('hex')
@@ -21,10 +30,45 @@ export async function startControl (session, extras = {}) {
   // Step 2 of joining (wake.js): an agent that hasn't chosen how Quilt wakes it is reminded with each answer.
   const wake = wakeCheck({
     fetchWake: async () => {
-      if (session.kind !== 'agent' || !extras.apiAuth) return { method: 'n/a' }
+      // A person's cloud AI (aiOf) is woken by its machine (autowork.js), never asked how.
+      if (session.kind !== 'agent' || session.aiOf || !extras.apiAuth) return { method: 'n/a' }
       return (await apiCall(await secretsApi(), 'GET', '/v1/agents/me/wake')).wake
     }
   })
+  // Seam's tools for this folder's AI sessions, in a session that is a quilt (session-seam.js), as
+  // this session's member: its person, or its agent on a cloud machine (seam-access.js).
+  // Kept on the session, so its AI's runs (autowork.js) read Seam as the same member.
+  if (extras.apiAuth && !session.apiAuth) session.apiAuth = extras.apiAuth
+  const seam = session.seamMember ? session.seamMember() : (session.seam || (session.seam = seamAccess({ api: () => appSeamUrl(), credential: sessionCredential({ apiAuth: extras.apiAuth, account: readAccount }) })))
+  const shared = new Set() // squares this person holds and has shared with the session's other people
+  const seamTool = async (b) => {
+    const q = session.quilt
+    if (!q || !q.id) return { content: [{ type: 'text', text: 'This session is not a quilt, so it has no Seam tools.' }], isError: true }
+    const branch = session.squareBranchKey ? session.squareBranchKey() : session.branchKey()
+    const at = squareFor(q, branch)
+    const square = at ? at.square : ((q.squares || {})[branch] || null)
+    const fail = (text) => ({ content: [{ type: 'text', text }], isError: true })
+    // The folder's live block on that square: the folder itself, following it in place, or a
+    // separate one (session-follow.js). Its commit is `quilt commit`'s: what the relay holds.
+    const f = session.squareFollower
+    const here = f && f.here && at && f.here.square === at.square ? f.here : null
+    const sep = f && f.following && at && f.following.square === at.square ? f.following : null
+    const live = (here && here.block) || (sep && sep.block) || null
+    if (here && !here.block && (b.tool === 'seam_commit' || b.tool === 'seam_merge')) return fail(here.problem ? `This folder can't follow its square yet (${here.problem}); Quilt tries again by itself.` : 'This folder is still starting to follow its square; try again in a moment.')
+    let c
+    try { c = await seam.client(q.id, square ? [square] : []) } catch (err) { return fail(err.message) }
+    // The folder's live work is read and committed as this member.
+    if (live) live.client = c.client
+    if (c.person && square && !shared.has(square)) {
+      shared.add(square)
+      // The square's holder shares it with the session's other people, so their AIs (working for them) write there too.
+      shareWithPeople(c.client, q.id, square, session.members || []).catch(() => shared.delete(square))
+    }
+    const next = at ? async () => session.conn.branchRequest({ op: 'quilt-next', token: c.token, branch }, { timeoutMs: QUILT_MOVE_TIMEOUT_MS }) : null
+    return runSessionSeamTool(String(b.tool || ''), b.args || {}, { client: c.client, quilt: q.id, square, live, next, branch })
+  }
+  // The app's square panel (ui-server.js) commits and merges through the same tools, as the same member.
+  session.seamTool = seamTool
   const routes = {
     'GET /status': (b) => {
       // To one of the AI sessions working through this app, "you" is that session (persona.js).
@@ -98,7 +142,8 @@ export async function startControl (session, extras = {}) {
     'POST /agent': (b) => { session.addAgent(b.client); return { ok: true } },
     'POST /feed': (b) => ({ entries: session.agentFeedFor(b.who, { limit: Math.min(Number(b.limit) || 40, 300) }) }),
     // The chronology: { path, by, since, task, limit } (see Session.historyQuery).
-    'POST /history': (b) => ({ entries: session.historyQuery(b) }),
+    // In a session linked to a quilt (Seam), the quilt's log too (Session.historyLinked): { entries, note? }.
+    'POST /history': (b) => session.historyLinked(b),
     'GET /tree': () => session.tree(),
     'POST /sharing': (b) => ({ on: session.setAgentSharing(b.on !== false) }),
     'GET /commits': () => session.commitStatus({ includeMe: false }),
@@ -106,6 +151,25 @@ export async function startControl (session, extras = {}) {
     // The relay's own list, with where each branch stands with GitHub (quilt_sync_status).
     'GET /sync-status': () => ({ branches: session.branchList || [], mine: session.branchKey ? session.branchKey() : '' }),
     'POST /branches/sync': () => session.syncBranchNow(),
+    // `quilt session migrate --dry-run`: what making the session a quilt would do (the relay's dry run).
+    'POST /quilt-plan': () => session.quiltPlan(),
+    // The quilt this session is (Seam), as the relay last said; null while it is not (session-seam.js).
+    'GET /quilt': () => ({ quilt: session.quilt || null }),
+    // One of Seam's tools (session-seam.js SEAM_SESSION_TOOLS), { tool, args }: an MCP tool result.
+    'POST /seam': (b) => seamTool(b),
+    // `quilt session migrate`: the relay makes the session a quilt, as its owner (their sign-in).
+    'POST /quilt-migrate': () => session.quiltMigrate(process.env.SEAM_TOKEN || (readAccount() || {}).token),
+    // "Make this a quilt" (`quilt session migrate`, the app's button): made a quilt and moved into its squares in one go.
+    'POST /quilt-make': () => session.quiltMake(process.env.SEAM_TOKEN || (readAccount() || {}).token),
+    // `quilt session migrate --switch` / `--back`: the session's files into its squares (layout 3), or back.
+    'POST /quilt-switch': () => session.quiltSwitch(process.env.SEAM_TOKEN || (readAccount() || {}).token),
+    'POST /quilt-unswitch': (b) => session.quiltUnswitch(process.env.SEAM_TOKEN || (readAccount() || {}).token, Array.isArray(b.carried) ? b.carried : []),
+    // `quilt session migrate --shadow <quilt>`: link the session to the quilt an import of its git remote fills (16 step 1).
+    'POST /quilt-shadow': (b) => session.quiltShadowLink(process.env.SEAM_TOKEN || (readAccount() || {}).token, b.quilt ?? null),
+    // `quilt session follow <folder>`: at layout 3, that folder follows this branch's square, live.
+    'POST /quilt-follow': (b) => session.quiltFollow(null, b.dir),
+    // `quilt commit <message>`: at layout 3, the square this folder follows is committed, as this person.
+    'POST /square-commit': (b) => session.squareCommit(String(b.message || '')),
     'POST /commit-request': (b) => session.requestCommit(b.message, { files: b.files == null ? null : b.files, description: b.description || '', task: b.task || null, via: b.via ? String(b.via) : null }),
     // quilt_commit: the relay commits the session's copy of the files to GitHub (relay-commit.js).
     'POST /agent-commits': (b) => session.setAgentCommits(b.mode),
@@ -209,7 +273,8 @@ export async function startControl (session, extras = {}) {
       const auth = await secretsApi()
       return { text: await runMailTool(b.tool, b.args && typeof b.args === 'object' ? b.args : {}, { call: (method, route, body) => apiCall(auth, method, route, body), room: session.room, me: session.actorName ? session.actorName(b.via) : session.name }) }
     },
-    'GET /info': (b) => ({ room: session.room, dir: session.root, name: session.actorName(b.via), person: session.name, kind: session.kind, invite: extras.invite || null, viewInvite: extras.viewInvite || null, access: session.access, pid: process.pid })
+    // `version` and `features` (what this app tells the relay it can do): the CLI checks them before a move (bin/quilt.js).
+    'GET /info': (b) => ({ room: session.room, dir: session.root, name: session.actorName(b.via), person: session.name, kind: session.kind, invite: extras.invite || null, viewInvite: extras.viewInvite || null, access: session.access, pid: process.pid, version: appVersion(), features: session.features || FEATURES })
   }
   const server = http.createServer(async (req, res) => {
     const reply = (code, body) => {
@@ -287,15 +352,76 @@ export function findDaemon (start = process.env.QUILT_DIR || process.cwd()) {
   }
 }
 
-/** `timeoutMs`: give up (throw) when the session hasn't answered by then (git's helpers: git must never wait on Quilt). */
-export async function call (daemon, method, route, body, { timeoutMs = 0 } = {}) {
-  const res = await fetch(`http://127.0.0.1:${daemon.port}${route}`, {
-    method,
-    headers: { authorization: `Bearer ${daemon.token}`, 'content-type': 'application/json' },
-    body: body ? JSON.stringify(body) : undefined,
-    signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined
+const appVersion = () => { try { return currentVersion() } catch { return '' } }
+
+/**
+ * `timeoutMs`: give up (throw) when the session hasn't answered by then (git's helpers: git must never wait on Quilt).
+ * Without it, it waits as long as the session takes (a move into Seam can take minutes): node:http, not fetch, whose
+ * own limit gave up after 5 minutes with nothing but "fetch failed". A session that can't be reached, or that
+ * stopped while answering, throws with what happened and what to do (`unreachable`).
+ */
+export function call (daemon, method, route, body, { timeoutMs = 0 } = {}) {
+  const data = body ? JSON.stringify(body) : null
+  return new Promise((resolve, reject) => {
+    let timer = null
+    let late = null // the timeout's error, once it fired: whatever the socket says after it
+    const failed = (err) => { clearTimeout(timer); reject(late || (err.name === 'TimeoutError' ? err : unreachable(daemon, err))) }
+    const req = http.request({
+      host: '127.0.0.1',
+      port: daemon.port,
+      path: route,
+      method,
+      // A connection each: a kept-alive one outlives an app that restarted, and the next call would find it cut.
+      agent: false,
+      headers: { authorization: `Bearer ${daemon.token}`, 'content-type': 'application/json', ...(data ? { 'content-length': Buffer.byteLength(data) } : {}) }
+    }, (res) => {
+      let raw = ''
+      res.setEncoding('utf8')
+      res.on('data', (c) => { raw += c })
+      res.on('error', failed)
+      res.on('end', () => {
+        clearTimeout(timer)
+        let json
+        try { json = JSON.parse(raw) } catch { return reject(new Error(`Quilt's app sent something that isn't an answer (HTTP ${res.statusCode})`)) }
+        if (res.statusCode < 200 || res.statusCode >= 300) return reject(Object.assign(new Error(json.error || `HTTP ${res.statusCode}`), { status: res.statusCode }))
+        resolve(json)
+      })
+    })
+    req.on('error', failed)
+    if (timeoutMs) {
+      timer = setTimeout(() => {
+        late = Object.assign(new Error(`The session in ${daemon.dir || 'this folder'} did not answer within ${Math.round(timeoutMs / 1000)} s`), { name: 'TimeoutError' })
+        req.destroy(late)
+      }, timeoutMs)
+    }
+    req.end(data || undefined)
   })
-  const json = await res.json()
-  if (!res.ok) throw new Error(json.error || `HTTP ${res.status}`)
-  return json
+}
+
+/**
+ * The control server couldn't be reached (nothing listens: the app closed this session or restarted), or
+ * it closed the connection before answering (the session stopped meanwhile: left, quit, or sent away by
+ * the relay). `cut` tells the two apart for callers that say more (a move into Seam goes on without the app).
+ */
+export function unreachable (daemon, err) {
+  const code = (err && err.code) || ''
+  const where = daemon && daemon.dir ? ` for ${daemon.dir}` : ''
+  const cut = code !== 'ECONNREFUSED'
+  const msg = cut
+    ? `Quilt's app${where} stopped answering in the middle of this (${code || err.message}): the session there stopped (left, Quilt quit or restarted, or the relay sent this app away to update). Open the session in Quilt again, then check before trying again.`
+    : `Quilt's app${where} isn't answering: the session there is not running any more (Quilt quit, restarted, or left it). Open it in Quilt (or run quilt join here), then try again.`
+  return Object.assign(new Error(msg), { unreachable: true, cut, code })
+}
+
+/**
+ * Why `quilt session migrate` (or --switch, --back) must not start through this app, from its GET /info,
+ * or null. The move ends by sending away every app that can't follow a square (no `quilt-folders`): the
+ * owner's own app too, cutting this command's answer off mid-way. An app older than this check says
+ * neither its features nor its version; `cliVersion` is the quilt command's own.
+ */
+export function moveRefusal (info, cliVersion = '') {
+  const features = info && typeof info.features === 'string' ? info.features.split(',') : null
+  if (features && features.includes('quilt-folders')) return null
+  const was = info && info.version ? ` (${info.version})` : ''
+  return `Quilt's app for this folder${was} is older than this quilt command${cliVersion ? ` (${cliVersion})` : ''}: the move sends it away to update at the end, and this command would lose its answer. Update Quilt, or restart it so it runs the new version, then run this again.`
 }

package/src/force-date.js

@@ -0,0 +1,27 @@
+// The forced date (Seam's plans/quilt-source-control/16, flag 9): QUILT_SOURCE_FORCE_AT=<date> on the
+// relay. Unset (or not a date), nothing happens. From the date on, a session still in git mode is
+// moved on without anyone losing work: one with no git remote becomes a quilt without history on its
+// owner's next open; one with a git remote that has not cut over keeps chat, tasks, the agent feed and
+// the audit trail, and its live file sync stops for good (git, its remote, clones and CI untouched).
+// Pure: no I/O (test/unit/force-date.test.js). The words are in ui/force-words.js, which the app loads too.
+export { syncStoppedWords, forceAheadWords } from './ui/force-words.js'
+
+/** The date as ms, or null when unset or not a date. */
+export function forceAtMs (env = process.env) {
+  const v = String(env.QUILT_SOURCE_FORCE_AT || '').trim()
+  if (!v) return null
+  const ms = Date.parse(v)
+  return Number.isFinite(ms) ? ms : null
+}
+
+/**
+ * What the date means for a session now: null (no date, not yet, or already a quilt in its squares),
+ * 'stop' (a git remote, not cut over: live sync stops), or 'migrate' (no git remote: its owner's next
+ * open makes it a quilt without history).
+ */
+export function forcedAction ({ at, now = Date.now(), layout = 2, remote = false, stopped = false }) {
+  if (stopped) return 'stop'
+  if (at == null || now < at || layout === 3) return null
+  return remote ? 'stop' : 'migrate'
+}
+

package/src/fsutil.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import crypto from 'node:crypto'
-import { makeIgnore, isIgnored, scopeIgnore, IGNORE_FILES } from './pathrules.js'
+import { isUtf8 } from 'node:buffer'
+import { makeIgnore, isIgnored, scopeIgnore, submodulePathsIn, IGNORE_FILES } from './pathrules.js'
 
 export { IGNORE_FILES } from './pathrules.js'
 export { MAX_TEXT_BYTES, MAX_BINARY_BYTES, LARGE_FILE_BYTES, MAX_STORED_BINARY_BYTES, CHAT_FILES, isIgnored, isSafeRelPath, globMatcher, patternsOverlap } from './pathrules.js'
@@ -27,6 +28,9 @@ export function closeWatcher (w) {
  */
 export function loadIgnore (root) {
   const ig = makeIgnore()
+  // A submodule (.gitmodules) is a repository of its own that git keeps as one commit id: its files
+  // are its own git's, never the session's (nor a Seam square's, which holds it as a gitlink).
+  for (const p of submodulePaths(root)) ig.add(`/${p}`)
   const visit = (dirRel) => {
     const dir = path.join(root, dirRel)
     for (const file of IGNORE_FILES) {
@@ -44,6 +48,11 @@ export function loadIgnore (root) {
   return ig
 }
 
+/** The folders .gitmodules names as submodules (`path = …`), as safe relative paths. */
+export function submodulePaths (root) {
+  try { return submodulePathsIn(fs.readFileSync(path.join(root, '.gitmodules'), 'utf8')) } catch { return [] }
+}
+
 /**
  * Resolves a relative path to an absolute one inside root, making sure no
  * symlinked parent directory points outside of it (or nowhere: a dangling
@@ -71,8 +80,9 @@ export function resolveInside (root, rel) {
 export function looksBinary (buf) {
   const n = Math.min(buf.length, 8000)
   for (let i = 0; i < n; i++) if (buf[i] === 0) return true
-  // Invalid UTF-8 is treated as binary so it round-trips byte for byte.
-  return !Buffer.from(buf.toString('utf8'), 'utf8').equals(buf)
+  // Invalid UTF-8 is treated as binary so it round-trips byte for byte. Checked in place: decoding
+  // and encoding every file again to compare made two copies of each one.
+  return !isUtf8(buf)
 }
 
 export function sha1 (buf) {

package/src/gitstate.js

@@ -916,8 +916,44 @@ export async function committedAs (root, sha, rel, text) {
   return blob.trim() !== '' && blob.trim() === hashed.trim()
 }
 
-export async function blobAt (root, sha, rel) {
-  const out = await run(root, ['cat-file', '--filters', `${sha}:${rel}`], { buffer: true })
+/** Which of `paths` are links (mode 120000) at commit `sha`: a Set, or null when git can't say. */
+export async function linksAt (root, sha, paths) {
+  if (!paths.length) return new Set()
+  const out = await run(root, ['ls-tree', '-z', sha, '--', ...paths])
+  if (out === null) return null
+  return new Set(out.split('\0').filter((l) => l.startsWith('120000 ')).map((l) => l.slice(l.indexOf('\t') + 1)))
+}
+
+/**
+ * The paths a folder's branch changed since it left the remote's default branch: `committed`, from
+ * the merge base of HEAD and origin/HEAD (else origin/main, origin/master) to HEAD; `uncommitted`,
+ * what differs from HEAD (staged or not, deletions too) and files git does not track and does not
+ * ignore. `gitDir` reads a .git kept elsewhere (set aside while the folder follows a square). Two
+ * Sets, or null when git can't say (no remote default branch, no common history).
+ */
+export async function ownSinceFork (root, { gitDir = null } = {}) {
+  const opts = gitDir ? { env: { GIT_DIR: gitDir, GIT_WORK_TREE: root } } : {}
+  let main = ''
+  for (const ref of ['refs/remotes/origin/HEAD', 'refs/remotes/origin/main', 'refs/remotes/origin/master']) {
+    main = ((await run(root, ['rev-parse', '-q', '--verify', `${ref}^{commit}`], opts)) || '').trim()
+    if (main) break
+  }
+  if (!main) return null
+  const fork = ((await run(root, ['merge-base', 'HEAD', main], opts)) || '').trim()
+  if (!fork) return null
+  const lists = [
+    await run(root, ['diff', '--no-renames', '--no-ext-diff', '--name-only', '-z', fork, 'HEAD'], opts),
+    await run(root, ['diff', '--no-renames', '--no-ext-diff', '--name-only', '-z', 'HEAD'], opts),
+    await run(root, ['ls-files', '--others', '--exclude-standard', '--exclude=/.quilt/', '-z'], opts)
+  ]
+  if (lists.some((l) => l === null)) return null
+  const names = (l) => l.split('\0').filter(Boolean)
+  return { committed: new Set(names(lists[0])), uncommitted: new Set([...names(lists[1]), ...names(lists[2])]) }
+}
+
+/** A file's bytes at commit `sha` (null when git can't say); `gitDir` reads from a .git kept elsewhere (set aside while the folder follows a square). */
+export async function blobAt (root, sha, rel, { gitDir = null } = {}) {
+  const out = await run(root, ['cat-file', '--filters', `${sha}:${rel}`], { buffer: true, ...(gitDir ? { env: { GIT_DIR: gitDir, GIT_WORK_TREE: root } } : {}) })
   return out === null ? null : out
 }
 

package/src/history.js

@@ -252,6 +252,22 @@ export function queryHistory (entries, { path, by, since, task, limit = 50 } = {
   return list
 }
 
+export const LEGACY_DAYS = 90
+
+/**
+ * The chronology once the session became a quilt at `at` (an ISO date, meta.quilt.at): entries from
+ * before then are its legacy tail (Seam's plans/quilt-source-control/16), marked `legacy: true` for
+ * LEGACY_DAYS and then left out. Not a quilt (no `at`): the entries as they are.
+ */
+export function legacyTail (entries, { at, now = Date.now(), history = false } = {}) {
+  const t = at ? Date.parse(at) : NaN
+  if (!Number.isFinite(t)) return entries
+  if (now - t > LEGACY_DAYS * 24 * 60 * 60 * 1000) return entries.filter((e) => !(e && e.ts < t))
+  // With history (the quilt is the session's imported git remote), git's own writes before then
+  // (pulls, first copies) are the log's imported patches: they are dropped, not shown twice.
+  return entries.filter((e) => !(history && e && e.ts < t && (e.pulled || e.seed))).map((e) => e && e.ts < t ? { ...e, legacy: true } : e)
+}
+
 function ago (ts, now) {
   const s = Math.max(0, Math.round((now - ts) / 1000))
   if (s < 60) return `${s}s ago`
@@ -265,10 +281,18 @@ export function formatHistory (list, { withDiff = false, now = Date.now() } = {}
   if (!list.length) return 'No changes match.'
   const out = []
   for (const e of list) {
+    if (e.seam) {
+      // A commit in the quilt's log (quilt-history.js): who, which patch, its message, how many files.
+      const where = e.patch ? `patch ${e.patch.line && e.patch.line !== 'main' ? `${e.patch.line}:` : ''}${e.patch.no}` : `commit ${e.short || String(e.commit || '').slice(0, 12)}`
+      const n = e.files ? ` (${e.files} file${e.files === 1 ? '' : 's'})` : ''
+      out.push(`[${ago(e.ts, now)}] ${e.by} committed ${where}: ${e.message || '(no message)'}${n}${e.task ? ` [task ${e.task.id}]` : ''}`)
+      if (withDiff && e.diff) out.push(e.diff, '')
+      continue
+    }
     const span = e.from && e.ts - e.from > 60000 ? ` over ${Math.round((e.ts - e.from) / 60000)}m` : ''
     const what = e.detail ? ` (${e.detail})` : ''
     const task = e.task ? ` for "${e.task.title}" [${e.task.id}]` : ''
-    out.push(`[${ago(e.ts, now)}] ${e.by} ${e.kind} ${e.path}${what}${e.pulled ? ' by pulling from git' : ''}${span}${task}`)
+    out.push(`[${ago(e.ts, now)}] ${e.by} ${e.kind} ${e.path}${what}${e.pulled ? ' by pulling from git' : ''}${span}${task}${e.legacy ? ' (before the session became a quilt)' : ''}`)
     if (withDiff && e.diff) out.push(e.diff, '')
   }
   return out.join('\n').replace(/\n+$/, '')

package/src/mcp.js

@@ -46,6 +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, 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)
@@ -118,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
@@ -199,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) : ''
@@ -221,12 +245,51 @@ export async function runMcp () {
     return `${label ? `Assigned to ${label}.` : 'Unassigned.'}${files}`
   }
 
+  // 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 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('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.',
     inputSchema: {}
   }, () => withDaemon(async (d) => {
     const st = await call(d, 'GET', '/status')
-    return renderStatus(st, { asAi: taskReader(st).asAi, mentionYours: true })
+    const q = await quiltNow()
+    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', {
@@ -281,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')) }))
@@ -719,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 }
@@ -1041,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', {
@@ -1111,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)]
 }