heyquilt 0.3.138 → 0.3.140

package/src/control.js

@@ -137,8 +137,6 @@ export async function startControl (session, extras = {}) {
     'POST /chat-link': (b) => session.createChatLink({ name: b.name, minutes: b.minutes }),
     // Owner only: how long a chat link still works. { who: name or key, minutes } -> { name, expiresAt }
     'POST /chat-link/extend': (b) => session.extendChatLink(String(b.who || ''), b.minutes),
-    // Owner only: the relay's read-only GitHub token, for commits while everyone's offline. { token } ('' clears) -> { githubToken }
-    'POST /github-token': (b) => session.setGithubToken(b.token),
     '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).
@@ -146,11 +144,6 @@ export async function startControl (session, extras = {}) {
     '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 }),
-    'GET /branches': () => ({ branches: session.status().branches, git: session.status().git }),
-    // 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).
@@ -170,23 +163,7 @@ export async function startControl (session, extras = {}) {
     '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),
-    // GitHub as a node: the owner's switch, and a person adopting an agent's branch (relay-outbound.js).
-    'POST /github-sync': async (b) => (await session.setGithubSync(b.on !== false)).githubSync === false ? { githubSync: false } : { githubSync: true },
-    'POST /adopt': (b) => session.adoptBranch(String(b.from || '')),
-    // The branch's pull requests on GitHub, and merging one, through the relay (relay-commit.js).
-    'POST /github/recheck': () => session.githubRecheck(),
-    'POST /unpublished': (b) => session.unpublished({ files: Array.isArray(b.files) ? b.files : null, task: b.task || null, column: b.column || '' }),
-    // git in an agent's folder: what it signs in to GitHub with (`quilt git-credential`), and whether a push may go (`quilt git-pre-push`).
-    'POST /git/credential': (b) => session.gitCredential({ host: b.host || '' }),
-    'POST /git/push-check': (b) => session.pushCheck({ remote: b.remote || 'origin', refs: Array.isArray(b.refs) ? b.refs : [] }),
 
-    // A commit request committed in this folder, which has git (commit.js).
-    'POST /commit-request/commit': (b) => session.commitRequest(String(b.id || '')),
-    'GET /uncommitted': () => session.uncommittedWork(),
-    'POST /commit-request/done': (b) => ({ done: session.resolveCommitRequests({ ids: b.id ? [String(b.id)] : null }) }),
     'POST /work': (b) => {
       if (b.state === 'working') session.personaSays(b.via, b.note)
       const work = session.setWork(b.state, b.note)
@@ -212,17 +189,13 @@ export async function startControl (session, extras = {}) {
       session.noteTaskChange(null, task, b.via)
       return { task, tasks: session.taskList() }
     },
-    'POST /tasks/update': async (b) => {
+    'POST /tasks/update': (b) => {
       const before = session.taskList().find((t) => t.id === b.id) || null
-      // Done merges the task's pull request first (relay-commit.js): refused with the reason when it can't be.
-      const finished = b.column === 'done' && before && before.column !== 'done' ? await session.finishTask(b.id) : null
       const task = session.updateTask(b)
       session.noteTaskChange(before, task, b.via)
       if (b.column === 'doing' && task) session.personaSays(b.via, task.title) // taking a task can name an AI session
       if (task && (b.column === 'doing' || b.column === 'done')) session.stitchClock(b.via, b.column === 'doing')
-      // An agent taking a task gets a branch of its own for it (session.js branchForTask).
-      const branch = b.column === 'doing' && task && before && before.column !== 'doing' ? await session.branchForTask(task).catch(() => null) : null
-      return { task, tasks: session.taskList(), ...(finished && finished.merged ? { merged: finished.merged } : {}), ...(branch ? { branch } : {}) }
+      return { task, tasks: session.taskList() }
     },
     // What an agent gets when it picks a task up: history for its files, claims, the project's checks.
     'POST /tasks/brief': (b) => session.taskBrief(b.id),
@@ -233,10 +206,6 @@ export async function startControl (session, extras = {}) {
       return r
     },
     'POST /tasks/delete': (b) => { session.deleteTask(b.id); return { tasks: session.taskList() } },
-    // Merges Quilt made on its own (session.js autoSettle), and files waiting for their holder to let go.
-    'GET /merges': () => ({ merges: session.mergeList() }),
-    // quilt_clash: a file held because the session and GitHub changed the same lines (relay-clash.js).
-    'POST /clash': (b) => session.clash({ action: String(b.action || ''), path: String(b.path || ''), content: typeof b.content === 'string' ? b.content : null, checks: b.checks && typeof b.checks === 'object' ? b.checks : null, force: b.force === true }),
     'GET /rules': () => ({ text: session.projectRulesText() }),
     // Secrets (`quilt run`, quilt_secret_names): asked of the API as this session's own identity
     // (its person, or the agent it runs as). Run tokens and names only: never a value.

package/src/duties.js

@@ -15,7 +15,7 @@
 //
 // Messages are chat entries ({ id, by, to, text, ts }) the reader can see.
 import { mentionsMe, mentioned, ALL_AGENTS } from './inbox.js'
-import { RELAY_BY } from './branches.js'
+import { RELAY_NAME as RELAY_BY } from './ui/chat.js'
 import { RELAY_OLD_NAMES } from './ui/chat.js'
 
 

package/src/github-commit.js

@@ -1,320 +1,8 @@
-// Commits made by the relay, through GitHub's API, for any member of a session: an agent on any
-// tool (Codex, Cursor, Claude Code, a hosted agent over HTTP), with no git and no credentials on
-// its machine, and with nobody else online. The session's copy of the files is the content; the
-// branch's commit on GitHub is the parent; only the files named change. No folder, index or
-// working tree is involved, so nobody's uncommitted work is swept in.
-//
-// It never rewrites history: a ref is only moved forward (GitHub refuses anything else without
-// force, which is never sent), and a file that changed on GitHub since the session's copy was
-// taken is refused rather than overwritten. Public and private repositories work alike: writing
-// needs the session's GitHub token with write access to the repository's contents (and to pull
-// requests, to open one).
-//
-// Git for this session (AGENT_COMMITS; docs/superpowers/specs/2026-10-17-git-for-everyone.md): off for
-// everyone, or on with what agents may push: their own branches only (quilt/<agent>/…, the default),
-// or any branch, the session's own included. People may push any branch while it is on.
-import crypto from 'node:crypto'
+// R3 removed GitHub commits; only this pure helper stays, because test/unit/history.test.js (claimed in
+// another square, sq:09a100d0) still imports it from here. Delete this file with that test's import.
 import { blameChange } from './history.js'
 
-const API = 'https://api.github.com'
-export const AGENT_COMMITS = ['off', 'branches', 'any']
-export const DEFAULT_AGENT_COMMITS = 'branches'
-export const MAX_COMMIT_FILES = 300
-export const MAX_COMMIT_BYTES = 20 * 1024 * 1024
-const BRANCH = /^(?!\/)(?!.*\/\/)(?!.*\.\.)(?!.*\.lock(\/|$))(?!.*[\s~^:?*[\\\x00-\x1f\x7f])(?!.*@\{)[^]+(?<![/.])$/
-
-export class CommitRefused extends Error {}
-
-/** Who set the rule over a session, in words: "the workspace Platform", "the team Night shift", "the org Acme". */
-export const ruleSetter = (set) => `the ${set.by === 'org' ? 'org' : set.by === 'team' ? 'team' : 'workspace'}${set.name ? ` ${set.name}` : ''}`
-
-/**
- * Git for everyone, in one line, for whoever is in the session: `policy` ('off', 'branches', 'any'),
- * `by` (the rule over the session, { by, name }, when one set it) and `login` (the GitHub account
- * whose connection covers the repository, when one does).
- */
-export function gitForEveryoneWords ({ policy = DEFAULT_AGENT_COMMITS, by = null, login = '' } = {}) {
-  if (policy === 'off') return `Git is off for everyone in this session: ${by ? ruleSetter(by) : 'the session owner'} turned it off.`
-  const agents = policy === 'any' ? 'people and agents push to any branch' : 'people push to any branch, agents to branches of their own'
-  if (login) return `Git is on for everyone here, through @${login}'s connection: ${agents}, with nothing to set up.`
-  return `Git is on for everyone here once someone connects GitHub (one click in the commit panel, by anyone whose GitHub account can write to the repository): ${agents}.`
-}
-
-/** git's id for a file's bytes (what GitHub's trees list), so content is compared without fetching it. */
-export function gitBlobSha (buf) {
-  return crypto.createHash('sha1').update(`blob ${buf.length}\0`).update(buf).digest('hex')
-}
-
-/** "duncan", "daniel-carmichael": a name as a branch path segment. */
-export function slug (s, max = 40) {
-  return String(s || '').toLowerCase().normalize('NFKD').replace(/[^\w\s-]/g, '').trim().replace(/[\s_]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, max).replace(/-$/, '') || 'work'
-}
-
-/** The branches an agent owns: quilt/<its name>/… */
-export const agentPrefix = (name) => `quilt/${slug(name, 30)}/`
-
-/** Whether `name` is a branch name git and GitHub accept. */
-export const validBranchName = (name) => typeof name === 'string' && name.length > 0 && name.length <= 200 && BRANCH.test(name)
-
-/**
- * Where a member's commit goes, or why it may not: { branch, own } or throws CommitRefused.
- * `sessionBranch`: the GitHub branch the session's branch follows (main). `target`: what they
- * asked for ('' = the default). `kind`: 'agent' for agents, anything else for people.
- */
-export function commitTarget ({ policy = DEFAULT_AGENT_COMMITS, kind = 'human', name, sessionBranch, target = '', message = '' }) {
-  const agent = kind === 'agent'
-  const mode = AGENT_COMMITS.includes(policy) ? policy : DEFAULT_AGENT_COMMITS
-  if (agent && mode === 'off') throw new CommitRefused('Git is off for everyone in this session. Ask a person for the commit with quilt_request_commit (your files and a message).')
-  const prefix = agentPrefix(name)
-  let branch = String(target || '').trim().replace(/^refs\/heads\//, '')
-  if (!branch) branch = agent && mode === 'branches' ? `${prefix}${slug(message, 40)}` : sessionBranch
-  if (!validBranchName(branch)) throw new CommitRefused(`"${branch}" is not a branch name git accepts.`)
-  if (agent && mode === 'branches' && !branch.startsWith(prefix)) {
-    throw new CommitRefused(`The session owner lets agents commit only to branches of their own: ${prefix}<topic>${branch === sessionBranch ? ` (not ${sessionBranch} itself)` : ''}. Leave branch out to get one, and open a pull request with pull_request: true.`)
-  }
-  return { branch, own: branch !== sessionBranch }
-}
-
-/**
- * What a commit of `files` would change: { changes: [{ path, sha?, deleted, bytes }], same: [paths], moved: [paths] }.
- * `files`: Map path -> Buffer (the session's content) or null (deleted in the session).
- * `parent`: Map path -> blob sha at the commit the new one goes on; `base`: at the commit the
- * session's copy is measured from. A file whose blob differs between the two changed on GitHub
- * since the session took its copy: it is `moved`, and committing the session's copy would undo
- * that change. Without `base` (a branch only its agent writes to) nothing counts as moved.
- */
-export function planCommit (files, { parent, base = null }) {
-  const changes = []
-  const same = []
-  const moved = []
-  for (const [rel, buf] of files) {
-    const now = buf ? gitBlobSha(buf) : null
-    const at = parent.get(rel) || null
-    if (now === at) { same.push(rel); continue }
-    if (base && (base.get(rel) || null) !== at) { moved.push(rel); continue }
-    changes.push({ path: rel, sha: now, deleted: !buf, bytes: buf || null })
-  }
-  return { changes, same, moved }
-}
-
-/**
- * Who changed each file in the session since `since` (ms) besides `me`, from the branch's
- * history (entries oldest first): Map path -> [names]. Pulls from git are nobody's.
- */
-export function othersEditing (paths, history, { me, since = 0 } = {}) {
-  const want = new Set(paths)
-  const out = new Map()
-  for (const e of history || []) {
-    if (!e || !want.has(e.path) || e.pulled || e.seed || !e.by || e.by === me || (e.ts || 0) <= since) continue
-    const list = out.get(e.path) || []
-    if (!list.includes(e.by)) list.push(e.by)
-    out.set(e.path, list)
-  }
-  return out
-}
-
-/** Who besides `me` made the changes a commit of one text file would carry (history.js blameChange). */
+/** Who besides `me` made the changes in one text file's edit (history.js blameChange). */
 export function othersInChange ({ before = '', after = '', entries = [], me }) {
   return blameChange({ before, after, entries }).filter((n) => n !== me)
 }
-
-/** The commit message, and who made it: an agent is named as the author, the token's account commits it. */
-export function messageFor ({ message, by, task = null, coAuthors = [] }) {
-  const lines = [String(message || '').trim() || 'Changes from the Quilt session']
-  const trailer = [`Made in Quilt by ${by}${task ? ` for task ${task.id}: ${task.title}` : ''}.`]
-  for (const n of coAuthors) trailer.push(`Co-authored-by: ${n} <${noreply(n)}>`)
-  return `${lines.join('\n')}\n\n${trailer.join('\n')}`
-}
-
-export const noreply = (name) => `${slug(name, 40)}@agents.noreply.heyquilt.com`
-
-class GitHubWriteError extends Error {
-  constructor (status, what, body) {
-    super(`GitHub answered ${status} to ${what}${body && body.message ? `: ${body.message}` : ''}`)
-    this.status = status
-    this.body = body
-  }
-}
-
-/** The GitHub calls a commit needs. The token goes in a header, never a URL. */
-export function githubWriter ({ fetch = globalThis.fetch, token, owner, name }) {
-  const headers = { 'user-agent': 'quilt-relay', 'x-github-api-version': '2022-11-28', accept: 'application/vnd.github+json', authorization: `Bearer ${token}` }
-  const repo = `${API}/repos/${owner}/${name}`
-  const req = async (method, path, body, what) => {
-    const res = await fetch(`${repo}${path}`, { method, headers: { ...headers, ...(body ? { 'content-type': 'application/json' } : {}) }, ...(body ? { body: JSON.stringify(body) } : {}), redirect: 'follow' })
-    let json = null
-    try { json = await res.json() } catch {}
-    if (!res.ok) throw new GitHubWriteError(res.status, what, json)
-    return json
-  }
-  const enc = (ref) => ref.split('/').map(encodeURIComponent).join('/')
-  return {
-    /** The branch's head commit, or null when there is no such branch. */
-    async ref (branch) {
-      try { return (await req('GET', `/git/ref/heads/${enc(branch)}`, null, `branch ${branch}`)).object.sha } catch (err) { if (err.status === 404) return null; throw err }
-    },
-    /** A commit's tree sha and date. */
-    async commit (sha) {
-      const c = await req('GET', `/git/commits/${sha}`, null, `commit ${sha.slice(0, 7)}`)
-      return { tree: c.tree.sha, ts: Date.parse(c.committer && c.committer.date) || 0 }
-    },
-    /** Every file's blob sha in a tree: Map path -> sha (null when GitHub cut the listing short). */
-    async blobs (treeSha) {
-      const t = await req('GET', `/git/trees/${treeSha}?recursive=1`, null, 'the file list')
-      if (t.truncated) return null
-      return new Map((t.tree || []).filter((x) => x.type === 'blob').map((x) => [x.path, x.sha]))
-    },
-    async modes (treeSha) {
-      const t = await req('GET', `/git/trees/${treeSha}?recursive=1`, null, 'the file list')
-      return new Map((t.tree || []).filter((x) => x.type === 'blob').map((x) => [x.path, x.mode]))
-    },
-    /** A file's bytes at a commit, or null when it isn't there. */
-    async content (sha, rel) {
-      const res = await fetch(`${repo}/contents/${enc(rel)}?ref=${sha}`, { headers: { ...headers, accept: 'application/vnd.github.raw' }, redirect: 'follow' })
-      if (res.status === 404) return null
-      if (!res.ok) throw new GitHubWriteError(res.status, rel, null)
-      return Buffer.from(await res.arrayBuffer())
-    },
-    async blob (buf) { return (await req('POST', '/git/blobs', { content: buf.toString('base64'), encoding: 'base64' }, 'a file')).sha },
-    async tree (baseTree, entries) { return (await req('POST', '/git/trees', { base_tree: baseTree, tree: entries }, 'the new file list')).sha },
-    async newCommit ({ message, tree, parent, author }) {
-      return (await req('POST', '/git/commits', { message, tree, parents: [parent], ...(author ? { author } : {}) }, 'the commit')).sha
-    },
-    /** Moves the branch forward to `sha` (never forced: GitHub refuses a move that would lose commits). */
-    async move (branch, sha) { await req('PATCH', `/git/refs/heads/${enc(branch)}`, { sha, force: false }, `branch ${branch}`) },
-    async create (branch, sha) { await req('POST', '/git/refs', { ref: `refs/heads/${branch}`, sha }, `new branch ${branch}`) },
-    async pull ({ title, head, base, body }) {
-      try {
-        const p = await req('POST', '/pulls', { title, head, base, body }, 'the pull request')
-        return { number: p.number, url: p.html_url }
-      } catch (err) {
-        // One is already open for this branch: say which.
-        if (err.status === 422) {
-          const open = await req('GET', `/pulls?head=${encodeURIComponent(`${owner}:${head}`)}&state=open`, null, 'pull requests')
-          if (Array.isArray(open) && open[0]) return { number: open[0].number, url: open[0].html_url, existed: true }
-        }
-        throw err
-      }
-    },
-    /** The branch's newest commits: [{ sha, message, author, date, url }]. */
-    async log (branch, n = 10) {
-      const list = await req('GET', `/commits?sha=${encodeURIComponent(branch)}&per_page=${Math.max(1, Math.min(50, n | 0))}`, null, `commits on ${branch}`)
-      return (Array.isArray(list) ? list : []).map((c) => ({ sha: c.sha, message: (c.commit && c.commit.message) || '', author: (c.commit && c.commit.author && c.commit.author.name) || (c.author && c.author.login) || '', date: (c.commit && c.commit.author && c.commit.author.date) || '', url: c.html_url }))
-    },
-    /** Open pull requests, newest first: [{ number, title, head, base, url, draft, by, sha }]. */
-    async pulls () {
-      const list = await req('GET', '/pulls?state=open&per_page=50&sort=updated&direction=desc', null, 'pull requests')
-      return (Array.isArray(list) ? list : []).map((p) => ({ number: p.number, title: p.title, head: p.head && p.head.ref, base: p.base && p.base.ref, url: p.html_url, draft: !!p.draft, by: p.user && p.user.login, sha: p.head && p.head.sha }))
-    },
-    /** One pull request: { number, title, head, base, url, sha, state, merged, mergeable, mergeableState }. */
-    async pullRequest (number) {
-      const p = await req('GET', `/pulls/${Number(number)}`, null, `pull request #${number}`)
-      return { number: p.number, title: p.title, head: p.head && p.head.ref, base: p.base && p.base.ref, url: p.html_url, sha: p.head && p.head.sha, state: p.state, merged: !!p.merged, mergeable: p.mergeable, mergeableState: p.mergeable_state || '' }
-    },
-    /** How `head` stands to `base`: 'identical', 'ahead' (base is in head), 'behind' or 'diverged' (it isn't). */
-    async compare (base, head) {
-      const c = await req('GET', `/compare/${encodeURIComponent(base)}...${encodeURIComponent(head)}`, null, 'a comparison')
-      return (c && c.status) || 'diverged'
-    },
-    /** How a commit's checks stand: 'passing', 'failing', 'pending' or 'none', with the failing ones named. */
-    async checks (sha) {
-      const runs = await req('GET', `/commits/${sha}/check-runs?per_page=100`, null, 'checks')
-      const st = await req('GET', `/commits/${sha}/status`, null, 'statuses')
-      const items = (runs && Array.isArray(runs.check_runs) ? runs.check_runs : []).map((c) => ({ name: c.name, done: c.status === 'completed', ok: ['success', 'neutral', 'skipped'].includes(c.conclusion) }))
-      for (const s of (st && Array.isArray(st.statuses) ? st.statuses : [])) items.push({ name: s.context, done: s.state !== 'pending', ok: s.state === 'success' })
-      if (!items.length) return { state: 'none', failing: [] }
-      const failing = items.filter((c) => c.done && !c.ok).map((c) => c.name)
-      if (failing.length) return { state: 'failing', failing }
-      return { state: items.every((c) => c.done) ? 'passing' : 'pending', failing: [] }
-    },
-    /** Merges a pull request: { sha }. GitHub refuses when it can't be merged as it is (conflicts, rules). */
-    async merge (number, { method = 'squash', title = '' } = {}) {
-      const r = await req('PUT', `/pulls/${Number(number)}/merge`, { merge_method: method, ...(title ? { commit_title: title } : {}) }, `merging #${number}`)
-      return { sha: r.sha, merged: !!r.merged }
-    },
-    async deleteBranch (branch) {
-      try { await req('DELETE', `/git/refs/heads/${enc(branch)}`, null, `deleting ${branch}`) } catch (err) { if (err.status !== 404 && err.status !== 422) throw err }
-    }
-  }
-}
-
-/** Why GitHub refused, in words for whoever asked (never the token). */
-export function writeProblem (err, repo) {
-  const s = err && err.status
-  if (s === 401) return `the session's GitHub token was refused by GitHub (expired or revoked): ask the session owner for a new one (quilt_github_token)`
-  if (s === 403 || s === 404) return `the session's GitHub token can't write to ${repo}: the owner needs a token with "Contents: Read and write" on it (and "Pull requests: Read and write" to open pull requests), set with quilt_github_token`
-  if (s === 409) return `${repo} is empty or being changed: try again`
-  if (s === 422) return `GitHub refused: ${err.body && err.body.message ? err.body.message : 'the branch moved meanwhile'}`
-  return err && err.message ? err.message : String(err)
-}
-
-/**
- * Makes the commit on GitHub: `files` (Map path -> Buffer|null) onto `branch`, which starts at
- * `from` when it doesn't exist yet (the session's commit), checked against `base` (the commit
- * the session's copy is measured from; null for a branch of the asker's own, which only they write to). Resolves { sha, branch, created, changed, same } or
- * throws CommitRefused (nothing to commit, files changed on GitHub) or a GitHub error.
- */
-export async function commitOnGitHub (gh, { files, branch, from, base, message, author, tries = 2 }) {
-  for (let attempt = 1; ; attempt++) {
-    const head = await gh.ref(branch)
-    const parent = head || from
-    const pc = await gh.commit(parent)
-    const parentBlobs = await gh.blobs(pc.tree)
-    if (!parentBlobs) throw new CommitRefused('The repository is too large for GitHub to list in one go; commit from a folder with git.')
-    const baseBlobs = !base ? null : base === parent ? parentBlobs : await gh.blobs((await gh.commit(base)).tree)
-    if (base && !baseBlobs) throw new CommitRefused('The repository is too large for GitHub to list in one go; commit from a folder with git.')
-    const plan = planCommit(files, { parent: parentBlobs, base: baseBlobs })
-    if (plan.moved.length) {
-      throw new CommitRefused(`${plan.moved.join(', ')} changed on ${head ? branch : 'GitHub'} since the session's copy was taken, so committing the session's copy would undo that. ` +
-        'Bring those commits into the session first (quilt_sync_branch; the session then has both), then commit again.')
-    }
-    if (!plan.changes.length) return { sha: parent, branch, created: false, changed: [], same: plan.same, nothing: true, exists: !!head }
-    const modes = await gh.modes(pc.tree)
-    const entries = []
-    for (const c of plan.changes) {
-      if (c.deleted) entries.push({ path: c.path, mode: modes.get(c.path) || '100644', type: 'blob', sha: null })
-      else entries.push({ path: c.path, mode: modes.get(c.path) || '100644', type: 'blob', sha: await gh.blob(c.bytes) })
-    }
-    const tree = await gh.tree(pc.tree, entries)
-    const sha = await gh.newCommit({ message, tree, parent, author })
-    try {
-      if (head) await gh.move(branch, sha)
-      else await gh.create(branch, sha)
-      return { sha, parent, branch, created: !head, changed: plan.changes.map((c) => c.path), same: plan.same }
-    } catch (err) {
-      // Someone pushed to the branch meanwhile: start again from its new head.
-      if ((err.status === 422 || err.status === 409) && attempt < tries) continue
-      throw err
-    }
-  }
-}
-
-/** quilt_commit, the same for every agent (local MCP, hosted MCP, CLI). */
-export const GIT_COMMIT_DESCRIPTION = 'Commit your work to the branch you are on, on GitHub: the session\'s copy of exactly these files (by default every change of yours on record on this branch), with your message. ' +
-  'On a branch of your own (quilt/<you>/…, where taking a task puts you) the pull request to the session\'s branch opens by itself and is tied to your task. ' +
-  'The session\'s branch itself is open to agents only when the owner lets agents push to any branch; otherwise take a task or quilt_git_branch create first. ' +
-  'Refused for a file that changed on GitHub since the session\'s copy (quilt_sync_branch first) and for one holding others\' uncommitted changes (unless with_others). ' +
-  'Commit as soon as work is finished and tested: work that is only in the session has not shipped. When the owner keeps agents from committing, ask a person with quilt_request_commit.'
-export const gitCommitSchema = (z) => ({
-  message: z.string().min(1).max(2000).describe('What the change does (the first line is the subject)'),
-  files: z.array(z.string().min(1).max(500)).max(200).optional().describe('The files to commit, deleted ones too; default: every change of yours on record on this branch'),
-  task: z.string().max(40).optional().describe('The task this is for: its title names the pull request, and the task follows it'),
-  with_others: z.boolean().optional().describe('Also commit files that hold other people\'s uncommitted changes (they are named as co-authors)')
-})
-
-export const COMMIT_DESCRIPTION = 'For agents with no folder (hosted, over HTTP): commit your finished work to the repository on GitHub through the relay, since you have no git of your own; nobody else needs to be online. Agents with a folder push with git instead. ' +
-  'Quilt commits the session\'s copy of exactly these files (by default every change of yours on record on this branch) with your message, and everyone sees it in chat. ' +
-  'Where it goes is the session owner\'s call: by default a branch of your own (quilt/<you>/<topic>; pull_request: true opens a pull request to the session\'s branch); ' +
-  'when the owner lets agents commit to any branch, leaving branch out commits to the session\'s branch itself. ' +
-  'Refused for a file that changed on GitHub since the session\'s copy (bring it in with quilt_sync_branch first) and for one holding others\' uncommitted changes (unless with_others). ' +
-  'Commit as soon as work is finished and tested: work that is only in the session has not shipped. When the owner keeps agents from committing, ask a person with quilt_request_commit.'
-
-/** quilt_commit's arguments, the same for the local and the hosted tool (`z`: zod). */
-export const commitSchema = (z) => ({
-  message: z.string().max(2000).optional().describe('The commit message: what the change does (a task\'s title by default)'),
-  files: z.array(z.string().max(1024)).max(300).optional().describe('The files to commit, relative to the project\'s top folder (deleted ones too); default: every change of yours on record on this branch'),
-  branch: z.string().max(200).optional().describe('The GitHub branch to commit to; default: a branch of your own (quilt/<you>/<topic>), or the session\'s branch when the owner lets agents commit there'),
-  pull_request: z.boolean().optional().describe('Open a pull request from your branch to the session\'s branch'),
-  with_others: z.boolean().optional().describe('Also commit files that hold others\' uncommitted changes (they are named as co-authors)'),
-  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')
-})