heyquilt 0.3.122 → 0.3.140

package/src/mcp.js

@@ -3,7 +3,6 @@
 // and their AIs are doing, coordinate, and even join or start a session by
 // itself. It forwards to the local `quilt join` process for the project, or
 // runs the session itself when the agent joins on its own.
-import { syncStatusText, SYNC_STATUS_DESCRIPTION } from './sync-words.js'
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod'
@@ -18,7 +17,6 @@ import os from 'node:os'
 import { findDaemon, call as rawCall } from './control.js'
 import { parentPids } from './hooks.js'
 import { renderMessage, renderStatus } from './status.js'
-import { branchesMarkdown, upstreamLine, describeBranchSync } from './branches.js'
 import { DEFAULT_KEY } from './branchdocs.js'
 import { formatTasks, columnName, assigneeLabel, renderNextTask, COLUMNS } from './tasks.js'
 import { formatTaskDetails, MAX_COMMENT } from './task-comments.js'
@@ -33,20 +31,16 @@ import { quiltHome } from './legacy.js'
 import { TASK_WORKFLOW, pickupBrief, doneRefusal, verifiedEnough, verifiedLine, qaRefusal, qaNotesEnough, qaNotesLine, MAX_VERIFIED } from './agent-task-workflow.js'
 import { formatHistory } from './history.js'
 import { releaseWords } from './release-words.js'
-import { describeCommitRequests, REQUEST_COMMIT_DESCRIPTION } from './commit.js'
-import { POLICY_WORDS, unpublishedRefusal } from './relay-commit.js'
 import { renderInbox, describeEvent, INBOX_HOW } from './inbox.js'
 import { renderConversation, renderContext, CONVERSATION_DESCRIPTION } from './conversation.js'
 import { renderChatAbout, renderUnanswered, heldRefusal, renderQueueNotice, renderQueued, CHAT_RULES, RE_HELP, PERSON_CHAT } from './duties.js'
 import { describeSubscription, describeWebhookTest, COALESCE_HELP, WEBHOOK_EVENTS } from './webhooks.js'
 import { UpdateCheck } from './update-check.js'
 import { getSettings } from './settings.js'
-import { mergeAction } from './merges.js'
-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)
@@ -85,19 +79,17 @@ export const MCP_INSTRUCTIONS =
   '(open tasks assigned to you are listed first), add work with quilt_add_task, assign it with quilt_assign_task, ' +
   'and move a task with quilt_move_task when you start or finish it; quilt_task reads one in full with its comments, and quilt_comment_task leaves a note or handoff on it. ' +
   'quilt_history tells you who changed which file, when, with the diff: read it for the files you are about to touch. ' +
-  'If git refuses to pull because untracked files would be overwritten, those files came from the session: quilt_status lists them under Pulling (and whether they match); make way and pull with rm <files> && git pull --autostash, and Quilt keeps them for everyone. ' +
   'If the person you work for lets their AI pick up work by itself (their cloud AI, on the cloud machine they connected), finishing (quilt_set_work done, a task to QA or Done) hands you your next task from the board: start it. ' +
   'Before you change files, call quilt_before_edit with their paths: it tells you whether each is yours to edit (claiming free ones for you, so partners are refused instead of overwriting you), ' +
   'and shows what people said about those files in chat, so you know what was asked or planned before you change them. ' +
   'Do not edit a file it refuses: ask for it in its file queue with quilt_request_file (a title like "Working on <what> for <task>" and up to 300 characters on your plan) and carry on with other work; you are woken when it is handed to you, with the holder\'s context. ' +
   'Claims also follow your edits: a file you change that nobody holds is claimed for you until you finish. ' +
   'If an edit of yours was undone because someone else holds the file, your next quilt answer says so: do not retry; ask for it with quilt_request_file and carry on with other work. ' +
-  'In a folder that is a git repository, your edits to a file stay in a box until you commit them: everyone sees the change, but it is only in your folder, so nobody else\'s git can commit it. Committing the file (or putting it back as it was) opens the box by itself; finishing or releasing does not. ' +
-  'quilt_unpack shares a box early when someone needs it: decide yourself, and ask your person first for a large, risky or critical change or when the project\'s rules say so. A file boxed by someone else (quilt_status lists Boxed work) is not in your folder yet: do not build on it; ask for it with quilt_request_file. ' +
+  'A boxed file\'s edits are only in its holder\'s folder; quilt_unpack shares a box when someone needs it: decide yourself, and ask your person first for a large, risky or critical change or when the project\'s rules say so. A file boxed by someone else (quilt_status lists Boxed work) is not in your folder yet: do not build on it; ask for it with quilt_request_file. ' +
   'When someone waits in the file queue for a file you hold, every quilt answer says so: finish the change you are making, then hand it off with quilt_handoff and your context (what you changed, what is left, gotchas). ' +
   'Until you do, you cannot finish (quilt_set_work done, a task to Done) or release that file. A claim whose holder does nothing in the session for 20 minutes goes to the next one waiting, or is released. ' +
   'For an agent of its own (not a person\'s AI session), every quilt answer starts with anything new for it (direct messages, mentions, tasks handed to it): act on it. ' +
-  'These rules are enforced for agents: while someone who messaged or mentioned you is waiting for an answer, the tools that move work on (claims, tasks, focus, merges, commits, quilt_set_work) refuse until you answer them with quilt_message; ' +
+  'These rules are enforced for agents: while someone who messaged or mentioned you is waiting for an answer, the tools that move work on (claims, tasks, focus, quilt_set_work) refuse until you answer them with quilt_message; ' +
   'an edit to a file someone else holds is undone. ' +
   'When you start a piece of work, call quilt_set_work with "working" and a note of what it is (with quilt_set_focus), so the loom shows you stitching; when you finish, call it with "done": it lets go of the files claimed for you. ' +
   'Claim ahead (quilt_claim) only for a larger change across several files. ' +
@@ -105,25 +97,36 @@ export const MCP_INSTRUCTIONS =
   'If quilt_status starts with While you were away, the session changed since this folder last synced: read quilt_history for those files before editing them. ' +
   'For an agent of its own, mentions of it (@yourname) in chat, direct messages to it and tasks handed to it wait in quilt_inbox: read it when you start, and act on each one. ' +
   'Each comes with the conversation before it with its sender; when a message refers to something earlier you do not have, read back with quilt_conversation before you answer, never guess. ' +
-  'Git works here as usual: commit only the files you changed and push yourself. When the relay serves the session\'s git, your folder\'s origin is the relay: git signs in with your Quilt pass, and the relay checks each push (the session owner\'s policy, never a force-push, no ignored files) and puts it on GitHub, replayed onto GitHub\'s head if it moved (your folder follows). Otherwise your folder signs in to GitHub through Quilt (a short-lived token for this repository). Either way pushes stay within the owner\'s policy: by default branches of your own. Taking a task (quilt_move_task to doing) puts your folder on quilt/<you>/<task>; push there and Quilt opens the pull request for the task; move the task to QA when it is done and tested; Done merges the pull request once its checks pass (a person moves it to Done unless the owner lets agents push to any branch). When agents may not commit, ask a person with quilt_request_commit. ' +
-  'When a branch syncs with GitHub (quilt_branches says so), pushes and merges on GitHub come into the session by themselves; nothing goes to GitHub until someone commits and pushes. A file GitHub and the session both changed is merged by Quilt on its own (the newer edit stays where both changed the same lines). Releasing a file only lets go of your claim: it publishes nothing by itself. ' +
-  'Work only in the session has not shipped: push before you move a task to QA. Pushes and merges on GitHub reach the session within seconds: never pull by hand. ' +
   'When you are about to answer someone in chat, quilt_typing shows them you are typing; sending clears it. ' +
   'Chat: ' + CHAT_RULES.replace(/^Send a chat message\. /, '') + ' A message that needs nothing back is settled with quilt_inbox (no_reply: [its id]), not answered. ' +
   WAKE_STEP + ' On a computer the ways include a command Quilt runs on each event (`quilt join --on-mention`), `quilt inbox --wait`, the quilt://inbox resource (MCP push), a webhook, email and a schedule. ' +
   'In the session you are your person: your messages, claims and tasks are theirs, and people see you as them. "<person>\'s AI" ("Daniel\'s AI") is only that person\'s cloud AI, when they connected one (Quilt runs their own AI tool for them on their own cloud machine): write to it by that name. Nothing written or handed to "<person>\'s AI" comes to you; when your person asks you to work on tasks, take them from the board (quilt_tasks). ' +
   PERSON_CHAT + ' ' +
-  'Share what you are doing with quilt_share: when you start on a request (request and your plan) and when you finish (what you did and the files you changed). Partners see it in their feed, it puts your work on the task board, and it tells the host not to commit under you. ' +
+  'Share what you are doing with quilt_share: when you start on a request (request and your plan) and when you finish (what you did and the files you changed). Partners see it in their feed, and it puts your work on the task board. ' +
   'When Claude Code is started with the quilt channel, they arrive on their own as <channel source="quilt"> events while you work: treat each like a request from that person, answer with quilt_message, and take a task with quilt_move_task. ' +
   RUN_GUIDE + ' ' +
   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 +203,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 +234,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 +277,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', {
@@ -283,18 +324,15 @@ export async function runMcp () {
     const brief = await call(d, 'POST', '/tasks/brief', { id })
     if (column === 'qa' && !qaNotesEnough(qaNotes)) return qaRefusal({ task: brief.task, checklist: brief.checklist })
     if (column === 'done' && !verifiedEnough(verified)) return doneRefusal({ task: brief.task, checklist: brief.checklist })
-    // An agent's finished work goes to git before QA, when it can commit itself (relay-commit.js); Done merges its pull request (the daemon asks the relay).
-    if (column === 'qa') {
-      const u = await call(d, 'POST', '/unpublished', { task: id, column }).catch(() => null)
-      if (u && u.unpublished && u.unpublished.length) return unpublishedRefusal(brief.task, u.unpublished, column, [])
-    }
     const patch = { id, column }
     if (column === 'qa') patch.qaNotes = qaNotes
     if (column === 'done') patch.verified = verified
-    const { task, merged, branch } = await call(d, 'POST', '/tasks/update', patch)
-    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)
-    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)
+    const { task } = 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 } })
+    if (column === 'qa') return `Moved "${task.title}" to QA. Notes: ${qaNotesLine(task)}` + await nextUp(d)
+    if (column === 'done') return `Moved "${task.title}" to Done. 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')) }))
 
@@ -448,39 +486,6 @@ export async function runMcp () {
     return n ? `Withdrew your request for ${rel}.` : `You had not asked for ${rel}.`
   }))
 
-  // Quilt merges on its own (session.js autoSettle): these say what it did, and what waits for a holder.
-  const mergeLine = (m, me) => {
-    const who = m.by === me ? 'you' : m.by
-    const what = m.state !== 'done' ? `${who} ${mergeAction(m)}; ${m.claimedBy || 'someone'} has it claimed, and it goes in, merged by Quilt, when they let go`
-      : m.reason || 'merged by Quilt'
-    return `- \`${m.path}\`: ${what}`
-  }
-
-  server.registerTool('quilt_merges', {
-    description: 'What Quilt merged on its own recently: files changed in two places (offline, by a pull or on GitHub, and in the session). Quilt combines them itself; where both changed the same lines the newer edit stays and the other lines are kept in the file\'s history. Nothing here is for you to settle.',
-    inputSchema: {}
-  }, () => withDaemon(async (d) => {
-    const { merges } = await call(d, 'GET', '/merges')
-    const me = (await call(d, 'GET', '/info')).name
-    if (!merges.length) return 'Quilt has merged nothing lately.'
-    return `Quilt merges on its own; nothing to do:\n${merges.map((m) => mergeLine(m, me)).join('\n')}`
-  }))
-
-  // Kept for guides and prompts from before Quilt merged on its own.
-  server.registerTool('quilt_resolve_merge', {
-    description: 'Not needed any more: Quilt merges on its own. Kept so older instructions get an answer.',
-    inputSchema: { id: z.string().optional(), how: z.string().optional() }
-  }, () => ({ content: [{ type: 'text', text: 'Quilt merges on its own now: there is nothing to settle.' }] }))
-
-  server.registerTool('quilt_clash', {
-    description: CLASH_DESCRIPTION,
-    inputSchema: clashSchema(z)
-  }, (args) => withDaemon(async (d) => {
-    const r = await call(d, 'POST', '/clash', args)
-    if (r && r.ok === false) throw new Error(r.text)
-    return r && r.text ? r.text : 'Done.'
-  }))
-
   server.registerTool('quilt_message', {
     description: CHAT_RULES + ' Set "to" to message one person directly.',
     inputSchema: {
@@ -730,6 +735,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 }
@@ -831,18 +838,8 @@ export async function runMcp () {
     return { content: [{ type: 'text', text: left ? 'Left the session. The files stay where they are.' : 'You have not joined a session from here.' }] }
   })
 
-  // ------------------------------------------------------ commit timing --
-
-  const describeCommits = (c) => {
-    const lines = []
-    lines.push(c.ready ? '✅ Everyone else\'s AI is idle: a good moment to commit.' : `⏳ Still working: ${c.busy.map((b) => b.why).join('; ')}`)
-    lines.push(describeCommitRequests(c, { canCommit: !!c.canCommit }))
-    if (c.open.length) lines.push('A request committed outside Quilt (with git by hand) is closed with quilt_commit_request_done.')
-    return lines.join('\n')
-  }
-
   server.registerTool('quilt_set_work', {
-    description: 'Tell everyone whether you (this agent) are working or done, so people know when it is safe to commit. Set "working" when you start a task and "done" when you finish: ' +
+    description: 'Tell everyone whether you (this agent) are working or done, so people know what is in progress. Set "working" when you start a task and "done" when you finish: ' +
       '"done" lets go of the files claimed for you while you edited. Like every tool that moves work on, it is refused while someone is waiting for an answer from you.',
     inputSchema: {
       state: z.enum(['working', 'done']),
@@ -926,95 +923,6 @@ export async function runMcp () {
     return lines.join('\n') + (said ? `\n\n${said}` : '') + '\n\nRe-read each file right before you edit it.'
   }))
 
-  server.registerTool('quilt_request_commit', {
-    description: REQUEST_COMMIT_DESCRIPTION,
-    inputSchema: {
-      message: z.string().max(500).optional().describe('The commit message: what the change does (a task\'s title by default)'),
-      files: z.array(z.string().max(1024)).max(500).optional().describe('The files you changed, relative to the project\'s top folder (deleted ones too)'),
-      task: z.string().max(40).optional().describe('The task this work was for: its title is the message and its changes the files, unless you give them')
-    }
-  }, ({ message, files, task }) => withDaemon(async (d) => {
-    const r = await call(d, 'POST', '/commit-request', { message, files, task })
-    return `Asked for a commit [${r.id}] of ${r.files.length} file${r.files.length === 1 ? '' : 's'}: ${r.files.slice(0, 12).join(', ')}${r.files.length > 12 ? ', …' : ''}.\n${r.committer}`
-  }, { gate: gateFor('quilt_request_commit') }))
-
-  server.registerTool('quilt_agent_commits', {
-    description: 'Session owner only: git for this session, for everyone in it (people and agents push with git through one GitHub connection, nothing for them to set up). "off": off for everyone (nobody pushes through Quilt; agents ask a person with quilt_request_commit, who commits from the app); "branches" (the default): on, agents push to branches of their own, quilt/<agent>/…, with pull requests for people to merge; "any": on, agents push to any branch, the session\'s own included. People push any branch while it is on. A rule its org, team or workspace sets is a ceiling: you may be stricter, never looser. For a hard limit on main, protect the branch on GitHub.',
-    inputSchema: { mode: z.enum(['off', 'branches', 'any']) }
-  }, ({ mode }) => withDaemon(async (d) => {
-    const r = await call(d, 'POST', '/agent-commits', { mode })
-    return `Now ${POLICY_WORDS[r.agentCommits]}.`
-  }))
-
-  server.registerTool('quilt_github_sync', {
-    description: 'Session owner only: whether this session syncs with GitHub through the relay (on by default once a GitHub connection covers the repository): pushes and merges on GitHub come into the session within seconds, and commits made in Quilt (quilt_git_commit) go through the relay. Nothing reaches GitHub without a commit. Off: the session keeps its files to itself, and people commit with git as before.',
-    inputSchema: { on: z.boolean() }
-  }, ({ on }) => withDaemon(async (d) => {
-    const r = await call(d, 'POST', '/github-sync', { on })
-    return r.githubSync ? 'This session syncs with GitHub.' : 'Sync with GitHub is off for this session.'
-  }))
-
-  server.registerTool('quilt_adopt_work', {
-    description: 'For people (and their AI): take the work on an agent\'s branch (quilt/<agent>/…, everything it changed since it started) into the branch you are on, as your edits, pushed to GitHub at once as one commit. This is how agents\' work reaches GitHub when the owner keeps agents off it ("off"), and a way to take a branch\'s work without a pull request.',
-    inputSchema: { from: z.string().min(1).max(200).describe('The agent\'s branch, e.g. quilt/grok/login-page') }
-  }, ({ from }) => withDaemon(async (d) => {
-    const r = await call(d, 'POST', '/adopt', { from })
-    return r.state === 'pushed' ? `Adopted ${from}: pushed as ${String(r.sha).slice(0, 7)} (${(r.changed || []).length} files).` : r.state === 'nothing' ? `Nothing to adopt: ${r.why || 'no changes'}.` : `Adopted into the session; not pushed yet (${r.state}${r.why ? `: ${r.why}` : ''}).`
-  }))
-
-  server.registerTool('quilt_branches', {
-    description: 'The session\'s git branches: which branch each member\'s folder is on, which AI sessions and worktrees work on which branch, how each stands against its upstream (behind, ahead, diverged), and who committed last. Read it before you branch, merge or push.',
-    inputSchema: {}
-  }, () => withDaemon(async (d) => {
-    const { branches, git } = await call(d, 'GET', '/branches')
-    const here = git && git.branch ? `This folder is on \`${git.branch}\`${git.upstream ? ` (${upstreamLine(git.upstream)})` : ''}.\n\n` : ''
-    return here + branchesMarkdown(branches || [], { limit: 40 })
-  }))
-
-  server.registerTool('quilt_sync_status', {
-    description: SYNC_STATUS_DESCRIPTION,
-    inputSchema: {}
-  }, () => withDaemon(async (d) => { const r = await call(d, 'GET', '/sync-status'); return syncStatusText(r.branches || [], { mine: r.mine || '' }) }))
-
-  server.registerTool('quilt_sync_branch', {
-    description: 'Bring commits made outside the session into it now: fetches this folder\'s upstream (say origin/main after a PR merged, or a push from a worktree) and moves the branch forward, with the session\'s uncommitted work merged in. Quilt also does this by itself about once a minute; call it right after you push or merge elsewhere. It says when the fetch fails (git has no credentials here, say). A folder that is not a git clone, or can\'t fetch, asks the relay to bring the commits in from GitHub instead. Files that both the commits and the session changed are merged by Quilt on its own.',
-    inputSchema: {}
-  }, () => withDaemon(async (d) => describeBranchSync(await call(d, 'POST', '/branches/sync'))))
-
-  server.registerTool('quilt_github_token', {
-    description: 'Session owner only: set (or clear, with an empty token) the GitHub token the relay uses to bring commits in from a private repository while no folder can, to load branches from it for hosted agents, and, when it can write, to commit the work of agents that have no folder (hosted agents\' quilt_git_commit). A fine-grained token for the repository with "Contents: Read" brings commits in; "Contents: Read and write" and "Pull requests: Read and write" let hosted agents commit and open pull requests, within what quilt_agent_commits allows. It goes to the relay and stays there: never shown again. Agents with a folder don\'t need it: their git signs in through the session\'s GitHub connection.',
-    inputSchema: { token: z.string().max(300).describe('The token (github_pat_… or ghp_…), or "" to remove it') }
-  }, ({ token }) => withDaemon(async (d) => {
-    const r = await call(d, 'POST', '/github-token', { token })
-    return r.githubToken ? 'Saved the GitHub token on the relay. It looks at the session\'s branches again now.' : 'Removed the GitHub token.'
-  }))
-
-  server.registerTool('quilt_commit_status', {
-    description: 'Is it a good moment to commit? Lists open commit requests and whose AI is still working (not counting yours).',
-    inputSchema: {}
-  }, () => withDaemon(async (d) => describeCommits(await call(d, 'GET', '/commits'))))
-
-  server.registerTool('quilt_wait_until_idle', {
-    description: 'Wait until every other AI in the session is idle (or the timeout passes), then report. Use it before committing, or when you need everyone else to finish first.',
-    inputSchema: { timeout_seconds: z.number().int().min(5).max(1800).optional().describe('How long to wait at most (default 300)') }
-  }, ({ timeout_seconds: timeout = 300 }) => withDaemon(async (d) => {
-    const until = Date.now() + timeout * 1000
-    let c = await call(d, 'GET', '/commits')
-    while (!c.ready && Date.now() < until) {
-      await new Promise((r) => setTimeout(r, 3000))
-      c = await call(d, 'GET', '/commits')
-    }
-    return `${c.ready ? '' : `Stopped waiting after ${timeout}s.\n`}${describeCommits(c)}`
-  }, { gate: gateFor('quilt_wait_until_idle') }))
-
-  server.registerTool('quilt_commit_request_done', {
-    description: 'Close commit requests whose work was committed with git (or isn\'t needed any more). Without an id, every open request is closed.',
-    inputSchema: { id: z.string().optional().describe('One request id; omit for all open ones') }
-  }, ({ id }) => withDaemon(async (d) => {
-    const { done } = await call(d, 'POST', '/commit-request/done', { id })
-    return done ? `Marked ${done} commit request${done === 1 ? '' : 's'} done.` : 'No open commit requests.'
-  }, { gate: gateFor('quilt_commit_request_done') }))
-
   server.registerTool('quilt_project_rules', {
     description: 'The project\'s rules for AI and its design system, the same whatever tool you run in: AGENTS.md (root and folders, else CLAUDE.md), Cursor rules that always apply, and DESIGN.md (or the file AGENTS.md names). Read it before your first change in a session.',
     inputSchema: {}
@@ -1052,8 +960,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 +1030,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