heyquilt 0.0.1 → 0.3.106

package/src/clash.js

@@ -0,0 +1,128 @@
+// Commits from outside that a folder can't bring in (git couldn't read a file
+// they change: too large, or behind a filter such as Git LFS) are handed to ONE
+// member as a task on the board, instead of every folder behind on that branch
+// telling its AI. Files both sides changed never come here: Quilt combines them
+// itself (upstream.js combine). Each folder that reports the clash works out the same owner from
+// presence; only the owner's Quilt writes the task, under an id derived from
+// the branch and the upstream commit, so two that race write the same task.
+// Pure: Session (reviewClash) reads presence and the board and applies these.
+import crypto from 'node:crypto'
+import { MAX_FILES, MAX_TITLE } from './tasks.js'
+
+const HEX_ID = /^[0-9a-f]{16}$/
+const SHA = /^[0-9a-f]{7,64}$/
+
+/** The task id for a clash on `branch` with upstream commit `sha`: the same in every member's Quilt. */
+export function clashTaskId (branch, sha) {
+  return crypto.createHash('sha256').update(`quilt-clash\n${branch}\n${sha}`).digest('hex').slice(0, 16)
+}
+
+/** A clash record from the room's "clashes" map (branch -> record), or null for anything else. */
+export function readClash (value, branch) {
+  if (!value || typeof value !== 'object') return null
+  if (typeof value.task !== 'string' || !HEX_ID.test(value.task)) return null
+  if (typeof value.sha !== 'string' || !SHA.test(value.sha)) return null
+  if (typeof value.upstream !== 'string' || !value.upstream || value.upstream.length > 200) return null
+  const ts = Number.isFinite(value.ts) ? value.ts : 0
+  return { branch, task: value.task, sha: value.sha, upstream: value.upstream, ts }
+}
+
+/** Whether a member's presence shows a live AI session working through its app (persona.js). */
+export function hasAi (st) {
+  return !!st && Array.isArray(st.personas) && st.personas.some((p) => p && typeof p.name === 'string' && p.name)
+}
+
+/**
+ * The members who may take this clash: their folder is on `branch` with `upstream` as its
+ * upstream and reports clashing files (not a diverged branch: that history is the folder's own),
+ * their Quilt hands clashes out (git.clash 1), and they may change the clashing files.
+ * `states`: [[clientID, presence state]], this member's own included.
+ * Each: { id, name, kind, ai, rank } (rank 0 an agent member, 1 a person with an AI session, 2 a person).
+ */
+export function clashCandidates (states, { branch, upstream }) {
+  const out = []
+  for (const [id, st] of states) {
+    if (!st || typeof st.name !== 'string' || !st.name || !st.git || typeof st.git !== 'object') continue
+    const g = st.git
+    const u = g.upstream
+    if (g.clash !== 1 || g.branch !== branch || !u || u.name !== upstream) continue
+    // A folder whose fetch fails can't pull, so its AI couldn't merge.
+    if (!(u.conflicts > 0) || u.diverged || u.mayWrite !== true || u.fetchOk === false) continue
+    const agent = st.kind === 'agent'
+    const ai = !agent && hasAi(st)
+    out.push({ id, name: st.name, kind: agent ? 'agent' : 'human', ai, rank: agent ? 0 : ai ? 1 : 2 })
+  }
+  return out
+}
+
+/** The candidates in the order they take the clash: an agent member first, then a person with an AI, then anyone; the lowest client id among equals. */
+export function clashOrder (candidates) {
+  return [...candidates].sort((a, b) => a.rank - b.rank || a.id - b.id)
+}
+
+/** Who takes the clash (the first in clashOrder not in `except`), or null. */
+export function pickClashOwner (candidates, { except = [] } = {}) {
+  return clashOrder(candidates.filter((c) => !except.includes(c.name)))[0] || null
+}
+
+/**
+ * The presence state of whoever `assignee` is (a member, or one of a member's AI sessions),
+ * counted only when that member's folder is on `branch`; null when they are not here.
+ */
+export function holderOf (states, assignee, branch) {
+  for (const [id, st] of states) {
+    if (!st || !st.git || st.git.branch !== branch) continue
+    if (st.name === assignee || (Array.isArray(st.personas) && st.personas.some((p) => p && p.name === assignee))) return { id, st, rank: st.kind === 'agent' ? 0 : hasAi(st) ? 1 : 2 }
+  }
+  return null
+}
+
+/** How a task's assignee is named in a notice and on the branch list: an agent by name, a person as "<name>'s AI". */
+export function ownerLabel ({ assignee, forAi }) {
+  return forAi ? `${assignee}'s AI` : assignee
+}
+
+const n = (k, w) => `${k} ${w}${k === 1 ? '' : 's'}`
+
+/** The task's title: "Bring 4 commits from origin/main into the session: src/a.js, src/b.js clash". */
+export function clashTitle ({ upstream, behind, conflicts = [] }) {
+  const head = `Bring ${n(behind, 'commit')} from ${upstream} into the session: `
+  const paths = conflicts.map((c) => c.path)
+  const tail = paths.length === 1 ? ' clashes' : ' clash'
+  const text = (shown) => {
+    const rest = paths.length - shown.length
+    return head + shown.join(', ') + (rest ? ` and ${rest} more` : '') + tail
+  }
+  let shown = []
+  for (const p of paths) {
+    const next = [...shown, p]
+    if (shown.length && text(next).length > MAX_TITLE) break
+    shown = next
+  }
+  return text(shown).slice(0, MAX_TITLE)
+}
+
+/** The files the task lists (the board keeps at most MAX_FILES). */
+export function clashFiles (conflicts = []) {
+  return [...new Set(conflicts.map((c) => c.path))].slice(0, MAX_FILES)
+}
+
+/** The task's description, as its first comment: each file and why. Nobody is asked to pull or merge. */
+export function clashBrief ({ branch, upstream, sha, behind, conflicts = [] }) {
+  const lines = [`${n(behind, 'commit')} on ${upstream} (up to ${sha.slice(0, 7)}) change files Quilt can't read here, so it brought nothing in yet:`]
+  for (const c of conflicts.slice(0, 30)) lines.push(`- ${c.path}: ${c.why}`)
+  if (conflicts.length > 30) lines.push(`- and ${conflicts.length - 30} more`)
+  lines.push('', `Files both sides changed are combined by Quilt on its own; nothing here needs merging by hand. Once a folder on \`${branch}\` that can read these files is at ${sha.slice(0, 7)} or later, every other folder follows it and Quilt closes this task by itself: no need to move it.`)
+  return lines.join('\n')
+}
+
+/** The notice for a member whose folder is behind but who is not merging: leave it to the owner. */
+export function leaveItNotice ({ label, upstream, task, facts }) {
+  return `${label} is bringing in the commits from ${upstream} (task ${task}); leave those files to them.${facts ? ` ${facts}` : ''}`
+}
+
+/** What a folder that reports the clash knows about it, without the advice to pull. */
+export function clashFacts ({ branch, upstream, behind, conflicts = [] }) {
+  const list = conflicts.slice(0, 4).map((c) => `${c.path} (${c.why})`).join('; ') + (conflicts.length > 4 ? `; and ${conflicts.length - 4} more` : '')
+  return `${branch} is ${n(behind, 'commit')} behind ${upstream}, and Quilt can't read ${list} to bring them in.`
+}

package/src/cloud-ai.js

@@ -0,0 +1,50 @@
+// A person's AI on its own cloud machine (docs/superpowers/specs/2026-10-17-ai-vm.md) is one of
+// that person's AI sessions: its presence says whose (`aiOf`), and it answers for
+// "<person>'s AI" only while none of the person's AI sessions on a computer is live. Pure, so
+// the relay (which wakes a suspended one) and every app (which shows it and reads its inbox)
+// decide the same way.
+import { aiName } from './ui/chat.js'
+
+/** The label a cloud AI's name carries: "Daniel · cloud". */
+export const CLOUD_LABEL = 'cloud'
+
+/**
+ * Whether one of `person`'s AI sessions on a computer is live: a presence of theirs (not a
+ * cloud AI's) publishing an AI session that isn't a "work on its own" run.
+ */
+export function localAiLive (states, person) {
+  for (const s of states || []) {
+    if (!s || s.name !== person || s.aiOf || !Array.isArray(s.personas)) continue
+    if (s.personas.some((p) => p && typeof p.name === 'string' && !p.auto)) return true
+  }
+  return false
+}
+
+/** The names of `person`'s AI sessions on computers: what they say never wakes the cloud AI. */
+export function localAiNames (states, person) {
+  const out = []
+  for (const s of states || []) {
+    if (!s || s.name !== person || s.aiOf || !Array.isArray(s.personas)) continue
+    for (const p of s.personas) if (p && typeof p.name === 'string') out.push(p.name)
+  }
+  return out
+}
+
+/**
+ * How a cloud AI named `name`, of `person`, reads the inbox (inbox.js): its own name always;
+ * "<person>'s AI" and tasks for it only while no AI session of theirs on a computer is live.
+ */
+export function cloudReader ({ name, person, states = [], aliases = [] }) {
+  const local = localAiLive(states, person)
+  return {
+    name,
+    aliases: local ? [...aliases] : [...aliases, aiName(person)],
+    agent: true,
+    asAi: false,
+    ...(local ? {} : { of: person }),
+    own: localAiNames(states, person)
+  }
+}
+
+/** Whether a presence is a cloud AI's (its relay checked `aiOf` against its pass). */
+export const isCloudAi = (state) => !!(state && typeof state.aiOf === 'string' && state.aiOf)

package/src/commit-request.js

@@ -0,0 +1,59 @@
+// Commit requests (quilt_request_commit): an AI or a person asks for a commit, says what it
+// is for and which files changed, and the session owner (whose machine usually commits) is
+// told with a direct message. Shared by the folder's Session and the relay's hosted MCP so
+// both build the same request and the same message.
+import { isSafeRelPath } from './pathrules.js'
+
+export const MAX_COMMIT_MESSAGE = 500
+export const MAX_COMMIT_DESCRIPTION = 2000
+export const MAX_COMMIT_FILES = 100
+
+/** The changed files an agent listed: clean relative paths, no duplicates, at most MAX_COMMIT_FILES. */
+export function cleanCommitFiles (files) {
+  if (files == null) return []
+  if (!Array.isArray(files)) throw new Error('files must be a list of paths')
+  const out = []
+  for (const f of files) {
+    const rel = String(f == null ? '' : f).trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '')
+    if (!rel) continue
+    if (!isSafeRelPath(rel)) throw new Error(`not a path in the project: ${String(f).slice(0, 200)}`)
+    if (!out.includes(rel)) out.push(rel)
+  }
+  if (out.length > MAX_COMMIT_FILES) throw new Error(`list at most ${MAX_COMMIT_FILES} files`)
+  return out
+}
+
+/** The owner's name from a member list ({ name, role }), or ''. */
+export function ownerName (members) {
+  const o = (members || []).find((m) => m && m.role === 'owner' && m.name)
+  return o ? String(o.name) : ''
+}
+
+/** A new open request. Throws when there is nothing to say. */
+export function makeCommitRequest ({ id, by, message, description = '', files = [], branch = '', ts = Date.now() }) {
+  const msg = String(message || '').trim().slice(0, MAX_COMMIT_MESSAGE)
+  if (!msg) throw new Error('say what the commit is for')
+  const desc = String(description || '').trim().slice(0, MAX_COMMIT_DESCRIPTION)
+  const list = cleanCommitFiles(files)
+  return { id, by, message: msg, ...(desc ? { description: desc } : {}), ...(list.length ? { files: list } : {}), ...(branch ? { branch } : {}), ts, state: 'open' }
+}
+
+/** What the owner is told: who wants a commit, what for, which files, and how to settle it. */
+export function commitRequestText (r, { defaultBranch = 'main' } = {}) {
+  const branch = r.branch && r.branch !== defaultBranch ? ` on \`${r.branch}\`` : ''
+  const files = r.files && r.files.length
+    ? ` Files (${r.files.length}): ${r.files.slice(0, 20).join(', ')}${r.files.length > 20 ? `, and ${r.files.length - 20} more` : ''}.`
+    : ''
+  const desc = r.description ? ` ${r.description.replace(/\s+/g, ' ')}` : ''
+  return `📌 Commit requested${branch} (${r.id}): ${r.message.replace(/[.!?]+$/, '')}.${desc}${files} ` +
+    'Commit with git when it is a good moment (quilt_commit_status), then mark it done with quilt_commit_request_done.'
+}
+
+/** The chat message that tells the owner, or null when there is no owner to tell or the owner asked. */
+export function commitRequestMessage (r, { owner, id, defaultBranch, of = null }) {
+  if (!owner || owner === r.by) return null
+  return { id, by: r.by, to: owner, text: commitRequestText(r, { defaultBranch }), ts: r.ts, kind: 'commit', commit: r.id, ...(of ? { of } : {}) }
+}
+
+/** A message that tells the owner about a commit request: settled by committing, not by a reply. */
+export const commitRequestNote = (m) => !!m && m.kind === 'commit'

package/src/commit.js

@@ -0,0 +1,213 @@
+// Commit requests, committed in a person's folder with git: exactly the files a request names
+// (those that differ from HEAD), with its message, then pushed to the branch's upstream. This is
+// the way in when the relay can't commit for the asker (relay-commit.js: no GitHub token, a
+// repository not on GitHub, or the owner keeps agents from committing): a person commits it from
+// the app's commit panel (session.js: commitRequest).
+//
+// Committing touches no file: `git commit --only -- <paths>` moves the branch and the index
+// entries of those paths, and leaves everything else (other people's uncommitted work, files
+// someone staged by hand) as it was. Quilt never merges history: a push git refuses (the
+// remote moved on) is reported, not forced.
+//
+// The pure parts (who changed which uncommitted file, what a person should know before
+// committing a request, the commit message) are here too, so the app, the daemon and tests agree.
+import { execFile } from 'node:child_process'
+import { isSafeRelPath, globMatcher } from './pathrules.js'
+
+export const COMMIT_TIMEOUT_MS = 60 * 1000 // a pre-commit hook may run tests
+export const PUSH_TIMEOUT_MS = 90 * 1000
+export const MAX_REQUEST_FILES = 500
+export const MAX_MESSAGE = 500
+// How long a request is left alone after it is made: the asker's AI may still be saving its files.
+export const REQUEST_SETTLE_MS = 60 * 1000
+
+const NO_PROMPT = { GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never', GIT_OPTIONAL_LOCKS: '0' }
+
+/** Runs git: { ok, out, err }. Never rejects. */
+function git (root, args, { timeout = 15000, env = {} } = {}) {
+  return new Promise((resolve) => {
+    let child
+    try {
+      child = execFile(process.env.QUILT_GIT || 'git', args, { cwd: root, timeout, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, ...NO_PROMPT, ...env } },
+        (err, stdout, stderr) => resolve({ ok: !err, out: String(stdout || ''), err: String(stderr || (err && err.message) || '') }))
+    } catch (err) { return resolve({ ok: false, out: '', err: err.message }) }
+    child.stdin.end()
+  })
+}
+
+/** The paths a request may name: relative, inside the folder, no duplicates. */
+export function cleanFiles (files) {
+  const out = []
+  for (const f of Array.isArray(files) ? files : []) {
+    const p = String(f || '').trim().replace(/\\/g, '/').replace(/^\.\//, '')
+    if (!isSafeRelPath(p) || out.includes(p)) continue
+    out.push(p)
+    if (out.length >= MAX_REQUEST_FILES) break
+  }
+  return out
+}
+
+/**
+ * Which of `files` differ from HEAD (changed, new or deleted, not ignored): Map path -> 'M' | 'A' | 'D'.
+ * Null when git can't say.
+ */
+export async function uncommitted (root, files = null) {
+  const args = ['-c', 'core.quotePath=false', 'status', '--porcelain=v1', '-z', '--no-renames', '--untracked-files=all']
+  if (files) {
+    if (!files.length) return new Map()
+    args.push('--', ...files.map((f) => `:(literal)${f}`))
+  }
+  const r = await git(root, args)
+  if (!r.ok) return null
+  const out = new Map()
+  for (const rec of r.out.split('\0')) {
+    if (rec.length < 4) continue
+    const xy = rec.slice(0, 2)
+    const rel = rec.slice(3)
+    if (xy === '!!') continue
+    out.set(rel, xy === '??' || xy.includes('A') ? 'A' : xy.includes('D') ? 'D' : 'M')
+  }
+  return out
+}
+
+/** When each path was last committed (ms), from the newest `depth` commits: Map path -> ts. */
+export async function lastCommitted (root, { depth = 2000 } = {}) {
+  const r = await git(root, ['-c', 'core.quotePath=false', 'log', `-n${depth}`, '--format=%x00%ct', '--name-only', 'HEAD'])
+  const out = new Map()
+  if (!r.ok) return out
+  let ts = 0
+  for (const line of r.out.split('\n')) {
+    if (line.startsWith('\0')) { ts = Number(line.slice(1)) * 1000 || 0; continue }
+    if (line && !out.has(line)) out.set(line, ts)
+  }
+  return out
+}
+
+/**
+ * Commits the request's files that differ from HEAD, and pushes. Resolves
+ * { hash, files, pushed, pushError, nothing } or throws with a plain reason (git refused, a hook failed).
+ * `push` false only commits. `upstream` is { remote, name } (gitstate.upstreamOf); without one nothing is pushed.
+ */
+export async function commitFiles (root, { files, message, push = true, upstream = null, branch = '' } = {}) {
+  const wanted = cleanFiles(files)
+  const changed = await uncommitted(root, wanted)
+  if (!changed) throw new Error('git could not read this folder')
+  const paths = wanted.filter((f) => changed.has(f))
+  if (!paths.length) return { hash: null, files: [], pushed: false, pushError: null, nothing: true }
+  const spec = paths.map((f) => `:(literal)${f}`)
+  // New files must be known to git before `commit --only` takes them; deletions are taken as they are.
+  const added = paths.filter((f) => changed.get(f) === 'A')
+  if (added.length) {
+    const a = await git(root, ['add', '--', ...added.map((f) => `:(literal)${f}`)])
+    if (!a.ok) throw new Error(`git add failed: ${firstLine(a.err)}`)
+  }
+  const c = await git(root, ['commit', '--only', '--no-edit', '-m', message, '--', ...spec], { timeout: COMMIT_TIMEOUT_MS })
+  if (!c.ok) {
+    // Leave nothing half-done: what was added for this commit goes back to untracked.
+    if (added.length) await git(root, ['reset', '-q', '--', ...added.map((f) => `:(literal)${f}`)])
+    throw new Error(`git commit failed: ${firstLine(c.err || c.out)}`)
+  }
+  const hash = (await git(root, ['rev-parse', 'HEAD'])).out.trim()
+  if (!push || !upstream || !upstream.remote || upstream.remote === '.') return { hash, files: paths, pushed: false, pushError: upstream ? null : 'this branch has no upstream to push to', nothing: false }
+  const target = String(upstream.name || '').startsWith(`${upstream.remote}/`) ? upstream.name.slice(upstream.remote.length + 1) : branch
+  const p = await git(root, ['-c', 'core.askPass=', 'push', '--quiet', upstream.remote, `HEAD:refs/heads/${target}`], {
+    timeout: PUSH_TIMEOUT_MS,
+    env: { GIT_ASKPASS: '', SSH_ASKPASS: '', GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND || 'ssh -o BatchMode=yes' }
+  })
+  return { hash, files: paths, pushed: p.ok, pushError: p.ok ? null : pushProblem(p.err, upstream.remote, target), nothing: false }
+}
+
+const firstLine = (s) => String(s || '').split('\n').map((l) => l.replace(/^(fatal|error):\s*/i, '').trim()).find(Boolean)?.slice(0, 200) || 'unknown error'
+
+/** Why a push failed, in plain words (never a URL: it may carry credentials). */
+export function pushProblem (stderr, remote = 'origin', branch = '') {
+  const e = String(stderr || '').toLowerCase()
+  if (/non-fast-forward|fetch first|rejected/.test(e)) return `${remote}/${branch} has commits this folder doesn't have yet: the commit is made here and will be pushed after Quilt catches the branch up`
+  if (/could not read (username|password)|terminal prompts disabled|authentication failed|permission denied|repository not found|could not read from remote|access denied|returned error: 40[13]/.test(e)) return `git can't sign in to ${remote} from this folder to push`
+  if (/could not resolve host|failed to connect|unable to access|network is unreachable|timed out/.test(e)) return `can't reach ${remote} (no network?)`
+  return `git push failed: ${firstLine(stderr).replace(/[a-z]+:\/\/[^\s'"]*@/gi, '')}`
+}
+
+/** The commit message: what the request says, and who asked (and for which task). */
+export function commitMessage (r) {
+  const first = String(r.message || '').trim().split('\n')[0].slice(0, 120) || 'Changes from the Quilt session'
+  const rest = String(r.message || '').trim().split('\n').slice(1).join('\n').trim()
+  const by = r.by ? `Asked for by ${r.by} in Quilt${r.task ? ` (task ${r.task.id}: ${r.task.title})` : ''}.` : ''
+  return [first, rest, by].filter(Boolean).join('\n\n')
+}
+
+/**
+ * Who made each uncommitted change, from the session's history: for each path in `dirty`, the
+ * people whose own edits (not pulls from git) to it came after it was last committed.
+ * Returns Map path -> [names], newest editor last. `history`: entries, oldest first.
+ */
+export function editorsSince (dirty, history, committedAt = new Map()) {
+  const out = new Map()
+  for (const rel of dirty) out.set(rel, [])
+  for (const e of history || []) {
+    if (!e || !out.has(e.path) || e.pulled || !e.by) continue
+    if ((e.ts || 0) <= (committedAt.get(e.path) || 0)) continue
+    const list = out.get(e.path)
+    const i = list.indexOf(e.by)
+    if (i >= 0) list.splice(i, 1)
+    list.push(e.by)
+  }
+  return out
+}
+
+/**
+ * Uncommitted work grouped by who made it: [{ by, files }], most files first. A file several
+ * people changed is listed under each. Files no history entry explains go under ''.
+ */
+export function uncommittedByPerson (editors) {
+  const groups = new Map()
+  for (const [rel, names] of editors) {
+    for (const n of names.length ? names : ['']) {
+      if (!groups.has(n)) groups.set(n, [])
+      groups.get(n).push(rel)
+    }
+  }
+  return [...groups].map(([by, files]) => ({ by, files: files.sort() })).sort((a, b) => b.files.length - a.files.length || a.by.localeCompare(b.by))
+}
+
+/**
+ * What the person committing a request should know first, or '': a file with conflict markers,
+ * one that also holds others' uncommitted changes (they would go in too), one someone else holds,
+ * or an asker still at work.
+ */
+export function requestWarning (r, { editors, claims = [], markers = new Set(), taskEditors = new Set(), busy = [], now = Date.now() } = {}) {
+  if (now - (r.ts || 0) < REQUEST_SETTLE_MS) return 'just asked'
+  if (busy.includes(r.by)) return `${r.by} is still working`
+  for (const [rel, names] of editors) {
+    if (markers.has(rel)) return `${rel} has conflict markers`
+    const others = names.filter((n) => n !== r.by && !taskEditors.has(n))
+    if (others.length) return `${rel} also has uncommitted changes by ${others.join(', ')}`
+    const held = claims.find((c) => c && c.by && c.by !== r.by && globMatcher(String(c.pattern || ''))(rel))
+    if (held) return `${held.by} holds ${rel}`
+  }
+  return ''
+}
+
+// ------------------------------------------------------------- words --
+// The same for the local and the hosted tools, and the HTTP routes' docs.
+
+export const REQUEST_COMMIT_DESCRIPTION = 'Ask a person to commit your finished work, when you can\'t get it into git yourself (the owner keeps agents from committing, nobody has connected GitHub, or the repository is not on GitHub). ' +
+  'A person with git on this branch commits exactly these files (those that differ from git) with your message, from their app, and you are told the commit. ' +
+  'Give the files you changed; without them, the task\'s changes (task) or every change of yours on record are asked for.'
+
+/** Open requests (with ids, files and what holds them up) and recent commits, as lines for an agent. */
+export function describeCommitRequests (c, { canCommit = false } = {}) {
+  const lines = []
+  const open = c.open || []
+  if (open.length) {
+    lines.push('Open commit requests:')
+    for (const r of open) {
+      const files = Array.isArray(r.files) && r.files.length ? ` (${r.files.length} file${r.files.length === 1 ? '' : 's'}: ${r.files.slice(0, 8).join(', ')}${r.files.length > 8 ? ', …' : ''})` : ''
+      lines.push(`- [${r.id}] ${r.by}${r.branch ? ` on \`${r.branch}\`` : ''}: ${r.message}${r.task ? ` (task ${r.task.id})` : ''}${files}${r.error ? `. Last try: ${r.error}` : ''}`)
+    }
+    lines.push(canCommit ? 'This folder has git: its app commits a request with its Commit button.' : 'A person with git on that branch commits them from their app; the asker is told the commit.')
+  } else lines.push('No open commit requests.')
+  const recent = (c.recent || []).filter((r) => r.hash)
+  if (recent.length) lines.push('Committed lately:', ...recent.map((r) => `- ${r.hash.slice(0, 7)} ${r.message} (${r.by}${r.pushed === false ? `; not pushed${r.pushError ? `: ${r.pushError}` : ''}` : ''})`))
+  return lines.join('\n')
+}