heyquilt 0.3.119 → 0.3.120

package/src/quilts/export-git.js

@@ -9,7 +9,7 @@ import { spawn, execFileSync } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
 
-const MODES = { file: '100644', exec: '100755', symlink: '120000' }
+const MODES = { file: '100644', exec: '100755', symlink: '120000', gitlink: '160000' }
 const GIT_ENV = { ...process.env, GIT_NO_REPLACE_OBJECTS: '1', GIT_CONFIG_NOSYSTEM: '1' }
 
 const git = (dir, args) => execFileSync('git', ['-C', dir, ...args], { env: GIT_ENV, maxBuffer: 256 * 1024 * 1024 }).toString().trim()
@@ -90,6 +90,9 @@ export async function exportGit (client, { q, dir, line = 'main', branch, page =
     let mark = 0
     const blobMark = new Map()
     for (const [id, bytes] of blobs) {
+      // A gitlink's content is the submodule commit it pins; git writes no blob for it.
+      if (r.patches.some((p) => p.changes.some((c) => c.blob === id && c.mode === 'gitlink'))) blobMark.set(id, bytes.toString('utf8').trim())
+      if (blobMark.has(id)) continue
       blobMark.set(id, ++mark)
       await send(`blob\nmark :${mark}\ndata ${bytes.length}\n`); await send(bytes); await send('\n')
     }
@@ -104,6 +107,7 @@ export async function exportGit (client, { q, dir, line = 'main', branch, page =
       first = false
       for (const c of p.changes) {
         if (c.op === 'delete') s += `D ${fiPath(c.path)}\n`
+        else if (c.mode === 'gitlink') s += `M 160000 ${blobMark.get(c.blob)} ${fiPath(c.path)}\n`
         else s += `M ${MODES[c.mode || 'file'] || MODES.file} :${blobMark.get(c.blob)} ${fiPath(c.path)}\n`
       }
       await send(s + '\n')

package/src/quilts/fastmerge.js

@@ -1,10 +1,10 @@
-// A fast front for src/merge3.js's mergeSmart (whose node-diff3 LCS is quadratic: seconds on a
+// A fast front for merge-smart.js's mergeSmart (whose node-diff3 LCS is quadratic: seconds on a
 // 7,000-line file). A clean line merge comes from the Myers hunks in textdiff.js (`nway`, the
 // same N-way merge the conflict format uses); only a clash goes to mergeSmart's ladder, and then
 // with the lines all three versions share at the start and end cut off, so it reads only the
 // region that differs. Same answer, same `how`, as mergeSmart for a clean merge; a clash is
 // mergeSmart's own answer on the middle, put back between the shared lines.
-import { mergeSmart } from '../merge3.js'
+import { mergeSmart } from './merge-smart.js'
 import { nway } from './conflict-format.js'
 
 export function fastMerge (base, ours, theirs) {

package/src/quilts/hash.js

@@ -17,7 +17,7 @@ export const KINDS = ['commit', 'blob', 'tree', 'chunk', 'pack', 'term', 'manife
 
 /** The id of `bytes` as an object of `kind`: BLAKE3 derive-key mode, 32 bytes, as hex. */
 // Not object kinds: keys made with their own contexts so they can never equal an object id.
-const KEY_KINDS = ['idempotency']
+const KEY_KINDS = ['idempotency', 'resolution']
 
 /** A key (not an object id) in its own context, e.g. 'idempotency' → "quilt idempotency v1". */
 export function keyOf (kind, bytes) {

package/src/quilts/history.js

@@ -0,0 +1,266 @@
+// History tools (plans/quilt-source-control/08 and 12): log --follow (a file's history through its
+// renames), log -S (commits that changed how often a text appears), describe (the nearest tag),
+// merge-base (where two revisions last shared history), grep (lines at a revision) and bisect (the
+// server narrows good..bad; whoever runs the check, the seam CLI or an agent, marks each step).
+import { cleanPath, cleanPrefix, under } from './records.js'
+import { isText, lineStat } from './textdiff.js'
+import { QuiltError } from './service.js'
+
+const MAX_WALK = 100000
+const MAX_GREP_BYTES = 64 * 1024 * 1024
+const MAX_GREP_FILE = 2 * 1024 * 1024
+const MAX_SEARCH_QUILTS = 100
+
+/** A grep pattern as a RegExp, refusing the shapes that can backtrack for ever on one line. */
+export function grepPattern (pattern, { fixed = false, ignoreCase = false } = {}) {
+  const p = String(pattern ?? '')
+  if (!p) throw new QuiltError(400, 'bad_request', 'give a pattern')
+  if (p.length > 500) throw new QuiltError(400, 'bad_request', 'a pattern is up to 500 characters')
+  const src = fixed ? p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') : p
+  if (!fixed && (/\((?:[^()\\]|\\.)*[+*}](?:[^()\\]|\\.)*\)\s*[+*{]/.test(p) || /\\[1-9]/.test(p))) {
+    throw new QuiltError(400, 'bad_request', `the pattern ${p} could run for ever (a repeated group that repeats, or a back-reference): simplify it, or pass fixed for plain text`)
+  }
+  try { return new RegExp(src, ignoreCase ? 'i' : '') } catch (err) { throw new QuiltError(400, 'bad_request', `bad pattern: ${err.message}`) }
+}
+
+const count = (text, needle) => { let n = 0; let i = 0; while ((i = text.indexOf(needle, i)) >= 0) { n++; i += needle.length } return n }
+
+export function historyOps (svc, { mergeBase: commonBase }) {
+  const { quiltFor, resolve, rootAt, getCommit, snapshot, reader, readBlob, commitView, store } = svc.internals
+  const baseLog = svc.log
+
+  async function entryAt (q, commitId, p) {
+    if (!commitId) return null
+    return reader(q).lookup(await snapshot(q, commitId), p)
+  }
+
+  async function textOf (q, e, cache) {
+    if (!e || !e.blob) return null
+    if (cache.has(e.blob)) return cache.get(e.blob)
+    const b = await readBlob(q, e.blob)
+    const t = isText(b) ? b.toString('utf8') : null
+    cache.set(e.blob, t)
+    return t
+  }
+
+  /** The path `p` had before commit `c` added it: copy_from, a deleted file with the same content, or the most alike deleted text file. */
+  async function renamedFrom (q, c, ch, texts) {
+    if (ch.copy_from?.path) return ch.copy_from.path
+    const parent = c.parents[0] || null
+    if (!parent || await entryAt(q, parent, ch.path)) return null
+    const gone = c.changes.filter((x) => x.op === 'delete')
+    if (!gone.length) return null
+    const before = await Promise.all(gone.map((x) => entryAt(q, parent, x.path)))
+    const same = gone.find((x, i) => before[i]?.blob === ch.blob)
+    if (same) return same.path
+    const now = await textOf(q, { blob: ch.blob }, texts)
+    if (now == null) return null
+    let best = null; let score = 0.5
+    for (let i = 0; i < gone.length; i++) {
+      const was = await textOf(q, before[i], texts)
+      if (was == null) continue
+      const st = lineStat(was, now)
+      const total = Math.max(was.split('\n').length, now.split('\n').length, 1)
+      const kept = 1 - Math.max(st.add, st.del) / total
+      if (kept >= score) { best = gone[i].path; score = kept }
+    }
+    return best
+  }
+
+  /** Whether commit `c` changed how many times `needle` appears in the changed files (a rename keeps the count). */
+  async function changesCount (q, c, needle, prefixes, texts) {
+    const parent = c.parents[0] || null
+    let before = 0; let after = 0
+    for (const ch of c.changes) {
+      if (prefixes.length && !prefixes.some((p) => under(ch.path, p))) continue
+      const was = await textOf(q, await entryAt(q, parent, ch.path), texts)
+      const now = ch.op === 'put' ? await textOf(q, { blob: ch.blob }, texts) : null
+      if (was) before += count(was, needle)
+      if (now) after += count(now, needle)
+    }
+    return before !== after
+  }
+
+  /**
+   * GET /log with follow (one file, through its renames) or search (-S): a walk over first parents.
+   * Without either, the indexed log (service.js).
+   */
+  async function log (me, ref, opts = {}) {
+    const { rev = 'main', paths = [], limit = 20, follow = false, search } = opts
+    if (!follow && !search) return baseLog(me, ref, opts)
+    const q = await quiltFor(me, ref)
+    if (follow && (paths || []).length !== 1) throw new QuiltError(400, 'bad_request', 'log --follow takes one file')
+    if (search != null && (!String(search).length || String(search).length > 500)) throw new QuiltError(400, 'bad_request', 'log -S takes a text of 1 to 500 characters')
+    let range = String(rev || 'main')
+    let stop = null
+    if (range.includes('..')) {
+      const [a, b] = range.split('..')
+      stop = a ? await resolve(q.id, a) : null
+      range = b || 'main'
+    }
+    let id = await resolve(q.id, range)
+    let cur = follow ? cleanPath(paths[0]) : null
+    const prefixes = follow ? [] : (paths || []).map(cleanPrefix)
+    const max = Math.min(Number(limit) || 20, 1000)
+    const texts = new Map()
+    const out = []
+    let walked = 0
+    while (id && id !== stop && out.length < max && walked++ < MAX_WALK) {
+      const c = await getCommit(q.id, id)
+      if (follow) {
+        const ch = c.changes.find((x) => x.path === cur)
+        if (ch && (search == null || await changesCount(q.id, c, String(search), [cur], texts))) out.push({ ...commitView(c, { changes: false }), path: cur })
+        if (ch && ch.op === 'put') { const from = await renamedFrom(q.id, c, ch, texts); if (from) cur = from }
+      } else {
+        const touched = !prefixes.length || c.changes.some((x) => prefixes.some((p) => under(x.path, p)))
+        if (touched && await changesCount(q.id, c, String(search), prefixes, texts)) out.push(commitView(c, { changes: false }))
+      }
+      id = c.parents[0] || null
+    }
+    return { commits: out, more: !!id && id !== stop && out.length >= max, ...(follow ? { follow: cleanPath(paths[0]) } : {}) }
+  }
+
+  /** Every ancestor of `id` (all parents) with its distance, nearest first, up to MAX_WALK. */
+  async function ancestors (q, id, { until } = {}) {
+    const seen = new Map()
+    if (!id) return seen
+    let frontier = [id]
+    seen.set(id, 0)
+    for (let d = 1; frontier.length && seen.size < MAX_WALK; d++) {
+      const next = []
+      for (const x of frontier) {
+        if (until && until(x)) continue
+        for (const p of (await getCommit(q, x)).parents) if (!seen.has(p)) { seen.set(p, d); next.push(p) }
+      }
+      frontier = next
+    }
+    return seen
+  }
+
+  async function patchOf (q, id) { return id ? ((await store.getCommit(q, id))?.patch || null) : null }
+
+  /** GET /describe?rev=: the nearest tag behind a revision, as <tag>-<commits past it>-<commit>. */
+  async function describe (me, ref, rev = 'main') {
+    const q = await quiltFor(me, ref)
+    const id = await resolve(q.id, rev || 'main')
+    if (!id) throw new QuiltError(404, 'not_found', `${rev || 'main'} has no commits yet`)
+    const byCommit = new Map()
+    for (const t of await store.tags(q.id)) {
+      const had = byCommit.get(t.commit)
+      if (!had || (t.seq || 0) > (had.seq || 0)) byCommit.set(t.commit, t)
+    }
+    const short = id.slice(0, 12)
+    let hit = null
+    if (byCommit.size) {
+      const dist = await ancestors(q.id, id, { until: (x) => byCommit.has(x) })
+      for (const [cid, d] of dist) if (byCommit.has(cid) && (!hit || d < hit.d)) hit = { d, tag: byCommit.get(cid).name }
+    }
+    if (!hit) return { commit: id, short, tag: null, distance: null, describe: short }
+    return { commit: id, short, tag: hit.tag, distance: hit.d, describe: hit.d ? `${hit.tag}-${hit.d}-${short}` : hit.tag }
+  }
+
+  /** GET /merge-base?a=&b=: where two revisions last shared history (null if never). */
+  async function mergeBaseOf (me, ref, a, b) {
+    const q = await quiltFor(me, ref)
+    if (!a || !b) throw new QuiltError(400, 'bad_request', 'merge-base takes two revisions (a and b)')
+    const { base } = await commonBase(q.id, await resolve(q.id, a), await resolve(q.id, b))
+    return { commit: base, short: base ? base.slice(0, 12) : null, patch: await patchOf(q.id, base) }
+  }
+
+  /** GET /grep: the lines matching a pattern in the files at a revision (sq:<id>:live too). */
+  async function grep (me, ref, { pattern, rev = 'main', paths = [], ignore_case: ignoreCase = false, fixed = false, limit = 200 } = {}) {
+    const q = await quiltFor(me, ref)
+    const re = grepPattern(pattern, { fixed, ignoreCase })
+    const { id, root } = await rootAt(q.id, rev || 'main')
+    const prefixes = (paths && paths.length ? paths : ['']).map(cleanPrefix)
+    const max = Math.min(Math.max(Number(limit) || 200, 1), 2000)
+    const matches = []
+    const files = []
+    let bytes = 0; let more = false; let skipped = 0
+    for (const e of await reader(q.id).list(root, prefixes)) {
+      if (!e.blob || e.mode === 'gitlink' || e.mode === 'symlink') continue
+      if ((e.size || 0) > MAX_GREP_FILE || bytes + (e.size || 0) > MAX_GREP_BYTES) { skipped++; continue }
+      const buf = await readBlob(q.id, e.blob)
+      bytes += buf.length
+      if (!isText(buf)) continue
+      const lines = buf.toString('utf8').split('\n')
+      let hit = false
+      for (let i = 0; i < lines.length; i++) {
+        const text = lines[i].length > 4000 ? lines[i].slice(0, 4000) : lines[i]
+        if (!re.test(text)) continue
+        if (matches.length >= max) { more = true; break }
+        hit = true
+        matches.push({ path: e.path, line: i + 1, text: text.replace(/\r$/, '') })
+      }
+      if (hit) files.push(e.path)
+      if (more) break
+    }
+    return { commit: id, matches, files, more, ...(skipped ? { skipped } : {}) }
+  }
+
+  /**
+   * GET /v1/search: grep across every quilt the caller can read (or the ones named), at one
+   * revision (main by default). A quilt without that revision is skipped; limit counts all matches.
+   */
+  async function search (me, { pattern, rev = 'main', quilts = [], paths = [], ignore_case: ignoreCase = false, fixed = false, limit = 200 } = {}) {
+    grepPattern(pattern, { fixed, ignoreCase })
+    const max = Math.min(Math.max(Number(limit) || 200, 1), 2000)
+    const named = (quilts || []).filter(Boolean)
+    const targets = named.length ? await Promise.all(named.map((ref) => quiltFor(me, ref))) : await store.quiltsFor(me.member_id)
+    if (targets.length > MAX_SEARCH_QUILTS) throw new QuiltError(400, 'bad_request', `search reads at most ${MAX_SEARCH_QUILTS} quilts at once: name some with quilts`)
+    const matches = []; const files = []; const searched = []
+    let more = false; let skipped = 0
+    for (const q of targets) {
+      if (matches.length >= max) { more = true; break }
+      let r
+      try { r = await grep(me, q.slug, { pattern, rev, paths, ignore_case: ignoreCase, fixed, limit: max - matches.length }) } catch (e) {
+        if (e instanceof QuiltError && e.status === 404) continue
+        throw e
+      }
+      searched.push(q.slug)
+      for (const m of r.matches) matches.push({ quilt: q.slug, ...m })
+      for (const f of r.files) files.push(`${q.slug}:${f}`)
+      skipped += r.skipped || 0
+      if (r.more) { more = true; break }
+    }
+    return { rev: rev || 'main', searched, matches, files, more, ...(skipped ? { skipped } : {}) }
+  }
+
+  /**
+   * POST /bisect { bad, good, marks }: the first-parent commits after good up to bad, narrowed by
+   * marks ({ <commit>: good | bad | skip }). Answers the next commit to test, or the first bad one.
+   */
+  async function bisect (me, ref, { bad = 'main', good, marks = {} } = {}) {
+    const q = await quiltFor(me, ref)
+    if (!good) throw new QuiltError(400, 'bad_request', 'bisect needs a good revision (one without the problem)')
+    const [b, g] = [await resolve(q.id, bad), await resolve(q.id, good)]
+    if (!b || !g) throw new QuiltError(404, 'not_found', 'bisect needs two revisions with commits')
+    const behindGood = await ancestors(q.id, g)
+    const list = []
+    let id = b
+    while (id && !behindGood.has(id) && list.length < MAX_WALK) { list.push(id); id = (await getCommit(q.id, id)).parents[0] || null }
+    if (!id || !list.length) throw new QuiltError(400, 'bad_request', `${good} is not an ancestor of ${bad}: give a good revision older than the bad one`)
+    list.reverse() // oldest first; the last is bad
+    const mark = new Map()
+    for (const [k, v] of Object.entries(marks || {})) {
+      if (!['good', 'bad', 'skip'].includes(v)) throw new QuiltError(400, 'bad_request', `a mark is good, bad or skip, not ${v}`)
+      const full = list.find((x) => x.startsWith(String(k).replace(/^c:/, '')))
+      if (full) mark.set(full, v)
+    }
+    let hi = list.length - 1
+    for (let i = 0; i < list.length; i++) if (mark.get(list[i]) === 'bad') { hi = i; break }
+    let lo = -1
+    for (let i = hi - 1; i >= 0; i--) if (mark.get(list[i]) === 'good') { lo = i; break }
+    const left = []
+    for (let i = lo + 1; i < hi; i++) if (mark.get(list[i]) !== 'skip') left.push(i)
+    const view = async (cid) => commitView(await getCommit(q.id, cid), { changes: false })
+    if (!left.length) {
+      const skipped = list.slice(lo + 1, hi)
+      return { done: true, first_bad: await view(list[hi]), ...(skipped.length ? { maybe: await Promise.all(skipped.map(view)) } : {}), tested: mark.size }
+    }
+    const next = left[Math.floor((left.length - 1) / 2)]
+    return { done: false, next: await view(list[next]), remaining: left.length, steps: Math.ceil(Math.log2(left.length + 1)) }
+  }
+
+  return { log, describe, mergeBaseOf, grep, search, bisect }
+}

package/src/quilts/import-git.js

@@ -1,14 +1,16 @@
 // The local driver of a git import (plans/quilt-source-control/14): walks a repository on this
 // machine with `git cat-file --batch`, hashes blobs with BLAKE3, uploads the missing ones in
 // packs with the commit records, and sends the commits in order. Every commit on HEAD's
-// first-parent chain becomes a patch on main with a square of its own; a merge commit's side
-// commits become the commits of the merge's square (14, "Which square owns each commit").
+// first-parent chain becomes a patch on main with a square of its own, and every other branch's
+// on a line of its name; a merge commit's side commits become the commits of the merge's square
+// (14, "Which square owns each commit"). Tags come too, submodules stay gitlink entries, LFS
+// pointer files stay the pointer files they are, and a second import adds only new commits.
 import { spawn, execFileSync } from 'node:child_process'
 import { cleanCommit, commitId, commitBytes, blobId } from './records.js'
 import { uuidv7 } from './ids.js'
 
 const GIT_ENV = { ...process.env, GIT_NO_REPLACE_OBJECTS: '1' }
-const MODES = { 100644: 'file', 100755: 'exec', 120000: 'symlink', 100664: 'file' }
+const MODES = { 100644: 'file', 100755: 'exec', 120000: 'symlink', 100664: 'file', 160000: 'gitlink' }
 
 /** A long-lived `git cat-file --batch`: get(sha) → { type, bytes }. */
 function catFile (repo) {
@@ -78,56 +80,106 @@ const agentEmail = /@agents\.noreply\.heyquilt\.com$/i
 const member = (who) => ({ member_id: `stub:${String(who.email || who.name).toLowerCase()}`, kind: agentEmail.test(who.email || '') ? 'agent' : 'person', name: who.name || who.email })
 
 /**
- * Imports the history of HEAD in `repo` into a new quilt `slug`. Returns { quilt, slug,
- * commits, patches, report, validated? }.
+ * The branches to import: [{ name, sha }], HEAD's branch first as main. Local branches, then
+ * remote-tracking ones (origin/dev → dev) no local branch has, so a fresh clone brings them all.
  */
-export async function importGit (client, { repo, slug, batch = 100, log = () => {}, validate = false, limit = 0 }) {
+function branches (repo, head) {
+  let current = null
+  try { current = git(repo, ['symbolic-ref', '-q', '--short', 'HEAD']).toString().trim() || null } catch {}
+  const out = [{ name: 'main', sha: head, git: current || 'HEAD' }]
+  const seen = new Set([current, 'HEAD'])
+  const rows = git(repo, ['for-each-ref', '--format=%(refname)%00%(objectname)%00%(objecttype)', 'refs/heads', 'refs/remotes']).toString().split('\n').filter(Boolean).map((l) => l.split('\0'))
+  for (const local of [true, false]) {
+    for (const [ref, sha, type] of rows) {
+      if (type !== 'commit' || ref.startsWith('refs/heads/') !== local) continue
+      const name = local ? ref.slice(11) : ref.split('/').slice(3).join('/')
+      if (!name || name === 'HEAD' || seen.has(name)) continue
+      seen.add(name)
+      out.push({ name, sha, git: local ? name : ref.slice(13) })
+    }
+  }
+  return out
+}
+
+/** Every tag: [{ name, sha }] with sha the commit it names (an annotated tag peeled). */
+function gitTags (repo) {
+  return git(repo, ['for-each-ref', '--format=%(refname:strip=2)%00%(objectname)%00%(*objectname)%00%(objecttype)%00%(*objecttype)', 'refs/tags']).toString().split('\n').filter(Boolean).map((l) => {
+    const [name, sha, peeled, type, ptype] = l.split('\0')
+    return { name, sha: peeled || sha, type: ptype || type }
+  })
+}
+
+/**
+ * Imports a git repository into the quilt `slug`: HEAD's branch as main, every other branch as a
+ * line of its own name, and every tag. Into a new quilt, or again into a quilt an import made,
+ * where only the commits it does not have yet are added. Returns { quilt, slug, commits,
+ * patches, lines, tags, report, validated? }.
+ */
+export async function importGit (client, { repo, slug, batch = 100, log = () => {}, validate = false, limit = 0, onlyHead = false, fresh = false }) {
   const head = git(repo, ['rev-parse', 'HEAD']).toString().trim()
-  const all = git(repo, ['rev-list', head]).toString().split('\n').filter(Boolean)
+  const refs = onlyHead ? [{ name: 'main', sha: head, git: 'HEAD' }] : branches(repo, head)
+  const all = git(repo, ['rev-list', ...new Set(refs.map((r) => r.sha))]).toString().split('\n').filter(Boolean)
   const cat = catFile(repo)
   const report = []
   try {
     // Parents and fields of every commit, read once.
     const info = new Map()
     for (const sha of all) info.set(sha, parseCommit((await cat.get(sha)).bytes))
-    // HEAD's first-parent chain, root first.
-    const chain = []
-    for (let s = head; s; s = info.get(s).parents[0]) chain.push(s)
-    chain.reverse()
-    if (limit) chain.length = Math.min(chain.length, limit)
-
-    const quilt = await client.createQuilt({ slug, name: slug, import: true })
-    log(`Importing ${chain.length} patches (${all.length} commits in all) into ${quilt.slug}…`)
+
+    // A quilt an import made takes the new commits; otherwise a new quilt.
+    let quilt = null
+    try { quilt = await client.quilt(slug) } catch (err) { if (err.status !== 404) throw err }
+    if (quilt && fresh) throw new Error(`there is already a quilt ${slug}`)
+    const again = !!quilt
+    if (!quilt) quilt = await client.createQuilt({ slug, name: slug, import: true })
     const ids = new Map() // git sha → quilt commit id
+    if (again) {
+      for (let i = 0; i < all.length; i += 5000) {
+        const { known } = await client.importKnown(quilt.id, all.slice(i, i + 5000))
+        for (const [sha, id] of Object.entries(known)) ids.set(sha, id)
+      }
+    }
+    const lineTips = new Map((again ? await client.lines(quilt.id) : [{ name: 'main', tip: null }]).map((l) => [l.name, l.tip]))
+    log(again ? `Adding to ${quilt.slug}: ${all.length - ids.size} new commits of ${all.length}…` : `Importing ${all.length} commits on ${refs.length} branches into ${quilt.slug}…`)
+
     const blobs = new Map() // git blob sha → { id, size }
-    const assigned = new Set()
+    const assigned = new Set(ids.keys())
     const items = []
+    const newLines = []
+    const written = [] // the git shas of the patches this import writes
     let pending = []
     let commits = 0; let patches = 0
+    const lines = []
 
     const flush = async () => {
-      if (!items.length) return
-      await client.upload(quilt.id, pending)
-      const r = await client.importCommits(quilt.id, items.splice(0))
+      if (!items.length && !newLines.length) return
+      if (pending.length) await client.upload(quilt.id, pending)
+      const r = await client.importCommits(quilt.id, items.splice(0), newLines.splice(0))
       pending = []
       commits += r.commits; patches += r.patches
       log(`  ${patches} patches, ${commits} commits`)
     }
 
-    const emit = async (sha, square, kind) => {
+    const blobOf = async (sha, gitMode) => {
+      let b = blobs.get(sha)
+      if (!b) {
+        // A submodule has no blob in git: its entry's content is the commit sha it pins.
+        const bytes = gitMode === '160000' ? Buffer.from(sha) : (await cat.get(sha)).bytes
+        b = { id: blobId(bytes), size: bytes.length }
+        blobs.set(sha, b)
+        pending.push({ kind: 'blob', id: b.id, bytes })
+      }
+      return b
+    }
+
+    const emit = async (sha, square, kind, line) => {
       const g = info.get(sha)
       const changes = []
       for (const ch of diffTree(repo, g.parents[0] || null, sha)) {
         if (ch.delete) { changes.push({ path: ch.path, op: 'delete' }); continue }
         const mode = MODES[ch.gitMode]
-        if (!mode) { report.push({ kind: ch.gitMode === '160000' ? 'submodule' : 'mode', sha, path: ch.path, note: `git mode ${ch.gitMode} left out` }); continue }
-        let b = blobs.get(ch.sha)
-        if (!b) {
-          const { bytes } = await cat.get(ch.sha)
-          b = { id: blobId(bytes), size: bytes.length }
-          blobs.set(ch.sha, b)
-          pending.push({ kind: 'blob', id: b.id, bytes })
-        }
+        if (!mode) { report.push({ kind: 'mode', sha, path: ch.path, note: `git mode ${ch.gitMode} left out` }); continue }
+        const b = await blobOf(ch.sha, ch.gitMode)
         changes.push({ path: ch.path, op: 'put', blob: b.id, mode, size: b.size })
       }
       const c = cleanCommit({
@@ -138,56 +190,102 @@ export async function importGit (client, { repo, slug, batch = 100, log = () =>
       const id = commitId(c)
       ids.set(sha, id)
       pending.push({ kind: 'commit', id, bytes: commitBytes(c) })
-      items.push({ id, commit: c, kind, square, git_sha: sha, payload: { committer: g.committer || null, author_email: g.author?.email || '' } })
+      if (kind === 'patch') written.push(sha)
+      items.push({ id, commit: c, kind, line, square, git_sha: sha, payload: { committer: g.committer || null, author_email: g.author?.email || '' } })
       if (items.length >= batch) await flush()
     }
 
-    for (const sha of chain) {
-      const g = info.get(sha)
-      const title = String(g.message).split('\n')[0].slice(0, 200)
-      const square = { id: uuidv7(g.author?.at || Date.now()), title, base: g.parents[0] ? ids.get(g.parents[0]) || null : null, holder: member(g.author || {}).member_id }
-      if (g.parents.length > 1) {
-        // Side commits: reachable from parents 2..n and not yet in any square, parents first.
-        const side = []
-        const seen = new Set()
-        const visit = (s) => {
-          if (!s || seen.has(s) || assigned.has(s) || !info.has(s)) return
-          seen.add(s)
-          for (const p of info.get(s).parents) visit(p)
-          side.push(s)
-        }
-        for (const p of g.parents.slice(1)) visit(p)
-        if (side.length) {
-          const m = title.match(/^Merge (?:pull request #\d+ from |branch ')([^' ]+)/)
-          if (m) square.title = m[1]
-          for (const s of side) { assigned.add(s); await emit(s, square, 'side') }
+    // One branch: its first-parent commits not yet imported become patches on its line.
+    const importBranch = async (ref) => {
+      const chain = []
+      let s = ref.sha
+      for (; s && !ids.has(s); s = info.get(s).parents[0]) chain.push(s)
+      const base = s ? ids.get(s) : null
+      chain.reverse()
+      if (limit && ref.name === 'main') chain.length = Math.min(chain.length, limit)
+      if (!lineTips.has(ref.name)) {
+        if (!base) { report.push({ kind: 'branch', ref: ref.git, note: 'shares no history with the other branches; left out' }); return }
+        if (!LINE_NAME.test(ref.name) || /\.\.|\/\/|\/$/.test(ref.name)) { report.push({ kind: 'branch', ref: ref.git, note: 'its name cannot be a line; left out' }); return }
+        await flush() // the line's first commit is imported before the line names it
+        newLines.push({ name: ref.name, tip: base })
+        lineTips.set(ref.name, base)
+      } else if ((lineTips.get(ref.name) || null) !== base) {
+        // The line moved on in the quilt (merges since the import), or git rewrote the branch.
+        if (chain.length) report.push({ kind: 'branch', ref: ref.git, note: `line ${ref.name} no longer follows git's branch; its ${chain.length} new commits were left out` })
+        return
+      }
+      for (const sha of chain) {
+        const g = info.get(sha)
+        const title = String(g.message).split('\n')[0].slice(0, 200)
+        const square = { id: uuidv7(g.author?.at || Date.now()), title, base: g.parents[0] ? ids.get(g.parents[0]) || null : null, holder: member(g.author || {}).member_id }
+        if (g.parents.length > 1) {
+          // Side commits: reachable from parents 2..n and not yet in any square, parents first.
+          const side = []
+          const seen = new Set()
+          const visit = (x) => {
+            if (!x || seen.has(x) || assigned.has(x) || !info.has(x)) return
+            seen.add(x)
+            for (const p of info.get(x).parents) visit(p)
+            side.push(x)
+          }
+          for (const p of g.parents.slice(1)) visit(p)
+          if (side.length) {
+            const m = title.match(/^Merge (?:pull request #\d+ from |branch ')([^' ]+)/)
+            if (m) square.title = m[1]
+            for (const x of side) { assigned.add(x); await emit(x, square, 'side', ref.name) }
+          }
         }
+        assigned.add(sha)
+        await emit(sha, square, 'patch', ref.name)
       }
-      assigned.add(sha)
-      await emit(sha, square, 'patch')
+      lineTips.set(ref.name, chain.length ? ids.get(chain[chain.length - 1]) : base)
+      lines.push({ name: ref.name, git: ref.git, added: chain.length })
     }
+
+    for (const ref of refs) await importBranch(ref)
     await flush()
 
+    // Tags, on the commits they name. A tag is never moved: one the quilt has on another commit is reported.
+    const have = again ? new Map((await client.tags(quilt.id)).map((t) => [t.name, t.commit])) : new Map()
+    let tagged = 0
+    for (const t of onlyHead ? [] : gitTags(repo)) {
+      const id = t.type === 'commit' ? ids.get(t.sha) : null
+      if (!id) { report.push({ kind: 'tag', ref: t.name, note: 'names no imported commit; left out' }); continue }
+      if (have.has(t.name)) { if (have.get(t.name) !== id) report.push({ kind: 'tag', ref: t.name, note: 'the quilt has this tag on another commit; left as it is' }); continue }
+      try { await client.createTag(quilt.id, { name: t.name, rev: `c:${id}` }); tagged++ } catch (err) { report.push({ kind: 'tag', ref: t.name, note: err.message }) }
+    }
+
     let validated
     if (validate) {
       validated = 0
-      // validate: 'all' checks every imported commit (side commits of merges too), else the patches.
-      for (const sha of validate === 'all' ? [...ids.keys()] : chain) {
+      // validate: 'all' checks every commit the quilt has from git (side commits of merges too),
+      // else the patches this import wrote.
+      const check = validate === 'all' ? [...ids.keys()] : written
+      for (const sha of check) {
         const want = new Map()
         for (const row of git(repo, ['ls-tree', '-r', '-z', sha]).toString('utf8').split('\0').filter(Boolean)) {
           const [meta, path] = row.split('\t')
           const [mode, type, osha] = meta.split(' ')
-          if (type !== 'blob' || !MODES[mode]) continue
-          want.set(path, { mode: MODES[mode], blob: blobs.get(osha)?.id })
+          if ((type !== 'blob' && type !== 'commit') || !MODES[mode]) continue
+          want.set(path, { mode: MODES[mode], osha, gitMode: mode })
         }
         const t = await client.tree(quilt.id, `c:${ids.get(sha)}`)
-        const bad = t.entries.length !== want.size || t.entries.some((e) => { const w = want.get(e.path); return !w || w.mode !== e.mode || w.blob !== e.blob })
+        let bad = t.entries.length !== want.size
+        for (const e of t.entries) {
+          const w = want.get(e.path)
+          if (bad || !w || w.mode !== e.mode) { bad = true; break }
+          // Blobs from an earlier import were not read this time: hash them now.
+          const id = blobs.get(w.osha)?.id || blobId(w.gitMode === '160000' ? Buffer.from(w.osha) : (await cat.get(w.osha)).bytes)
+          if (id !== e.blob) { bad = true; break }
+        }
         if (bad) throw new Error(`validation: the tree of git ${sha.slice(0, 12)} does not match quilt commit ${ids.get(sha).slice(0, 12)}`)
         validated++
       }
     }
-    return { quilt: quilt.id, slug: quilt.slug, commits, patches, report, ...(validate ? { validated } : {}), tip: ids.get(chain[chain.length - 1]) }
+    return { quilt: quilt.id, slug: quilt.slug, again, commits, patches, lines, tags: tagged, report, ...(validate ? { validated } : {}), tip: lineTips.get('main') }
   } finally {
     cat.close()
   }
 }
+
+const LINE_NAME = /^[A-Za-z0-9._-][A-Za-z0-9._/-]{0,99}$/