heyquilt 0.3.122 → 0.3.138

package/src/quilts/xdiff.js

@@ -1,435 +0,0 @@
-// A port of git's xdiff line diff (Myers with xdiff's heuristics, record cleanup, and change
-// compaction with the indent heuristic), so `blame` and `diff` choose the same lines git does.
-//
-// Ported from git's xdiff/xprepare.c, xdiff/xdiffi.c and xdiff-interface.c (trim_common_tail).
-// LibXDiff by Davide Libenzi, Copyright (C) 2003, LGPL-2.1-or-later; git's changes are under the
-// same terms. Structure and names follow the C so the two can be compared line by line.
-
-const XDL_KPDIS_RUN = 4
-const XDL_MAX_EQLIMIT = 1024
-const XDL_SIMSCAN_WINDOW = 100
-const XDL_MAX_COST_MIN = 256
-const XDL_HEUR_MIN_COST = 256
-const XDL_LINE_MAX = Number.MAX_SAFE_INTEGER
-const XDL_SNAKE_CNT = 20
-const XDL_K_HEUR = 4
-const DISCARD = 0; const KEEP = 1; const INVESTIGATE = 2
-
-function bogosqrt (n) { let i = 1; for (; n > 0; n = Math.floor(n / 4)) i *= 2; return i }
-
-/** git's trim_common_tail: the byte length to drop from both ends' tails (blame only). */
-function commonTail (a, b) {
-  const blk = 1024
-  let trimmed = 0; let recovered = 0
-  const smaller = Math.min(a.length, b.length)
-  while (blk + trimmed <= smaller &&
-    a.compare(b, b.length - trimmed - blk, b.length - trimmed, a.length - trimmed - blk, a.length - trimmed) === 0) trimmed += blk
-  const ap = a.length - trimmed
-  while (recovered < trimmed) if (a[ap + recovered++] === 10) break
-  return trimmed - recovered
-}
-
-/** Records of a buffer: [start, end) per line, each with its \n. */
-function records (buf, size) {
-  const starts = []
-  let s = 0
-  while (s < size) {
-    let e = buf.indexOf(10, s)
-    e = e < 0 || e >= size ? size : e + 1
-    starts.push(s, e)
-    s = e
-  }
-  return starts
-}
-
-function prepare (buf, size, classes, counts, pass) {
-  const r = records(buf, size)
-  const n = r.length / 2
-  const mph = new Int32Array(n)
-  for (let i = 0; i < n; i++) {
-    const key = buf.toString('latin1', r[2 * i], r[2 * i + 1])
-    let id = classes.get(key)
-    if (id === undefined) { id = classes.size; classes.set(key, id); counts.push(0, 0) }
-    counts[2 * id + pass]++
-    mph[i] = id
-  }
-  return { buf, r, nrec: n, mph, changed: new Uint8Array(n + 2), ref: null, nreff: 0, dstart: 0, dend: n - 1 }
-}
-
-function cleanMmatch (action, i, len) {
-  let s = 0; let e = len - 1
-  if (i - s > XDL_SIMSCAN_WINDOW) s = i - XDL_SIMSCAN_WINDOW
-  if (e - i > XDL_SIMSCAN_WINDOW) e = i + XDL_SIMSCAN_WINDOW
-  let r; let rdis0 = 0; let rpdis0 = 1; let rdis1 = 0; let rpdis1 = 1
-  for (r = 1; i - r >= s; r++) {
-    const a = action[i - r]
-    if (a === DISCARD) rdis0++
-    else if (a === INVESTIGATE) rpdis0++
-    else break
-  }
-  if (rdis0 === 0) return false
-  for (r = 1; i + r <= e; r++) {
-    const a = action[i + r]
-    if (a === DISCARD) rdis1++
-    else if (a === INVESTIGATE) rpdis1++
-    else break
-  }
-  if (rdis1 === 0) return false
-  rdis1 += rdis0
-  rpdis1 += rpdis0
-  return rpdis1 * XDL_KPDIS_RUN < rpdis1 + rdis1
-}
-
-function trimEnds (x1, x2) {
-  const lim = Math.min(x1.nrec, x2.nrec)
-  let i = 0
-  while (i < lim && x1.mph[i] === x2.mph[i]) i++
-  x1.dstart = x2.dstart = i
-  const lim2 = lim - i
-  let j = 0
-  while (j < lim2 && x1.mph[x1.nrec - 1 - j] === x2.mph[x2.nrec - 1 - j]) j++
-  x1.dend = x1.nrec - j - 1
-  x2.dend = x2.nrec - j - 1
-}
-
-function cleanupRecords (counts, x1, x2) {
-  const off = x1.dstart
-  const len1 = x1.dend - off + 1
-  const len2 = x2.dend - off + 1
-  const one = (x, len, other) => {
-    const action = new Uint8Array(Math.max(len, 0))
-    let mlim = bogosqrt(x.nrec)
-    if (mlim > XDL_MAX_EQLIMIT) mlim = XDL_MAX_EQLIMIT
-    for (let i = 0; i < len; i++) {
-      const nm = counts[2 * x.mph[i + off] + other]
-      action[i] = nm === 0 ? DISCARD : nm < mlim ? KEEP : INVESTIGATE
-    }
-    x.ref = new Int32Array(Math.max(len, 0))
-    x.nreff = 0
-    for (let i = 0; i < len; i++) {
-      let a = action[i]
-      if (a === INVESTIGATE) a = cleanMmatch(action, i, len) ? DISCARD : KEEP
-      if (a === KEEP) x.ref[x.nreff++] = i + off
-      else x.changed[i + off + 1] = 1
-    }
-  }
-  one(x1, len1, 1)
-  one(x2, len2, 0)
-}
-
-function doDiff (x1, x2) {
-  const h1 = new Int32Array(x1.nreff); for (let i = 0; i < x1.nreff; i++) h1[i] = x1.mph[x1.ref[i]]
-  const h2 = new Int32Array(x2.nreff); for (let i = 0; i < x2.nreff; i++) h2[i] = x2.mph[x2.ref[i]]
-  const ndiags = x1.nreff + x2.nreff + 3
-  const kvd = new Float64Array(2 * ndiags + 2)
-  const F = x2.nreff + 1
-  const B = ndiags + x2.nreff + 1
-  let mxcost = bogosqrt(ndiags)
-  if (mxcost < XDL_MAX_COST_MIN) mxcost = XDL_MAX_COST_MIN
-  const snakeCnt = XDL_SNAKE_CNT; const heurMin = XDL_HEUR_MIN_COST
-  const spl = { i1: 0, i2: 0, minLo: 0, minHi: 0 }
-
-  function split (off1, lim1, off2, lim2, needMin) {
-    const dmin = off1 - lim2; const dmax = lim1 - off2
-    const fmid = off1 - off2; const bmid = lim1 - lim2
-    const odd = (fmid - bmid) & 1
-    let fmin = fmid; let fmax = fmid; let bmin = bmid; let bmax = bmid
-    let i1, i2, prev1, best, dd, v, k, d
-    kvd[F + fmid] = off1
-    kvd[B + bmid] = lim1
-    for (let ec = 1; ; ec++) {
-      let gotSnake = false
-      if (fmin > dmin) kvd[F + (--fmin) - 1] = -1; else ++fmin
-      if (fmax < dmax) kvd[F + (++fmax) + 1] = -1; else --fmax
-      for (d = fmax; d >= fmin; d -= 2) {
-        if (kvd[F + d - 1] >= kvd[F + d + 1]) i1 = kvd[F + d - 1] + 1
-        else i1 = kvd[F + d + 1]
-        prev1 = i1
-        i2 = i1 - d
-        while (i1 < lim1 && i2 < lim2 && h1[i1] === h2[i2]) { i1++; i2++ }
-        if (i1 - prev1 > snakeCnt) gotSnake = true
-        kvd[F + d] = i1
-        if (odd && bmin <= d && d <= bmax && kvd[B + d] <= i1) {
-          spl.i1 = i1; spl.i2 = i2; spl.minLo = spl.minHi = 1
-          return
-        }
-      }
-      if (bmin > dmin) kvd[B + (--bmin) - 1] = XDL_LINE_MAX; else ++bmin
-      if (bmax < dmax) kvd[B + (++bmax) + 1] = XDL_LINE_MAX; else --bmax
-      for (d = bmax; d >= bmin; d -= 2) {
-        if (kvd[B + d - 1] < kvd[B + d + 1]) i1 = kvd[B + d - 1]
-        else i1 = kvd[B + d + 1] - 1
-        prev1 = i1
-        i2 = i1 - d
-        while (i1 > off1 && i2 > off2 && h1[i1 - 1] === h2[i2 - 1]) { i1--; i2-- }
-        if (prev1 - i1 > snakeCnt) gotSnake = true
-        kvd[B + d] = i1
-        if (!odd && fmin <= d && d <= fmax && i1 <= kvd[F + d]) {
-          spl.i1 = i1; spl.i2 = i2; spl.minLo = spl.minHi = 1
-          return
-        }
-      }
-      if (needMin) continue
-      if (gotSnake && ec > heurMin) {
-        for (best = 0, d = fmax; d >= fmin; d -= 2) {
-          dd = d > fmid ? d - fmid : fmid - d
-          i1 = kvd[F + d]
-          i2 = i1 - d
-          v = (i1 - off1) + (i2 - off2) - dd
-          if (v > XDL_K_HEUR * ec && v > best && off1 + snakeCnt <= i1 && i1 < lim1 && off2 + snakeCnt <= i2 && i2 < lim2) {
-            for (k = 1; h1[i1 - k] === h2[i2 - k]; k++) {
-              if (k === snakeCnt) { best = v; spl.i1 = i1; spl.i2 = i2; break }
-            }
-          }
-        }
-        if (best > 0) { spl.minLo = 1; spl.minHi = 0; return }
-        for (best = 0, d = bmax; d >= bmin; d -= 2) {
-          dd = d > bmid ? d - bmid : bmid - d
-          i1 = kvd[B + d]
-          i2 = i1 - d
-          v = (lim1 - i1) + (lim2 - i2) - dd
-          if (v > XDL_K_HEUR * ec && v > best && off1 < i1 && i1 <= lim1 - snakeCnt && off2 < i2 && i2 <= lim2 - snakeCnt) {
-            for (k = 0; h1[i1 + k] === h2[i2 + k]; k++) {
-              if (k === snakeCnt - 1) { best = v; spl.i1 = i1; spl.i2 = i2; break }
-            }
-          }
-        }
-        if (best > 0) { spl.minLo = 0; spl.minHi = 1; return }
-      }
-      if (ec >= mxcost) {
-        let fbest = -1; let fbest1 = -1
-        for (d = fmax; d >= fmin; d -= 2) {
-          i1 = Math.min(kvd[F + d], lim1)
-          i2 = i1 - d
-          if (lim2 < i2) { i1 = lim2 + d; i2 = lim2 }
-          if (fbest < i1 + i2) { fbest = i1 + i2; fbest1 = i1 }
-        }
-        let bbest = XDL_LINE_MAX; let bbest1 = XDL_LINE_MAX
-        for (d = bmax; d >= bmin; d -= 2) {
-          i1 = Math.max(off1, kvd[B + d])
-          i2 = i1 - d
-          if (i2 < off2) { i1 = off2 + d; i2 = off2 }
-          if (i1 + i2 < bbest) { bbest = i1 + i2; bbest1 = i1 }
-        }
-        if ((lim1 + lim2) - bbest < fbest - (off1 + off2)) {
-          spl.i1 = fbest1; spl.i2 = fbest - fbest1; spl.minLo = 1; spl.minHi = 0
-        } else {
-          spl.i1 = bbest1; spl.i2 = bbest - bbest1; spl.minLo = 0; spl.minHi = 1
-        }
-        return
-      }
-    }
-  }
-
-  // xdl_recs_cmp, with its recursion on an explicit stack (depth can reach thousands).
-  const stack = [[0, x1.nreff, 0, x2.nreff, 0]]
-  while (stack.length) {
-    let [off1, lim1, off2, lim2, needMin] = stack.pop()
-    while (off1 < lim1 && off2 < lim2 && h1[off1] === h2[off2]) { off1++; off2++ }
-    while (off1 < lim1 && off2 < lim2 && h1[lim1 - 1] === h2[lim2 - 1]) { lim1--; lim2-- }
-    if (off1 === lim1) {
-      for (; off2 < lim2; off2++) x2.changed[x2.ref[off2] + 1] = 1
-    } else if (off2 === lim2) {
-      for (; off1 < lim1; off1++) x1.changed[x1.ref[off1] + 1] = 1
-    } else {
-      spl.i1 = spl.i2 = 0
-      split(off1, lim1, off2, lim2, needMin)
-      const { i1, i2, minLo, minHi } = spl
-      // Low half first, as the C recursion does (it only marks, so order matters not for the
-      // result, but keep it for fidelity).
-      stack.push([i1, lim1, i2, lim2, minHi])
-      stack.push([off1, i1, off2, i2, minLo])
-    }
-  }
-}
-
-// --- change compaction (xdl_change_compact) with the indent heuristic ---
-
-const MAX_INDENT = 200
-const MAX_BLANKS = 20
-const START_OF_FILE_PENALTY = 1
-const END_OF_FILE_PENALTY = 21
-const TOTAL_BLANK_WEIGHT = -30
-const POST_BLANK_WEIGHT = 6
-const RELATIVE_INDENT_PENALTY = -4
-const RELATIVE_INDENT_WITH_BLANK_PENALTY = 10
-const RELATIVE_OUTDENT_PENALTY = 24
-const RELATIVE_OUTDENT_WITH_BLANK_PENALTY = 17
-const RELATIVE_DEDENT_PENALTY = 23
-const RELATIVE_DEDENT_WITH_BLANK_PENALTY = 17
-const INDENT_WEIGHT = 60
-const INDENT_HEURISTIC_MAX_SLIDING = 100
-
-function getIndent (x, i) {
-  let ret = 0
-  const buf = x.buf
-  for (let p = x.r[2 * i], e = x.r[2 * i + 1]; p < e; p++) {
-    const c = buf[p]
-    // isspace: space, \t, \n, \v, \f, \r
-    if (!(c === 32 || (c >= 9 && c <= 13))) return ret
-    else if (c === 32) ret += 1
-    else if (c === 9) ret += 8 - ret % 8
-    if (ret >= MAX_INDENT) return MAX_INDENT
-  }
-  return -1
-}
-
-function measureSplit (x, split) {
-  const m = { eof: 0, indent: -1, preBlank: 0, preIndent: -1, postBlank: 0, postIndent: -1 }
-  if (split >= x.nrec) { m.eof = 1; m.indent = -1 } else m.indent = getIndent(x, split)
-  for (let i = split - 1; i >= 0; i--) {
-    m.preIndent = getIndent(x, i)
-    if (m.preIndent !== -1) break
-    m.preBlank += 1
-    if (m.preBlank === MAX_BLANKS) { m.preIndent = 0; break }
-  }
-  for (let i = split + 1; i < x.nrec; i++) {
-    m.postIndent = getIndent(x, i)
-    if (m.postIndent !== -1) break
-    m.postBlank += 1
-    if (m.postBlank === MAX_BLANKS) { m.postIndent = 0; break }
-  }
-  return m
-}
-
-function scoreAddSplit (m, s) {
-  if (m.preIndent === -1 && m.preBlank === 0) s.penalty += START_OF_FILE_PENALTY
-  if (m.eof) s.penalty += END_OF_FILE_PENALTY
-  const postBlank = m.indent === -1 ? 1 + m.postBlank : 0
-  const totalBlank = m.preBlank + postBlank
-  s.penalty += TOTAL_BLANK_WEIGHT * totalBlank
-  s.penalty += POST_BLANK_WEIGHT * postBlank
-  const indent = m.indent !== -1 ? m.indent : m.postIndent
-  const anyBlanks = totalBlank !== 0
-  s.effectiveIndent += indent
-  if (indent === -1 || m.preIndent === -1) {
-    // no adjustment
-  } else if (indent > m.preIndent) {
-    s.penalty += anyBlanks ? RELATIVE_INDENT_WITH_BLANK_PENALTY : RELATIVE_INDENT_PENALTY
-  } else if (indent === m.preIndent) {
-    // same level
-  } else if (m.postIndent !== -1 && m.postIndent > indent) {
-    s.penalty += anyBlanks ? RELATIVE_OUTDENT_WITH_BLANK_PENALTY : RELATIVE_OUTDENT_PENALTY
-  } else {
-    s.penalty += anyBlanks ? RELATIVE_DEDENT_WITH_BLANK_PENALTY : RELATIVE_DEDENT_PENALTY
-  }
-}
-
-function scoreCmp (s1, s2) {
-  const c = (s1.effectiveIndent > s2.effectiveIndent) - (s1.effectiveIndent < s2.effectiveIndent)
-  return INDENT_WEIGHT * c + (s1.penalty - s2.penalty)
-}
-
-// `changed` is offset by one: changed[i + 1] is record i; changed[0] and changed[nrec + 1] are 0.
-function changeCompact (x, xo) {
-  const ch = x.changed; const cho = xo.changed
-  const C = (i) => ch[i + 1]
-  const CO = (i) => cho[i + 1]
-  const g = { start: 0, end: 0 }; const go = { start: 0, end: 0 }
-  while (C(g.end)) g.end++
-  while (CO(go.end)) go.end++
-  const next = (xx, c, gg) => {
-    if (gg.end === xx.nrec) return -1
-    gg.start = gg.end + 1
-    for (gg.end = gg.start; c(gg.end); gg.end++);
-    return 0
-  }
-  const previous = (c, gg) => {
-    if (gg.start === 0) return -1
-    gg.end = gg.start - 1
-    for (gg.start = gg.end; c(gg.start - 1); gg.start--);
-    return 0
-  }
-  const slideDown = () => {
-    if (g.end < x.nrec && x.mph[g.start] === x.mph[g.end]) {
-      ch[g.start++ + 1] = 0
-      ch[g.end++ + 1] = 1
-      while (C(g.end)) g.end++
-      return 0
-    }
-    return -1
-  }
-  const slideUp = () => {
-    if (g.start > 0 && x.mph[g.start - 1] === x.mph[g.end - 1]) {
-      ch[--g.start + 1] = 1
-      ch[--g.end + 1] = 0
-      while (C(g.start - 1)) g.start--
-      return 0
-    }
-    return -1
-  }
-  const bug = (s) => { throw new Error('xdiff: ' + s) }
-  for (;;) {
-    if (g.end !== g.start) {
-      let groupsize, earliestEnd, endMatchingOther
-      do {
-        groupsize = g.end - g.start
-        endMatchingOther = -1
-        while (!slideUp()) if (previous(CO, go)) bug('group sync broken sliding up')
-        earliestEnd = g.end
-        if (go.end > go.start) endMatchingOther = g.end
-        for (;;) {
-          if (slideDown()) break
-          if (next(xo, CO, go)) bug('group sync broken sliding down')
-          if (go.end > go.start) endMatchingOther = g.end
-        }
-      } while (groupsize !== g.end - g.start)
-      if (g.end === earliestEnd) {
-        // no shifting possible
-      } else if (endMatchingOther !== -1) {
-        while (go.end === go.start) {
-          if (slideUp()) bug('match disappeared')
-          if (previous(CO, go)) bug('group sync broken sliding to match')
-        }
-      } else {
-        let shift = earliestEnd
-        let bestShift = -1; let bestScore = null
-        if (g.end - groupsize - 1 > shift) shift = g.end - groupsize - 1
-        if (g.end - INDENT_HEURISTIC_MAX_SLIDING > shift) shift = g.end - INDENT_HEURISTIC_MAX_SLIDING
-        for (; shift <= g.end; shift++) {
-          const score = { effectiveIndent: 0, penalty: 0 }
-          scoreAddSplit(measureSplit(x, shift), score)
-          scoreAddSplit(measureSplit(x, shift - groupsize), score)
-          if (bestShift === -1 || scoreCmp(score, bestScore) <= 0) { bestScore = score; bestShift = shift }
-        }
-        while (g.end > bestShift) {
-          if (slideUp()) bug('best shift unreached')
-          if (previous(CO, go)) bug('group sync broken sliding to blank line')
-        }
-      }
-    }
-    if (next(x, C, g)) break
-    if (next(xo, CO, go)) bug('group sync broken moving to next group')
-  }
-}
-
-/**
- * git's diff of two byte buffers: hunks [{ a: [start, len], b: [start, len] }] over their lines
- * (a final line without \n counts as different from the same line with one). `trimTail`
- * reproduces what git does for a zero-context diff (blame): drop the common tail in 1 KiB blocks.
- */
-export function xdiff (a, b, { trimTail = false } = {}) {
-  let sa = a.length; let sb = b.length
-  if (trimTail) { const t = commonTail(a, b); sa -= t; sb -= t }
-  const classes = new Map(); const counts = []
-  const x1 = prepare(a, sa, classes, counts, 0)
-  const x2 = prepare(b, sb, classes, counts, 1)
-  trimEnds(x1, x2)
-  cleanupRecords(counts, x1, x2)
-  doDiff(x1, x2)
-  changeCompact(x1, x2)
-  changeCompact(x2, x1)
-  // xdl_build_script, forwards.
-  const out = []
-  const c1 = x1.changed; const c2 = x2.changed
-  let i1 = 0; let i2 = 0
-  while (i1 < x1.nrec || i2 < x2.nrec) {
-    if (c1[i1 + 1] || c2[i2 + 1]) {
-      const s1 = i1; const s2 = i2
-      while (c1[i1 + 1]) i1++
-      while (c2[i2 + 1]) i2++
-      out.push({ a: [s1, i1 - s1], b: [s2, i2 - s2] })
-    } else { i1++; i2++ }
-  }
-  return out
-}

package/src/ui/branches.js

@@ -1,111 +0,0 @@
-// The branch menu in the session's top bar: which branch each folder, AI
-// session and worktree is on, and how each stands against its upstream. Read
-// only: nobody switches branches from here (a folder's branch is its own, and
-// its AIs work on it). Commits pushed or merged elsewhere come in by
-// themselves; "Bring in now" asks this folder to look at once.
-import { esc, ago, I } from './common.js'
-
-/** One line on how a branch stands against its upstream ('' without one). */
-export function upstreamText (u) {
-  if (!u || !u.name) return ''
-  const n = (k, w) => `${k} ${w}${k === 1 ? '' : 's'}`
-  // A failed fetch: what git last knew is stale, so never "up to date".
-  if (u.fetchOk === false) return `can't fetch ${u.name}: ${u.fetchError || 'git fetch failed'}`
-  const by = u.mergedBy ? `; being merged by ${u.clashMine ? 'your AI' : u.mergedBy}` : ''
-  if (u.diverged) return `diverged from ${u.name}: ${n(u.ahead, 'commit')} here, ${n(u.behind, 'commit')} there${by}`
-  const clash = Array.isArray(u.conflicts) ? u.conflicts.length : u.conflicts
-  if (clash) return `${n(u.behind, 'commit')} behind ${u.name}; ${n(clash, 'file')} clash with the session's work${by}`
-  if (u.waiting) return `${n(u.behind, 'commit')} behind ${u.name}; waiting: ${u.waiting}`
-  if (u.behind) return `${n(u.behind, 'commit')} behind ${u.name}`
-  if (u.ahead) return `${n(u.ahead, 'commit')} ahead of ${u.name}`
-  return `up to date with ${u.name}`
-}
-
-/**
- * What the relay does for a branch no folder is online on: "brought in by the relay 5m ago (3
- * commits)", a clash it handed out, why it can't, and when it last looked; '' when it hasn't.
- */
-export function relayText (r, now = Date.now()) {
-  if (!r || !(r.checkedAt || (r.brought && r.brought.at))) return ''
-  const n = (k, w) => `${k} ${w}${k === 1 ? '' : 's'}`
-  const when = (ts) => { const a = ago(ts, now); return a === 'now' ? 'just now' : /^\d+[mh]$/.test(a) ? `${a} ago` : `on ${a}` }
-  const bits = []
-  if (r.brought && r.brought.at) bits.push(`brought in by the relay ${when(r.brought.at)} (${n(r.brought.count, 'commit')})`)
-  if (r.clashTask) bits.push(`a clash with ${r.upstream || 'upstream'} is with an agent`)
-  if (r.problem) bits.push(r.problem)
-  if (r.checkedAt) bits.push(`relay checked ${when(r.checkedAt)}`)
-  return bits.join(' · ')
-}
-
-/** The agent whose own branch `name` is (quilt/<agent>/<topic>), or ''; never a protected branch's live branch or another session's. */
-export function agentOfBranch (name) {
-  const m = /^quilt\/([^/]+)\/./.exec(String(name || ''))
-  return m && m[1] !== 'live' && !m[1].startsWith('session-') ? m[1] : ''
-}
-
-/** Where a branch stands with GitHub, in a few words for the menu ('' when it doesn't sync). */
-export function syncShort (r) {
-  const s = r && r.sync
-  if (!s) return ''
-  if (s.state === 'synced') return 'committed'
-  if (s.state === 'github-pending') return 'uncommitted changes'
-  if (s.state === 'conflict-held') return 'merge held'
-  if (s.state === 'pr-pending') return 'commits go through a pull request'
-  if (s.state === 'offline') return 'GitHub unreachable'
-  return s.why || 'not syncing'
-}
-
-/** Whether the label should draw the eye: this folder is behind and Quilt can't bring it in by itself. */
-export function needsHand (u) {
-  return !!(u && (u.diverged || u.fetchOk === false || (Array.isArray(u.conflicts) ? u.conflicts.length : u.conflicts)))
-}
-
-/** The menu's markup. `git`: this folder's (status.git); `branches`: status.branches; `me`: our name; `fold`: lists folded behind one line. */
-export function branchMenuHtml ({ git, branches = [], me = '', syncing = false, fold = false, now = Date.now() }) {
-  const u = git && git.upstream
-  // Folded (the git panel): the branch in one line, its upstream beside it (in full on hover), and a small Check.
-  const compact = fold && git ? `<div class="br-here br-compact">
-      <div class="br-line">${I.branch}<b class="br-name">${esc(git.key)}</b>${u ? `<span class="br-sub${needsHand(u) ? ' warn' : ''}" title="${esc(upstreamText(u))}">${esc(upstreamText(u))}</span>` : ''}${u ? `<button type="button" class="btn sm ghost br-sync" data-branch-sync ${syncing ? 'disabled' : ''} title="Look for new commits on ${esc(u.name || 'the upstream')}">${I.refresh}<span>${syncing ? 'Checking' : 'Check'}</span></button>` : ''}</div>
-      ${u && Array.isArray(u.conflicts) && u.conflicts.length ? `<ul class="br-clash">${u.conflicts.slice(0, 6).map((c) => `<li><code>${esc(c.path)}</code> ${esc(c.why)}</li>`).join('')}</ul><div class="br-hint">Ask your AI to pull and resolve these: Quilt brings nothing in until they're settled.</div>` : ''}
-      ${u && u.diverged ? '<div class="br-hint">Quilt never merges git history: ask your AI to pull or rebase, and the session takes in the result.</div>' : ''}
-    </div>` : ''
-  const here = compact || (git ? `<div class="br-here">
-      <div class="br-title">This folder is on <b>${esc(git.key)}</b></div>
-      ${u ? `<div class="br-sub${needsHand(u) ? ' warn' : ''}">${esc(upstreamText(u))}</div>` : '<div class="br-sub">No upstream: nothing to bring in.</div>'}
-      ${u && Array.isArray(u.conflicts) && u.conflicts.length ? `<ul class="br-clash">${u.conflicts.slice(0, 6).map((c) => `<li><code>${esc(c.path)}</code> ${esc(c.why)}</li>`).join('')}</ul><div class="br-hint">Ask your AI to pull and resolve these: Quilt brings nothing in until they're settled.</div>` : ''}
-      ${u && u.diverged ? '<div class="br-hint">Quilt never merges git history: ask your AI to pull or rebase, and the session takes in the result.</div>' : ''}
-      ${u && u.brought && u.brought.at && !needsHand(u) ? `<div class="br-sub">Brought in ${u.brought.count ? `${u.brought.count} commit${u.brought.count === 1 ? '' : 's'}` : 'commits'} ${esc(ago(u.brought.at, now))} by itself</div>` : ''}
-      ${u ? `<button type="button" class="btn sm ghost br-sync" data-branch-sync ${syncing ? 'disabled' : ''}>${syncing ? 'Looking…' : needsHand(u) ? 'Check again' : 'Check for new commits'}</button>` : ''}
-    </div>` : '')
-  // Agents' own branches (plan §2: people see them live) after everyone else's, each with its pull request and where it stands.
-  const order = [...branches].sort((a, b) => (agentOfBranch(a.name) ? 1 : 0) - (agentOfBranch(b.name) ? 1 : 0))
-  const row = (b) => {
-    const who = [
-      ...b.folders.map((f) => `<span class="br-who${needsHand(f.upstream) ? ' warn' : ''}" title="${esc(`${f.name === me ? 'Your folder' : `${f.name}'s folder`}${f.upstream ? `: ${upstreamText(f.upstream)}` : ''}`)}">${esc(f.name === me ? 'you' : f.name)}</span>`),
-      ...b.ais.map((n) => `<span class="br-who ai" title="AI session">${esc(n)}</span>`),
-      ...b.worktrees.map((w) => `<span class="br-who wt" title="${esc(`Worktree ${w}`)}">${w === b.name ? 'worktree' : `worktree ${esc(w)}`}</span>`)
-    ].join('')
-    const status = upstreamText(b.upstream)
-    const relay = relayText(b.relay, now)
-    const last = b.last && b.last.ts ? `${esc(b.last.author || 'someone')} · ${esc(ago(b.last.ts, now))}` : ''
-    const tags = [b.default ? '<span class="br-tag">default</span>' : '', b.session ? '<span class="br-tag">in the session</span>' : '', b.full ? '<span class="br-tag warn" title="full: new changes aren\'t saved">full</span>' : ''].filter(Boolean).join('')
-    const agent = agentOfBranch(b.name)
-    const pr = b.relay && b.relay.pr && b.relay.pr.number ? b.relay.pr : null
-    const live = syncShort(b.relay)
-    // The agent as people know it: whoever on the branch has the name its slug was made from.
-    const flat = (n) => String(n || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '')
-    const known = agent ? [...(b.hosted || []), ...(b.folders || []).map((f) => f.name), ...(b.ais || [])].find((n) => flat(n) === agent) : ''
-    const agentLine = agent ? [`<span>${esc(known || agent)}'s branch</span>`, live && `<span>${esc(live)}</span>`, pr && (pr.url ? `<a href="${esc(pr.url)}" target="_blank" rel="noreferrer">pull request #${pr.number}</a>` : `<span>pull request #${pr.number}</span>`)].filter(Boolean).join(' · ') : ''
-    return `<li class="br-row${git && b.name === git.key ? ' on' : ''}${agent ? ' agent' : ''}">
-        <div class="br-line"><span class="br-name" title="${esc(b.name)}">${esc(b.name)}</span>${tags}${who ? `<span class="br-people">${who}</span>` : ''}</div>
-        ${agentLine ? `<div class="br-meta br-agent">${agentLine}</div>` : ''}
-        ${status || last ? `<div class="br-meta">${[status && `<span class="${needsHand(b.upstream) ? 'warn' : ''}">${esc(status)}</span>`, last && `<span title="${esc(b.last.subject || '')}">last commit ${last}</span>`].filter(Boolean).join(' · ')}</div>` : ''}
-        ${relay ? `<div class="br-meta br-relay${b.relay.problem ? ' warn' : ''}">${esc(relay)}</div>` : ''}
-      </li>`
-  }
-  const people = order.filter((b) => !agentOfBranch(b.name)).map(row).join('')
-  const agents = order.filter((b) => agentOfBranch(b.name)).map(row).join('')
-  const lists = `${people ? `<div class="br-head">Branches</div><ul class="br-list">${people}</ul>` : ''}${agents ? `<div class="br-head">Agents' branches</div><ul class="br-list">${agents}</ul>` : ''}`
-  // `fold`: the lists behind one line (the git panel, where the changes come after them).
-  return fold && lists ? `${here}<details class="br-all"><summary>Every branch <span class="br-n">${branches.length}</span></summary>${lists}</details>` : `${here}${lists}`
-}