heyquilt 0.3.138 → 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,16 +31,12 @@ 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'
@@ -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,15 +97,12 @@ 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 + ' ' +
@@ -335,21 +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)
+    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 } }) + (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.` : '')
-    // 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)
+    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')) }))
 
@@ -503,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: {
@@ -888,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']),
@@ -983,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: {}

package/src/relay-ask.js

@@ -1,13 +1,10 @@
 // Questions for the relay, "Quilt" in chat. Anyone in a session can @mention @Quilt (or message it directly)
-// and it answers from what it knows: how the session's branches stand against git, who is
-// connected, which branches it keeps, and (for the owner) trimming branches nobody uses. No
+// and it answers from what it knows: who is connected, which branches it keeps, and (for the owner) trimming branches nobody uses. No
 // model runs here: each question is matched by its words and answered by code. Pure but for
 // `room`, which the relay passes in (server.js answerRelay).
 
-import { RELAY_BY, isRelay } from './branches.js'
 import { mentioned } from './inbox.js'
-import { chosenBranches } from './relay-prune.js'
-import { RELAY_QUESTIONS, RELAY_OLD_NAMES } from './ui/chat.js'
+import { RELAY_QUESTIONS, RELAY_OLD_NAMES, RELAY_NAME as RELAY_BY, isRelay } from './ui/chat.js'
 
 export { RELAY_QUESTIONS }
 
@@ -25,7 +22,6 @@ export function asksRelay (m) {
 export function questionOf (text) {
   const t = String(text || '').replace(/@(the relay|quilt)\b/gi, ' ').toLowerCase()
   if (/\b(trim|prune|clean ?up|remove)\b/.test(t)) return 'trim'
-  if (/\b(git|github|upstream|commits?|behind|synced?)\b/.test(t)) return 'git'
   if (/\b(members?|connected|online|who|people|agents?)\b/.test(t)) return 'members'
   if (/\bbranch(es)?\b/.test(t)) return 'branches'
   return 'help'
@@ -53,32 +49,6 @@ function whoIsOn (room) {
   return on
 }
 
-function gitAnswer (room, now) {
-  const ups = room.meta.upstreams || {}
-  const lines = []
-  for (const key of Object.keys(room.meta.branches)) {
-    const r = ups[key]
-    if (!r || !r.name) continue
-    const parts = [`${key} follows ${r.name}${r.repo ? ` (${r.repo})` : ''}`]
-    if (r.sha) parts.push(`at ${r.sha.slice(0, 7)}${r.checkedAt ? `, checked ${ago(r.checkedAt, now)}` : ''}`)
-    if (r.brought && r.brought.at) parts.push(`brought in ${plural(r.brought.count || 0, 'commit')} ${ago(r.brought.at, now)}`)
-    if (r.clash && r.clash.task) parts.push(`waiting on merge task ${r.clash.task}`)
-    if (r.problem) parts.push(`problem: ${typeof r.problem === 'string' ? r.problem : r.problem.message || 'see the branch menu'}`)
-    const why = r.github && GITHUB_BLOCKED[r.github.state]
-    if (why) parts.push(`agents can't commit: ${why}`)
-    lines.push(parts.join('; '))
-  }
-  if (!lines.length) return 'No branch here follows a GitHub repository yet. It starts when a member with a git folder joins.'
-  return lines.length === 1 ? `${lines[0]}.` : `Against git:\n${lines.map((l) => `- ${l}`).join('\n')}`
-}
-
-// Why agents can't commit to a branch's repository, by its GitHub connection's state (relay-upstream.js noteConnection).
-const GITHUB_BLOCKED = {
-  'not-connected': 'nobody here has connected GitHub',
-  'not-installed': 'the Quilt app isn\'t installed on the repository',
-  'no-access': 'the connected GitHub account can\'t write to it'
-}
-
 function membersAnswer (room) {
   const people = new Set()
   for (const ws of room.conns.keys()) { const n = room.names.get(ws); if (n) people.add(n) }
@@ -116,38 +86,6 @@ export function unusedBranches (room, now = Date.now()) {
 }
 
 /** Branch names that are never trimmed for being merged: the trunk itself, whatever the session calls its default. */
-const TRUNKS = new Set(['main', 'master'])
-
-/**
- * The branches whose work is merged and can leave the session (Room.trimMergedBranches), so a
- * session never fills its MAX_BRANCHES with finished work. A branch counts when its pull request
- * was merged on GitHub (its upstream record has `merged`, from notePull, reviewPulls or a merge
- * made in Quilt) and nothing was written on it in the session since (`changed` no later than the
- * merge). Never the default branch, main or master, the branch it merged into, a branch someone
- * is on, holds a file on, or a hosted agent chose, nor one with session edits still waiting to go
- * to GitHub. Git keeps every branch: only the relay's copy goes.
- */
-export function mergedBranches (room, now = Date.now()) {
-  const on = whoIsOn(room)
-  const claimed = new Set(Object.values(room.meta.claims || {}).map((c) => room.branchOf(c)))
-  const chosen = chosenBranches(room, now) // a hosted agent's choice holds a branch worked on this week
-  const ups = room.meta.upstreams || {}
-  const bases = new Set()
-  for (const rec of Object.values(ups)) if (rec && rec.merged && rec.merged.into) bases.add(room.resolveKey ? room.resolveKey(rec.merged.into) : rec.merged.into)
-  return Object.entries(room.meta.branches)
-    .filter(([k, b]) => {
-      const rec = ups[k]
-      const m = rec && rec.merged
-      if (!m || !m.into || !(m.at > 0)) return false
-      if (k === room.defaultKey || TRUNKS.has(k) || TRUNKS.has(rec.ref) || bases.has(k) || rec.ref === m.into) return false
-      if (on.has(k) || claimed.has(k) || chosen.has(k)) return false
-      const pending = room.meta.sync && room.meta.sync[k] && room.meta.sync[k].pending
-      if (pending && Object.keys(pending).length) return false // session edits not on GitHub yet (relay-outbound.js)
-      return !(b && b.changed > m.at) // written on after the merge: that work isn't merged
-    })
-    .map(([k]) => k)
-}
-
 function trimAnswer (room, asker, now) {
   if (!asker.mayTrim) return 'Only the session owner can trim branches.'
   const gone = unusedBranches(room, now)
@@ -156,7 +94,7 @@ function trimAnswer (room, asker, now) {
   room.saveMeta()
   room.broadcastBranches()
   room.log(`[${room.name}] ${asker.name} trimmed ${plural(gone.length, 'unused branch')}: ${gone.join(', ')}`)
-  return `Trimmed ${plural(gone.length, 'branch')} nobody used for a day: ${list(gone)}. Git keeps them, and a branch comes back when someone checks it out.`
+  return `Trimmed ${plural(gone.length, 'branch')} nobody used for a day: ${list(gone)}. A branch comes back when someone checks it out.`
 }
 
 const HELP = `I can answer:\n${RELAY_QUESTIONS.map((q) => `- ${q.text}${q.owner ? ' (owner only)' : ''}`).join('\n')}`
@@ -166,7 +104,6 @@ const HELP = `I can answer:\n${RELAY_QUESTIONS.map((q) => `- ${q.text}${q.owner
  */
 export function relayAnswer (room, m, asker, now = Date.now()) {
   switch (questionOf(m.text)) {
-    case 'git': return gitAnswer(room, now)
     case 'members': return membersAnswer(room)
     case 'branches': return branchesAnswer(room, now)
     case 'trim': return trimAnswer(room, asker, now)

package/src/relay-cluster.js

@@ -50,14 +50,13 @@ export function clusterConfig (opts = {}, env = process.env) {
 }
 
 /** What cluster mode is missing; [] when it can run. */
-export function clusterProblems (cc, cfg, { fileKey = '' } = {}) {
+export function clusterProblems (cc, cfg) {
   if (!cc.on) return []
   const out = []
   if (!MACHINE_RE.test(cc.machineId)) out.push('FLY_MACHINE_ID (this machine\'s id)')
   if (!cfg.apiUrl) out.push('QUILT_API_URL')
   if (!cfg.relayApiSecret) out.push('RELAY_API_SECRET')
   if (!cfg.passPublicKey) out.push('QUILT_PASS_PUBLIC_KEY (sign-in)')
-  if (cfg.gitSync && !fileKey) out.push('QUILT_RELAY_FILE_KEY (the file key every machine shares)')
   if (!cc.peerUrl) out.push('QUILT_PEER_URL or FLY_APP_NAME (how machines reach each other)')
   return out
 }
@@ -75,10 +74,9 @@ export function storedRooms (dataDir) {
   return [...out].sort()
 }
 
-/** The room a request's path is about ('' for none): git, chat files, large files, chat links. */
+/** The room a request's path is about ('' for none): chat files, large files, chat links. */
 export function roomOfPath (pathname) {
-  const m = /^\/git\/([A-Za-z0-9_-]{1,64})\.git\//.exec(pathname) ||
-    /^\/files\/([A-Za-z0-9_-]{1,64})(?:\/|$)/.exec(pathname) ||
+  const m = /^\/files\/([A-Za-z0-9_-]{1,64})(?:\/|$)/.exec(pathname) ||
     /^\/blobs\/([A-Za-z0-9_-]{1,64})\//.exec(pathname) ||
     /^\/c\/([A-Za-z0-9_-]{1,64})\//.exec(pathname)
   return m ? m[1] : ''