heyquilt 0.3.122 → 0.3.138

package/src/quilts/records.js

@@ -1,211 +0,0 @@
-// The immutable records of Quilt source control (plans/quilt-source-control/README §3.1):
-// commits, their file changes and conflict terms, as JSON for the API and as canonical CBOR
-// for their ids. A commit's id depends only on what its author made: no tree, no server time,
-// no sequence number, no git hash.
-import { encode, decode } from './cbor.js'
-import { idOf, isId, idBytes } from './hash.js'
-
-// gitlink: a git submodule, kept as git has it: its blob is the submodule commit's sha as text.
-export const MODES = ['file', 'exec', 'symlink', 'quilt', 'gitlink']
-export const TERM_KINDS = ['content', 'order', 'edit_vs_delete', 'name', 'mode', 'square_divergence']
-export const MAX_FILES_PER_COMMIT = 20000
-export const MAX_MESSAGE = 64 * 1024
-
-const hex = (b) => Buffer.from(b).toString('hex')
-
-/**
- * A path as the quilt keeps it: NFC, posix, relative, no empty, '.' or '..' segments, no
- * trailing slash, never inside .git. Throws on anything else.
- */
-export function cleanPath (p) {
-  if (typeof p !== 'string' || !p) throw new Error('a path is required')
-  const s = p.normalize('NFC')
-  if (s.includes('\\') || s.includes('\0')) throw new Error(`bad path ${JSON.stringify(p)}: use / and no NUL`)
-  const parts = s.split('/')
-  if (parts.some((x) => !x || x === '.' || x === '..')) throw new Error(`bad path ${JSON.stringify(p)}`)
-  if (parts[0] === '.git') throw new Error(`bad path ${JSON.stringify(p)}: .git is not part of a quilt`)
-  return s
-}
-
-/** A path prefix (a block's directory): '' for the root, else a clean path. */
-export function cleanPrefix (p) {
-  const s = String(p || '').replace(/^\/+|\/+$/g, '')
-  return s ? cleanPath(s) : ''
-}
-
-/** Whether `path` lies under `prefix` (a directory, or the file itself). */
-export const under = (path, prefix) => !prefix || path === prefix || path.startsWith(prefix + '/')
-
-function side (s) {
-  return {
-    ...(s.blob ? { b: idBytes(s.blob) } : {}),
-    ...(s.mode ? { m: s.mode } : {}),
-    ...(s.from_commit ? { fc: idBytes(s.from_commit) } : {}),
-    ...(s.from_square ? { fs: s.from_square } : {}),
-    ...(s.by ? { by: s.by } : {})
-  }
-}
-const unside = (s) => ({
-  ...(s.b ? { blob: hex(s.b) } : {}),
-  ...(s.m ? { mode: s.m } : {}),
-  ...(s.fc ? { from_commit: hex(s.fc) } : {}),
-  ...(s.fs ? { from_square: s.fs } : {}),
-  ...(s.by ? { by: s.by } : {})
-})
-
-/** A conflict term's canonical bytes (kind, N adds, N−1 removes, origin). */
-export function termBytes (t) {
-  if (!TERM_KINDS.includes(t.kind)) throw new Error(`bad conflict kind ${t.kind}`)
-  if (!Array.isArray(t.adds) || !Array.isArray(t.removes) || t.adds.length !== t.removes.length + 1) throw new Error('a conflict term has N adds and N-1 removes')
-  return encode({
-    k: t.kind,
-    ad: t.adds.map(side),
-    rm: t.removes.map(side),
-    ...(t.origin ? { or: { r: t.origin.reason, ...(t.origin.against ? { ag: idBytes(t.origin.against) } : {}) } } : {}),
-    // 07's suggestion: a ladder step that may not merge by itself (`words`) and the text it made.
-    ...(t.suggestion ? { sg: { h: t.suggestion.how, b: idBytes(t.suggestion.blob) } } : {}),
-    // A name term's other paths (a file on a directory, or one case-folded name): kept side wins the name.
-    ...(t.clash && t.clash.length ? { cl: [...t.clash].sort() } : {})
-  })
-}
-
-export function decodeTerm (bytes) {
-  const r = decode(bytes)
-  return {
-    kind: r.k,
-    adds: r.ad.map(unside),
-    removes: r.rm.map(unside),
-    ...(r.or ? { origin: { reason: r.or.r, ...(r.or.ag ? { against: hex(r.or.ag) } : {}) } } : {}),
-    ...(r.sg ? { suggestion: { how: r.sg.h, blob: hex(r.sg.b) } } : {}),
-    ...(r.cl ? { clash: r.cl } : {})
-  }
-}
-
-export const termId = (t) => idOf('term', termBytes(t))
-
-/** Checks and normalises one FileChange (JSON form). */
-export function cleanChange (c) {
-  const path = cleanPath(c.path)
-  if (c.op === 'delete') return { path, op: 'delete' }
-  if (c.op === 'put') {
-    if (!isId(c.blob)) throw new Error(`${path}: put needs a blob id`)
-    const mode = c.mode || 'file'
-    if (!MODES.includes(mode)) throw new Error(`${path}: bad mode ${mode}`)
-    if (!Number.isSafeInteger(c.size) || c.size < 0) throw new Error(`${path}: put needs a size`)
-    const out = { path, op: 'put', blob: c.blob, mode, size: c.size }
-    if (c.copy_from) out.copy_from = { path: cleanPath(c.copy_from.path), commit: c.copy_from.commit }
-    return out
-  }
-  if (c.op === 'conflict') {
-    if (!isId(c.term)) throw new Error(`${path}: conflict needs a term id`)
-    return { path, op: 'conflict', term: c.term }
-  }
-  throw new Error(`${path}: bad op ${c.op}`)
-}
-
-/** Sorts and checks a commit's changes: by path (bytewise, as the tree sorts), no duplicates. */
-export function cleanChanges (changes) {
-  if (!Array.isArray(changes)) throw new Error('changes must be a list')
-  if (changes.length > MAX_FILES_PER_COMMIT) throw Object.assign(new Error(`too many files in one commit (${changes.length}; at most ${MAX_FILES_PER_COMMIT})`), { code: 'too_many_files' })
-  const out = changes.map(cleanChange).sort((a, b) => cmpPath(a.path, b.path))
-  for (let i = 1; i < out.length; i++) if (out[i].path === out[i - 1].path) throw new Error(`${out[i].path} is changed twice`)
-  return out
-}
-
-/** Bytewise order of UTF-8 paths, the order of every tree and change list. */
-export function cmpPath (a, b) {
-  return a === b ? 0 : Buffer.compare(Buffer.from(a), Buffer.from(b))
-}
-
-function changeCbor (c) {
-  if (c.op === 'delete') return { p: c.path, o: 'delete' }
-  if (c.op === 'conflict') return { p: c.path, o: 'conflict', t: idBytes(c.term) }
-  return {
-    p: c.path, o: 'put', b: idBytes(c.blob), m: c.mode, z: c.size,
-    ...(c.copy_from ? { cf: { p: c.copy_from.path, c: idBytes(c.copy_from.commit) } } : {})
-  }
-}
-function unchange (c) {
-  if (c.o === 'delete') return { path: c.p, op: 'delete' }
-  if (c.o === 'conflict') return { path: c.p, op: 'conflict', term: hex(c.t) }
-  return { path: c.p, op: 'put', blob: hex(c.b), mode: c.m, size: c.z, ...(c.cf ? { copy_from: { path: c.cf.p, commit: hex(c.cf.c) } } : {}) }
-}
-
-/**
- * A commit in its JSON form, checked and normalised: { quilt_id, square_id, parents,
- * predecessor?, author: { member_id, kind, name, tool?, model? }, on_behalf_of?, task_id?,
- * session_room?, message, authored_at, changes, stack, conflicted }.
- */
-export function cleanCommit (c) {
-  if (!c.quilt_id || !c.square_id) throw new Error('a commit names its quilt and square')
-  const parents = c.parents || []
-  if (!parents.every(isId)) throw new Error('parents must be commit ids')
-  if (c.predecessor != null && !isId(c.predecessor)) throw new Error('predecessor must be a commit id')
-  const a = c.author || {}
-  if (!a.member_id || !['person', 'agent', 'system'].includes(a.kind)) throw new Error('author needs member_id and kind')
-  const message = String(c.message ?? '')
-  if (Buffer.byteLength(message) > MAX_MESSAGE) throw new Error('commit message over 64 KiB')
-  const changes = cleanChanges(c.changes || [])
-  const stack = {}
-  for (const [k, v] of Object.entries(c.stack || {})) if (v != null) stack[k] = String(v)
-  return {
-    quilt_id: String(c.quilt_id),
-    square_id: String(c.square_id),
-    parents: [...parents],
-    ...(c.predecessor ? { predecessor: c.predecessor } : {}),
-    author: { member_id: String(a.member_id), kind: a.kind, name: String(a.name || ''), ...(a.tool ? { tool: String(a.tool) } : {}), ...(a.model ? { model: String(a.model) } : {}) },
-    ...(c.on_behalf_of ? { on_behalf_of: String(c.on_behalf_of) } : {}),
-    ...(c.task_id ? { task_id: String(c.task_id) } : {}),
-    ...(c.session_room ? { session_room: String(c.session_room) } : {}),
-    message,
-    authored_at: Math.trunc(Number(c.authored_at) || 0),
-    changes,
-    stack,
-    conflicted: changes.filter((x) => x.op === 'conflict').length
-  }
-}
-
-/** A commit's canonical bytes. */
-export function commitBytes (c) {
-  const a = c.author
-  return encode({
-    q: c.quilt_id,
-    s: c.square_id,
-    p: c.parents.map(idBytes),
-    pr: c.predecessor ? idBytes(c.predecessor) : undefined,
-    a: { m: a.member_id, k: a.kind, n: a.name, t: a.tool, md: a.model },
-    ob: c.on_behalf_of,
-    tk: c.task_id,
-    sr: c.session_room,
-    msg: c.message,
-    at: c.authored_at,
-    c: c.changes.map(changeCbor),
-    st: Object.keys(c.stack).length ? c.stack : undefined,
-    cn: c.conflicted
-  })
-}
-
-export function decodeCommit (bytes) {
-  const r = decode(bytes)
-  return {
-    quilt_id: r.q,
-    square_id: r.s,
-    parents: r.p.map(hex),
-    ...(r.pr ? { predecessor: hex(r.pr) } : {}),
-    author: { member_id: r.a.m, kind: r.a.k, name: r.a.n, ...(r.a.t ? { tool: r.a.t } : {}), ...(r.a.md ? { model: r.a.md } : {}) },
-    ...(r.ob ? { on_behalf_of: r.ob } : {}),
-    ...(r.tk ? { task_id: r.tk } : {}),
-    ...(r.sr ? { session_room: r.sr } : {}),
-    message: r.msg,
-    authored_at: r.at,
-    changes: r.c.map(unchange),
-    stack: r.st || {},
-    conflicted: r.cn
-  }
-}
-
-/** The commit's id, from its canonical bytes. */
-export const commitId = (c) => idOf('commit', commitBytes(c))
-
-/** A blob's id: BLAKE3 of the raw file bytes under the blob context. */
-export const blobId = (bytes) => idOf('blob', bytes)

package/src/quilts/resolutions.js

@@ -1,69 +0,0 @@
-// Remembered resolutions (plans/quilt-source-control/07, "Reuse", D12): when someone settles a
-// conflicted file, seam keeps the answer keyed by the conflict's content: the path, the base and
-// every side's bytes. When a later rebase, merge or fold meets the very same conflict (the usual
-// case when a square is rebased again, or the same change is cherry-picked twice), the stored
-// answer is applied and reported as `reuse`, naming who settled it first. Because the key is the
-// content, a side that changed since cannot match, so a wrong reuse is impossible by construction.
-// Kept per file, not per hunk: one key per file conflict is enough to never settle it twice, and
-// it reads the same from the CLI, MCP and HTTP. A row stays until someone forgets it.
-import { QuiltError } from './errors.js'
-import { keyOf } from './hash.js'
-
-const REUSABLE = new Set(['content', 'order', 'edit_vs_delete', 'mode'])
-const sideKey = (s) => s && s.blob ? `${s.blob}:${s.mode || 'file'}` : '-'
-
-/** The key of a conflict on `path` described by `term` ({ kind, adds, removes }), or null when it can't be remembered. */
-export function resolutionKey (path, term) {
-  if (!term || !REUSABLE.has(term.kind) || term.clash) return null
-  const adds = (term.adds || []).map(sideKey).sort()
-  const base = sideKey((term.removes || [])[0])
-  return keyOf('resolution', Buffer.from(JSON.stringify([path, term.kind, base, adds]), 'utf8'))
-}
-
-/** The stored answer for this conflict, or null. */
-export async function recall (store, q, path, term) {
-  const key = resolutionKey(path, term)
-  if (!key || !store.resolution) return null
-  return store.resolution(q, key)
-}
-
-/**
- * Remembers settled conflicts: entries [{ path, term (id), pick: { blob, mode, size } | null, how }].
- * Terms are read with `getTerm`; a term that can't be remembered (a name clash) is skipped.
- */
-export async function remember (store, getTerm, q, entries, me, at) {
-  for (const e of entries) {
-    const t = await getTerm(q, e.term).catch(() => null)
-    const key = resolutionKey(e.path, t)
-    if (!key) continue
-    await store.setResolution({ quilt_id: q, key, path: e.path, blob: e.pick ? e.pick.blob : null, mode: e.pick ? e.pick.mode || 'file' : null, size: e.pick ? e.pick.size ?? null : null, how: e.how, by: me.member_id, at })
-  }
-}
-
-const view = (r) => ({ key: r.key, short: r.key.slice(0, 12), path: r.path, answer: r.blob ? 'put' : 'delete', ...(r.blob ? { blob: r.blob, mode: r.mode, size: r.size } : {}), how: r.how, by: r.by, at: r.at })
-
-export function resolutionOps (svc) {
-  const { store, quiltFor, fromStore } = svc.internals
-
-  /** GET /resolutions[?path=]: the remembered resolutions, newest first. */
-  async function resolutions (me, ref, { path } = {}) {
-    const q = await quiltFor(me, ref, 'read')
-    let rows = await store.resolutions(q.id)
-    if (path) rows = rows.filter((r) => r.path === path)
-    return { resolutions: rows.sort((a, b) => b.at - a.at).map(view) }
-  }
-
-  /** DELETE /resolutions/:key (the key or its first 8+ characters): the conflict is asked about again next time. */
-  async function forgetResolution (me, ref, key) {
-    const q = await quiltFor(me, ref, 'write')
-    const k = String(key || '').toLowerCase()
-    if (!/^[0-9a-f]{8,64}$/.test(k)) throw new QuiltError(400, 'bad_request', 'name a resolution by its key (8 to 64 hex characters)')
-    const hits = (await store.resolutions(q.id)).filter((r) => r.key.startsWith(k))
-    if (!hits.length) throw new QuiltError(404, 'not_found', `no remembered resolution ${k}`)
-    if (hits.length > 1) throw new QuiltError(400, 'bad_request', `${k} names ${hits.length} resolutions; give more of the key`)
-    try { await store.deleteResolution({ quilt_id: q.id, key: hits[0].key }) } catch (err) { throw fromStore(err) }
-    return { ok: true, forgotten: view(hits[0]) }
-  }
-
-  return { resolutions, forgetResolution }
-}

package/src/quilts/reviews.js

@@ -1,208 +0,0 @@
-// Review on squares (plans/quilt-source-control/13): comments (on the square or on one line of a
-// file at its head), approvals, requests for changes, and a line's rule that a square needs N
-// approvals before it merges into that line. Every review row is kept; a member's latest verdict
-// (approve, request_changes or dismiss) is the one that holds.
-//
-// An approval names the square's head when it was given and counts only while the head is the
-// same: a new commit asks for a fresh look. Nobody approves their own square: the holder, whoever
-// opened it, and the person either works for are the requester set, and an approval from that
-// set is refused. A request for changes from someone whose approval would count holds the merge
-// until they approve or dismiss it.
-//
-// A line can also require checks (the server-side hook: CI or any runner reports a named check
-// green or red on a square's latest commit, and the merge is refused until each required check is
-// green there). Seam does not run the checks; whoever runs them reports with a key.
-import { QuiltError, squareShort } from './service.js'
-import { uuidv7 } from './ids.js'
-import { cleanRunners, cleanTiers, cleanGlobs } from './checks.js'
-
-export const KINDS = ['comment', 'approve', 'request_changes', 'dismiss']
-export const MAX_BODY = 20000
-export const MAX_APPROVALS = 20
-export const MAX_CHECKS = 20
-const CHECK_NAME = /^[A-Za-z0-9._\/:-]{1,100}$/
-
-/** The member ids that may not approve a square: its holder, its opener, and whom they act for. */
-export function requesters (sq, actsFor = []) {
-  return new Set([sq.holder, sq.opened_by, ...actsFor].filter(Boolean))
-}
-
-/** Where a square stands against its line's rule, from its review rows (oldest first). */
-export function standing (sq, rows, need = 0, not = requesters(sq)) {
-  const latest = new Map()
-  for (const r of rows) if (r.kind !== 'comment') latest.set(r.author, r)
-  const counts = (r) => !not.has(r.author) && !(r.on_behalf_of && not.has(r.on_behalf_of))
-  const approvedBy = []
-  const changesBy = []
-  for (const r of latest.values()) {
-    if (!counts(r)) continue
-    if (r.kind === 'approve' && r.head === (sq.head || null)) approvedBy.push(r.author)
-    if (r.kind === 'request_changes') changesBy.push(r.author)
-  }
-  return { need, have: approvedBy.length, approved_by: approvedBy, changes_requested_by: changesBy, ready: approvedBy.length >= need && !changesBy.length }
-}
-
-const view = (sq, r) => ({
-  id: r.id,
-  square: squareShort(r.square_id),
-  kind: r.kind,
-  author: r.author,
-  ...(r.on_behalf_of ? { on_behalf_of: r.on_behalf_of } : {}),
-  body: r.body || '',
-  head: r.head || null,
-  ...(r.path ? { path: r.path, line: r.line ?? null } : {}),
-  outdated: (r.head || null) !== (sq.head || null),
-  at: r.at
-})
-
-export function reviewOps (svc) {
-  const { store, now, quiltFor, squareByRef, getCommit, fromStore } = svc.internals
-
-  // The requester set: holder, opener, and the person the square's latest commit was made for.
-  async function notAllowed (q, sq) {
-    const c = sq.head ? await getCommit(q, sq.head).catch(() => null) : null
-    return requesters(sq, [c?.on_behalf_of])
-  }
-
-  async function ruleOf (q, line) {
-    const r = (await store.lineRules(q)).find((x) => x.line === line)
-    const tg = r?.targeting || {}
-    return { approvals: r ? r.approvals : 0, checks: r?.checks || [], runners: r?.runners || {}, ...(tg.tiers && Object.keys(tg.tiers).length ? { tiers: tg.tiers } : {}), ...(tg.tests?.length ? { tests: tg.tests } : {}), ...(tg.ci_config?.length ? { ci_config: tg.ci_config } : {}), since_seq: r?.since_seq ?? null }
-  }
-  const need = async (q, line) => (await ruleOf(q, line)).approvals
-
-  // The square's checks against what its line requires: each named check's latest report, and
-  // whether it is green for the square's latest commit.
-  async function checksOf (q, sq, required) {
-    const reports = await store.squareChecks(q, sq.id)
-    const names = [...new Set([...required, ...reports.map((r) => r.name)])]
-    return names.map((name) => {
-      const r = reports.find((x) => x.name === name)
-      const state = !r ? 'missing' : r.head !== (sq.head || null) ? 'stale' : r.status
-      return { name, required: required.includes(name), status: state, ...(r ? { by: r.by, at: r.at } : {}) }
-    })
-  }
-
-  /** GET /squares/:id/reviews: every review row, oldest first, and where the square stands. */
-  async function reviews (me, ref, sqRef) {
-    const q = await quiltFor(me, ref, 'read')
-    const sq = await squareByRef(q.id, sqRef)
-    const rows = await store.reviews(q.id, sq.id) // in the order they were written
-    const rule = await ruleOf(q.id, sq.line)
-    const s = standing(sq, rows, rule.approvals, await notAllowed(q.id, sq))
-    const checks = await checksOf(q.id, sq, rule.checks)
-    const checksGreen = checks.every((c) => !c.required || c.status === 'green')
-    return { square: squareShort(sq.id), line: sq.line, head: sq.head || null, reviews: rows.map((r) => view(sq, r)), ...s, checks, ready: s.ready && checksGreen }
-  }
-
-  /** POST /squares/:id/checks { check, status }: a check's result for the square's latest commit (a writer: CI with a key). */
-  async function reportSquareCheck (me, ref, sqRef, body = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await squareByRef(q.id, sqRef)
-    const name = String(body.check || '').trim()
-    if (!CHECK_NAME.test(name)) throw new QuiltError(400, 'bad_request', 'check: a name of up to 100 letters, digits, dots, dashes, underscores, slashes or colons')
-    if (!['green', 'red'].includes(body.status)) throw new QuiltError(400, 'bad_request', 'status is green or red')
-    if (!sq.head) throw new QuiltError(400, 'bad_request', 'the square has no commits to check yet')
-    const head = body.head || sq.head
-    if (head !== sq.head) throw new QuiltError(409, 'head_moved', 'the square moved on since that commit: check its latest commit', { head: sq.head })
-    const rule = await ruleOf(q.id, sq.line)
-    const noted = svc.internals.noteVerdict ? await svc.internals.noteVerdict(me, q, { name, tier: 'pre_merge', commit: head, square: sq.id, line: sq.line, verdict: body.status, run_key: body.run_key, url: body.url }) : {}
-    if (noted.advisory) return { square: squareShort(sq.id), check: name, status: body.status, head, advisory: true, runners: rule.runners[name], checks: await checksOf(q.id, sq, rule.checks) }
-    try { await store.setSquareCheck({ quilt_id: q.id, square_id: sq.id, name, status: body.status, head, by: me.member_id, at: now() }) } catch (err) { throw fromStore(err) }
-    return { square: squareShort(sq.id), check: name, status: body.status, head, checks: await checksOf(q.id, sq, rule.checks) }
-  }
-
-  /** POST /squares/:id/reviews { kind, body?, path?, line? }: a comment or a verdict on the square's head. */
-  async function review (me, ref, sqRef, body = {}) {
-    const q = await quiltFor(me, ref, 'read')
-    const sq = await squareByRef(q.id, sqRef)
-    const kind = body.kind || 'comment'
-    if (!KINDS.includes(kind)) throw new QuiltError(400, 'bad_request', `kind is one of ${KINDS.join(', ')}`)
-    const text = String(body.body || '')
-    if (text.length > MAX_BODY) throw new QuiltError(400, 'bad_request', `a review is up to ${MAX_BODY} characters`)
-    if ((kind === 'comment' || kind === 'request_changes') && !text.trim()) throw new QuiltError(400, 'bad_request', kind === 'comment' ? 'say something: body is empty' : 'say what to change: body is empty')
-    if (kind !== 'comment' && !['open', 'merging'].includes(sq.state)) throw new QuiltError(409, 'square_closed', `the square is ${sq.state}`)
-    if (kind === 'approve' || kind === 'request_changes') {
-      if (!sq.head) throw new QuiltError(400, 'bad_request', 'the square has no commits to review yet')
-      const not = await notAllowed(q.id, sq)
-      if (not.has(me.member_id) || (me.on_behalf_of && not.has(me.on_behalf_of))) {
-        throw new QuiltError(403, 'own_square', `you cannot ${kind === 'approve' ? 'approve' : 'request changes on'} a square you or the person you work for opened or hold: ask someone else to review it`)
-      }
-    }
-    let path = null
-    let line = null
-    if (body.path != null && body.path !== '') {
-      if (kind !== 'comment') throw new QuiltError(400, 'bad_request', 'only a comment goes on a file')
-      path = String(body.path).replace(/^\.\//, '')
-      if (path.length > 1000 || path.split('/').includes('..') || path.startsWith('/')) throw new QuiltError(400, 'bad_request', 'path is a file path in the quilt')
-      if (body.line != null) {
-        line = Number(body.line)
-        if (!Number.isInteger(line) || line < 1) throw new QuiltError(400, 'bad_request', 'line is a line number from 1')
-      }
-    } else if (body.line != null) throw new QuiltError(400, 'bad_request', 'a line number goes with a path')
-    const row = { quilt_id: q.id, id: uuidv7(now()), square_id: sq.id, kind, author: me.member_id, on_behalf_of: me.on_behalf_of || null, body: text, head: sq.head || null, path, line, at: now() }
-    try { await store.addReview(row) } catch (err) { throw fromStore(err) }
-    const rows = await store.reviews(q.id, sq.id)
-    return { review: view(sq, row), ...standing(sq, rows, await need(q.id, sq.line), await notAllowed(q.id, sq)) }
-  }
-
-  /** PUT /lines/:name/policy { approvals }: how many approvals a square needs to merge into the line. A person who is an admin only. */
-  async function setLinePolicy (me, ref, lineName, body = {}) {
-    const q = await quiltFor(me, ref, 'admin')
-    if (me.kind !== 'person') throw new QuiltError(403, 'forbidden', 'only a person sets what a line needs to merge')
-    const line = String(lineName)
-    if (!await store.getLine(q.id, line)) throw new QuiltError(404, 'not_found', `no line ${line}`)
-    const was = await ruleOf(q.id, line)
-    const n = body.approvals === undefined ? was.approvals : Number(body.approvals)
-    if (!Number.isInteger(n) || n < 0 || n > MAX_APPROVALS) throw new QuiltError(400, 'bad_request', `approvals is a whole number from 0 to ${MAX_APPROVALS}`)
-    let checks = was.checks
-    if (body.checks !== undefined) {
-      if (!Array.isArray(body.checks) || body.checks.length > MAX_CHECKS) throw new QuiltError(400, 'bad_request', `checks is a list of up to ${MAX_CHECKS} check names`)
-      checks = [...new Set(body.checks.map((c) => String(c).trim()))]
-      const bad = checks.find((c) => !CHECK_NAME.test(c))
-      if (bad !== undefined) throw new QuiltError(400, 'bad_request', `${bad || '(empty)'} is not a check name: letters, digits, dots, dashes, underscores, slashes or colons`)
-    }
-    const runners = body.runners === undefined ? was.runners : cleanRunners(body.runners, (c) => CHECK_NAME.test(c))
-    const tiers = body.tiers === undefined ? (was.tiers || {}) : cleanTiers(body.tiers, (c) => CHECK_NAME.test(c))
-    const tests = body.tests === undefined ? (was.tests || []) : cleanGlobs(body.tests, 'tests')
-    const ciConfig = body.ci_config === undefined ? (was.ci_config || []) : cleanGlobs(body.ci_config, 'ci_config')
-    const targeting = { ...(Object.keys(tiers).length ? { tiers } : {}), ...(tests.length ? { tests } : {}), ...(ciConfig.length ? { ci_config: ciConfig } : {}) }
-    try { await store.setLineRule({ quilt_id: q.id, line, approvals: n, checks, runners, targeting, actor: me.member_id, at: now() }) } catch (err) { throw fromStore(err) }
-    return { line, approvals: n, checks, runners, ...targeting }
-  }
-
-  /** GET /lines/:name/policy */
-  async function linePolicy (me, ref, lineName) {
-    const q = await quiltFor(me, ref, 'read')
-    const line = String(lineName)
-    if (!await store.getLine(q.id, line)) throw new QuiltError(404, 'not_found', `no line ${line}`)
-    const { since_seq: seq, ...rule } = await ruleOf(q.id, line)
-    void seq
-    return { line, ...rule }
-  }
-
-  /** Refuses a merge of `sq` into `line` that the line's rule does not allow yet (428 policy). */
-  async function guardReview (q, sq, line) {
-    const rule = await ruleOf(q, line)
-    const n = rule.approvals
-    if (!n && !rule.checks.length) return
-    const s = n ? standing(sq, await store.reviews(q, sq.id), n, await notAllowed(q, sq)) : { ready: true, have: 0, changes_requested_by: [] }
-    const notGreen = rule.checks.length ? (await checksOf(q, sq, rule.checks)).filter((c) => c.required && c.status !== 'green') : []
-    if (notGreen.length) {
-      // Asking to merge asks the runners of a required check that has nothing on the head yet.
-      if (svc.internals.askForChecks) await svc.internals.askForChecks(q, sq, notGreen.filter((x) => x.status !== 'red').map((x) => x.name), sq.holder)
-      const c = notGreen[0]
-      const why = { missing: 'has not reported', stale: 'has not reported on the latest commit', red: 'is red' }[c.status]
-      throw new QuiltError(428, 'policy', `${line} needs check ${c.name} green on ${squareShort(sq.id)}'s latest commit and it ${why}: run it and report with seam check ${c.name} green --square ${squareShort(sq.id)}`,
-        { needs: notGreen.map((x) => ({ rule: 'check', kind: 'check', check: x.name, status: x.status })) })
-    }
-    if (s.ready) return
-    const needs = []
-    if (s.have < n) needs.push({ rule: 'approvals', kind: 'approval', need: n, have: s.have })
-    if (s.changes_requested_by.length) needs.push({ rule: 'changes_requested', kind: 'approval', who: s.changes_requested_by })
-    const why = s.have < n ? `${line} needs ${n} approval${n === 1 ? '' : 's'} of the square's latest commit and it has ${s.have}` : `${s.changes_requested_by.join(', ')} asked for changes`
-    throw new QuiltError(428, 'policy', `${why}: ask someone to review ${squareShort(sq.id)} (seam review ${squareShort(sq.id)})`, { needs })
-  }
-
-  return { reviews, review, reportSquareCheck, setLinePolicy, linePolicy, guardReview }
-}