heyquilt 0.3.118 → 0.3.120

package/RELEASES.md

@@ -11,6 +11,31 @@ Format: `## <version> — <YYYY-MM-DD>`, an optional one-line summary, then bull
 Lead each bullet with a short bold phrase. Inline `code` and **bold** are rendered;
 nothing else is.
 
+## 0.3.120 — 2026-10-26
+
+Seam gets nearly everything its docs said was missing.
+
+- **Seam release lines**: `seam line new 1.0 --from patch:780` makes `release/1.0` from any revision; squares open on it (`--line`) and merge into it apart from `main`; `seam line freeze` stops merges into a line until it is unfrozen. Also as `seam_line_*` tools and `GET`/`POST /lines`.
+- **Seam tags and releases**: `seam tag v1.0 patch:780` names a commit for good (read it as `tag:v1.0` anywhere a revision goes); `seam release v1.1 -m "notes"` is a tag with release notes. `seam tag` and `seam release` alone list them. Also as `seam_tag`, `seam_release` and their `_list` tools, and `GET`/`POST /tags` and `/releases`.
+- **Seam imports all of a git repo**: `seam import git` now brings every branch (as a line with the branch's name, remote-only branches of a clone too) and every tag, keeps submodules as gitlink entries and LFS pointer files as they are, and run again into the same quilt adds only the new commits. Also as the `seam_import_git` tool.
+- **Seam block folders: restore, reset, clean**: `seam restore <paths>` throws away uncommitted edits, `seam reset [rev]` makes the folder's files those of a revision (commit the difference to undo a square's last commit), and `seam clean [-f]` removes files nobody committed. Every `.gitignore` in a block folder is read now, not only the top one, and a committed file is never ignored. Also as `seam_restore`, `seam_reset` and `seam_clean` tools.
+- **Seam live work and `^` on squares**: `seam live share` puts a block folder's uncommitted edits on the server so anyone can read them as `sq:<id>:live` (`seam ls`, `cat`, `diff`) before they are committed; `seam live` shows them and `seam live clear` takes them back. `sq:<id>^` and `sq:<id>^2` name a square head's parents. Also as `seam_live` / `seam_live_set` and `GET`/`PUT /squares/:id/live`.
+- **Seam history tools**: `seam bisect <bad> <good> --run "<check>"` finds the commit that broke something (each step checked out and tested in a fresh folder); `seam grep` searches the files at any revision; `seam log --follow` follows a file through renames and `seam log -S <text>` finds where text came or went; `seam describe` and `seam merge-base` as in git. The same as `seam_bisect`, `seam_grep`, `seam_describe`, `seam_merge_base` and HTTP
+- **Seam amend**: `seam commit --amend [-m "message"]` changes your square's last commit instead of adding one (a forgotten file, a better message); `seam_commit` with `amend: true` and `POST /squares/<s>/amend` do the same
+- **Seam claims**: `seam claim "src/api/**" --note "why"` claims files, folders or globs for your square, so other squares' commits to them on the same line are refused (`claim_refused`) until it merges or `seam unclaim`; `seam claim` lists them. `seam_claim`, `seam_claims`, `seam_unclaim` and `/claims` routes do the same
+- **Seam reverts a patch that broke a check**: `seam check ci red --patch 784` (or `seam_check`, or `POST /lines/main/checks` with `patch`) reverts that patch on the line by itself and hands its holder a square holding the change again to fix; they get a `patch.reverted` event. Without `--patch` a red check only halves the merge window, as before
+- **Seam remembers how a conflict was settled**: settle a conflict once (by hand or with `seam resolve`) and the same conflict coming back in a later rebase or merge is settled the same way, naming who settled it. `seam resolutions` lists them, `seam resolutions forget <key>` drops one, `--no-remember` skips it (also `seam_resolutions`, `seam_forget_resolution`, `GET /resolutions`)
+- **Seam stacks squares**: `seam square open <title> --on sq:…` (or `seam_open_square { on }`, `POST /squares { on }`) starts your square from another open square's work. It can't merge before that one, and when that one merges yours is moved onto the line by itself
+- **Seam review**: `seam review approve|request-changes|comment|dismiss <square>` reviews a square (a comment can sit on one line of a file), `seam review <square>` shows the reviews, and `seam line require main 2` makes a line refuse merges (`428 policy`) until a square's latest commit has two approvals from people other than its holder and nobody's request for changes stands. Also as `seam_review`, `seam_reviews`, `seam_line_require` and `/squares/<s>/reviews`, `/lines/<line>/policy`.
+- **Seam required checks**: `seam line require main --checks ci,lint` makes a line refuse merges (`428 policy`) until each named check is green on a square's latest commit; CI reports with `seam check ci green --square <sq>` (or `seam_check { square }`, `POST /squares/<s>/checks`). Seam doesn't run the checks, the runner reports them.
+- **Seam signed commits**: `seam key add` makes an Ed25519 key on your computer and adds it to your account, `seam commit --sign` (or `seam sign <rev>`) signs a commit you made, and `seam log --show-signature` checks each one: good, bad, removed key or none. Also as `seam_key_add`, `seam_sign`, `seam_commit { sign }`, `/v1/signing-keys` and `POST /commits/<rev>/signatures`.
+- **Seam code search**: `seam grep --all <pattern>` searches every quilt you can read at once (`--quilts a,b` for some), at main or any revision, and prints the quilt before each file. Also as `seam_search` and `GET /v1/search`.
+- **Seam quilt tokens**: `seam token new ci --level write` makes a key for one quilt (read or write) for a CI job or script; its `sqt_` secret is shown once and works as `SEAM_TOKEN` or `Authorization: Bearer`. `seam token` lists them and `seam token revoke ci` ends one at once. Also as `seam_token_new`, `seam_token_list`, `seam_token_revoke` and `/tokens` routes.
+
+## 0.3.119 — 2026-10-25
+
+- **Your cloud AI no longer answers old messages again.** Each time its machine started, your cloud AI took messages already written to it for new ones (it learnt its name only after looking), so it did old work again, sometimes for half an hour, while new messages waited. It now answers only what was written while it was away.
+
 ## 0.3.118 — 2026-10-25
 
 - **A new name for your AI shows at once.** Renaming your cloud AI (or changing its color) now makes it join its sessions again under the new name within seconds, once it isn't in the middle of a run, so @its new name reaches it. Before, it kept its old name for up to five minutes and then dropped out of the session's people list.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyquilt",
-  "version": "0.3.118",
+  "version": "0.3.120",
   "description": "Real-time, tool-agnostic pair vibe coding: sync a project folder live between collaborators using any AI coding tool.",
   "author": {
     "name": "Daniel Carmichael",

package/src/api/server.js

@@ -48,6 +48,7 @@ import { voiceRoutes } from './routes/voice.js'
 import { mailRoutes } from './routes/mail.js'
 import { agentWakeRoutes } from './routes/agent-wake.js'
 import { quiltRoutes } from '../quilts/routes.js'
+import { workspaceReach } from './workspace-reach.js'
 import { leader, LEADER_ONLY } from './leader.js'
 import { autoscale } from './autoscale.js'
 import { scaler as machineScaler } from './scaler.js'
@@ -416,7 +417,15 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
   // How Quilt wakes each agent (routes/agent-wake.js): step 2 of joining.
   routes.push(...agentWakeRoutes({ ...ctx, passKey, mail, mailFetch, makeLimiter }))
   // Quilt source control (src/quilts/, plans/quilt-source-control/): off unless startApi gets `quilts`.
-  routes.push(...quiltRoutes({ ...ctx, passKey, quilts }))
+  // Seam takes who is calling from us, as a quilt member: { member_id, kind, name, tool?, on_behalf_of? }.
+  const quiltCaller = quilts ? workspaceReach({ ...ctx, passKey }) : null
+  const identifyQuiltMember = async (req) => {
+    const c = await quiltCaller.caller(req)
+    if (c.agent) return { member_id: c.account, kind: 'agent', name: c.agent.name || 'agent', ...(c.agent.provider ? { tool: String(c.agent.provider).toLowerCase() } : {}), ...(c.agent.ownerUserId ? { on_behalf_of: `person:${c.agent.ownerUserId}` } : {}) }
+    const p = c.userId && store.profile ? await store.profile(c.userId).catch(() => null) : null
+    return { member_id: c.account, kind: 'person', name: (p && p.name) || 'person' }
+  }
+  routes.push(...quiltRoutes({ quilts, identify: identifyQuiltMember }))
 
   async function openLink (code) {
     const userCode = normalizeUserCode(code)

package/src/quilts/archiver.js

@@ -158,9 +158,16 @@ export async function replaySegments (objects, q) {
     if (p && p.hidden_seq == null) p.hidden_seq = c.seq
   }
   for (const row of log) {
+    // A line made from a commit, and a line frozen or unfrozen (policy rows naming the line).
+    if (row.kind === 'policy' && row.line && row.payload) {
+      const op = row.payload.op
+      if (op === 'line') lines.set(row.line, { name: row.line, tip: row.payload.tip || null, tip_seq: row.seq, patch_count: 0, frozen: false })
+      else if ((op === 'freeze' || op === 'unfreeze') && lines.has(row.line)) lines.get(row.line).frozen = op === 'freeze'
+      continue
+    }
     if (row.kind !== 'merge') continue
     const id = row.commit || row.to || row.commit_id
-    lines.set(row.line, { name: row.line, tip: id, tip_seq: row.seq, patch_count: row.patch_no })
+    lines.set(row.line, { ...lines.get(row.line), name: row.line, tip: id, tip_seq: row.seq, patch_count: row.patch_no })
     const c = commits.get(id)
     if (c) { c.patch = { line: row.line, patch_no: row.patch_no }; if (row.snapshot_root) c.snapshot_root = row.snapshot_root }
   }

package/src/quilts/autorevert.js

@@ -0,0 +1,49 @@
+// The automatic revert (plans/quilt-source-control/07 "The post-merge pipeline", steps 3 and 4).
+// A red post-merge check that names the patch it failed at (`patch`, found by the runner, for
+// example with `seam bisect`) reverts that patch on the line by itself: a revert square is opened
+// and merged as the reporter, and a fix square holding the change again is opened for the
+// patch's holder, so fixing forward is "edit, commit, merge". The patch stays in history. The
+// revert is an ordinary revert and merge, so a frozen line or a full merge window refuses it like
+// any merge and the revert square is left open; a revert that conflicts with later patches is
+// left open too, with its terms.
+import { QuiltError } from './service.js'
+
+export function autoRevertOps (svc, { revert, mergeIntoLine, cherryPick, openSquare, handoff }) {
+  const { store, quiltFor, resolve, getCommit, squareView } = svc.internals
+
+  async function revertCulprit (me, ref, line, check, n) {
+    const q = await quiltFor(me, ref, 'write')
+    const row = await store.patch(q.id, line, n)
+    if (!row || !row.commit) throw new QuiltError(404, 'not_found', `${line} has no patch ${n}`)
+    const culprit = await resolve(q.id, `${line}:${n}`)
+    const x = await getCommit(q.id, culprit)
+    const first = String(x.message || '').split('\n')[0]
+    let r
+    try {
+      r = await revert(me, ref, { rev: `${line}:${n}`, line, message: `Revert patch ${line}:${n}: ${check} failed\n\nThis reverts patch ${line}:${n} (${first}).` })
+    } catch (err) {
+      if (err.code === 'bad_request') return { reverted: false, patch_no: n, refused: { code: 'nothing_to_revert', detail: err.message } }
+      throw err
+    }
+    const out = { reverted: false, patch_no: n, square: r.square }
+    if (r.conflicted) return { ...out, refused: { code: 'conflict', detail: `the revert conflicts with later patches in ${r.terms.map((t) => t.path).join(', ')}; resolve and merge the revert square` } }
+    try {
+      const m = await mergeIntoLine(me, ref, line, { square: r.square.id }, { reverts: n })
+      if (!m.ok) return { ...out, square: m.square || r.square, refused: m.refused }
+      Object.assign(out, { reverted: true, revert_patch_no: m.merged.patch_no, square: m.square })
+    } catch (err) {
+      if (!err.code || !err.status) throw err
+      return { ...out, refused: { code: err.code, detail: err.message } }
+    }
+    // The fix square: the change again over the tip after the revert, held by the patch's holder.
+    const orig = row.square ? await store.getSquare(row.square) : null
+    const holder = orig && !orig.import ? orig.holder : null
+    const fix = await openSquare(me, ref, { title: `Fix ${first || `patch ${line}:${n}`}`.slice(0, 200), line })
+    await cherryPick(me, ref, fix.id, { from: culprit, expect_head: null, message: x.message })
+    if (holder && holder !== me.member_id) await handoff(me, ref, fix.id, { to: holder, context: `Patch ${line}:${n} was reverted: ${check} failed. This square holds the change again: fix it, commit, merge.` })
+    out.fix_square = await squareView(await store.getSquare(fix.id))
+    return out
+  }
+
+  return { revertCulprit }
+}

package/src/quilts/bisect-run.js

@@ -0,0 +1,31 @@
+// The check side of bisect (the server narrows, history.js): each commit the server names is
+// checked out into a fresh folder and the check command runs there. Exit 0 is good, 125 is skip,
+// 1 to 127 is bad, anything else (a signal, 128 and up) stops, as git bisect run does.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { checkout } from './block.js'
+
+const runIn = (cmd, cwd) => new Promise((resolve, reject) => {
+  const child = spawn(cmd, { cwd, shell: true, stdio: 'ignore' })
+  child.on('error', reject)
+  child.on('exit', (code, signal) => resolve(signal ? null : code))
+})
+
+export async function bisectRun (client, { quilt, bad, good, run, marks = {}, paths = [''], api, log = () => {} }) {
+  const m = { ...marks }
+  for (let i = 0; i < 200; i++) {
+    const r = await client.bisect(quilt, { bad, good, marks: m })
+    if (r.done) return { ...r, marks: m }
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'seam-bisect-'))
+    try {
+      await checkout(client, { quilt, rev: r.next.id, paths, dir, api })
+      const code = await runIn(run, dir)
+      if (code == null || code > 127) throw new Error(`The check stopped on ${r.next.short} (exit ${code ?? 'by a signal'}): bisect stopped.`)
+      m[r.next.id] = code === 0 ? 'good' : code === 125 ? 'skip' : 'bad'
+      log(`${r.next.short} ${m[r.next.id]}`)
+    } finally { fs.rmSync(dir, { recursive: true, force: true }) }
+  }
+  throw new Error('bisect took more than 200 steps')
+}

package/src/quilts/block.js

@@ -35,29 +35,57 @@ export function saveBlock (dir, block) {
 
 const inBlock = (block, p) => block.paths.some((x) => under(p, x))
 
-function ignorer (dir) {
-  const ig = ignore().add(ALWAYS_IGNORED)
-  try { ig.add(fs.readFileSync(path.join(dir, '.gitignore'), 'utf8')) } catch {}
-  return ig
+/** The folders that hold committed files: they are walked even when a .gitignore names them. */
+function trackedDirs (block) {
+  const out = new Set()
+  for (const p of Object.keys(block.files)) for (let i = p.indexOf('/'); i > 0; i = p.indexOf('/', i + 1)) out.add(p.slice(0, i))
+  return out
+}
+
+/** Reads `rel`/.gitignore into the stack of rules in force there (deepest last). */
+function rulesIn (dir, rel, stack) {
+  try { return [...stack, { base: rel, ig: ignore().add(fs.readFileSync(path.join(dir, rel, '.gitignore'), 'utf8')) }] } catch { return stack }
+}
+
+/** As git decides: the deepest .gitignore with a rule for the path wins (a `!` rule re-includes). */
+function ignoredBy (stack, r, isDir) {
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const { base, ig } = stack[i]
+    const rel = base ? r.slice(base.length + 1) : r
+    const res = ig.test(isDir ? rel + '/' : rel)
+    if (res.ignored) return true
+    if (res.unignored) return false
+  }
+  return false
 }
 
-/** Every file under the block's paths on disk: Map path → { abs, stat }. */
+const ALWAYS = ignore().add(ALWAYS_IGNORED)
+
+/**
+ * Every file under the block's paths on disk: Map path → { abs, stat }. Every .gitignore on the
+ * way down is read, as git does; a committed file is never ignored.
+ */
 function scan (dir, block) {
-  const ig = ignorer(dir)
   const out = new Map()
-  const walk = (rel) => {
+  const dirs = trackedDirs(block)
+  const walk = (rel, stack) => {
     let names
     try { names = fs.readdirSync(path.join(dir, rel), { withFileTypes: true }) } catch { return }
     for (const d of names) {
       const r = rel ? `${rel}/${d.name}` : d.name
-      if (ig.ignores(d.isDirectory() ? r + '/' : r)) continue
-      if (d.isDirectory()) { if (block.paths.some((x) => under(r, x) || under(x, r))) walk(r); continue }
+      const n = r.normalize('NFC')
+      const isDir = d.isDirectory()
+      if (ALWAYS.ignores(isDir ? r + '/' : r)) continue
+      if (!(isDir ? dirs.has(n) : block.files[n]) && ignoredBy(stack, r, isDir)) continue
+      // A submodule's folder stands for its gitlink entry: what is inside belongs to the submodule.
+      if (isDir && block.files[n]?.mode === 'gitlink') { out.set(n, { abs: path.join(dir, r), gitlink: true }); continue }
+      if (isDir) { if (block.paths.some((x) => under(r, x) || under(x, r))) walk(r, rulesIn(dir, r, stack)); continue }
       if (!(d.isFile() || d.isSymbolicLink()) || !inBlock(block, r)) continue
       const abs = path.join(dir, r)
-      out.set(r.normalize('NFC'), { abs, stat: fs.lstatSync(abs) })
+      out.set(n, { abs, stat: fs.lstatSync(abs) })
     }
   }
-  walk('')
+  walk('', rulesIn(dir, '', []))
   return out
 }
 
@@ -75,8 +103,8 @@ export function localChanges (dir, block, { paths = [] } = {}) {
   const wanted = (p) => !only.length || only.some((x) => under(p, x))
   const files = scan(dir, block)
   const out = []
-  for (const [p, { abs, stat }] of files) {
-    if (!wanted(p)) continue
+  for (const [p, { abs, stat, gitlink }] of files) {
+    if (!wanted(p) || gitlink) continue
     const known = block.files[p]
     if (known && known.size === stat.size && known.mtimeMs === stat.mtimeMs) continue
     const { bytes, mode } = readFileEntry(abs, stat)
@@ -94,6 +122,8 @@ async function writeEntry (dir, e, content) {
   const abs = path.join(dir, ...e.path.split('/'))
   fs.mkdirSync(path.dirname(abs), { recursive: true })
   try { fs.rmSync(abs, { force: true }) } catch {}
+  // A git submodule is an empty folder, as git leaves one it has not cloned.
+  if (e.mode === 'gitlink') { fs.mkdirSync(abs, { recursive: true }); return { blob: e.blob, mode: 'gitlink', size: e.size, mtimeMs: 0 } }
   if (e.mode === 'symlink') fs.symlinkSync(content.toString('utf8'), abs)
   else fs.writeFileSync(abs, content, { mode: e.mode === 'exec' ? 0o755 : 0o644 })
   const st = fs.lstatSync(abs)
@@ -156,7 +186,11 @@ export async function syncTo (client, dir, block, to, { square } = {}) {
   for (const f of d.files) {
     if (local.has(f.path)) { kept.push(f.path); continue }
     const e = byPath.get(f.path)
-    if (!e) { fs.rmSync(path.join(dir, ...f.path.split('/')), { force: true }); delete block.files[f.path]; written++; continue }
+    if (!e) {
+      const abs = path.join(dir, ...f.path.split('/'))
+      if (block.files[f.path]?.mode === 'gitlink') { try { fs.rmdirSync(abs) } catch {} } else fs.rmSync(abs, { force: true })
+      delete block.files[f.path]; written++; continue
+    }
     block.files[f.path] = await writeEntry(dir, e, await get(e))
     written++
   }
@@ -213,6 +247,25 @@ export async function commitFolder (client, dir, block, { message, paths = [] })
   return r
 }
 
+/** Amends the square's last commit with the folder's changes (paths: only these) and, if given, a new message. */
+export async function amendFolder (client, dir, block, { message, paths = [] }) {
+  if (!block.square) throw new Error('This folder is a read-only checkout of a line; there is no commit of yours to amend.')
+  const changes = localChanges(dir, block, { paths })
+  const blobs = changes.filter((c) => c.bytes).map((c) => ({ kind: 'blob', id: c.blob, bytes: c.bytes }))
+  if (blobs.length) await client.upload(block.quilt, blobs)
+  const list = changes.map((c) => c.status === 'deleted' ? { path: c.path, op: 'delete' } : { path: c.path, op: 'put', blob: c.blob, mode: c.mode || 'file' })
+  const r = await client.amend(block.quilt, block.square, { expect_head: block.head, ...(message ? { message } : {}), changes: list })
+  for (const c of changes) {
+    if (c.status === 'deleted') { delete block.files[c.path]; continue }
+    const st = fs.lstatSync(path.join(dir, ...c.path.split('/')))
+    block.files[c.path] = { blob: c.blob, mode: c.mode, size: st.size, mtimeMs: st.mtimeMs }
+  }
+  block.at = r.square.head
+  block.head = r.square.head
+  saveBlock(dir, block)
+  return r
+}
+
 /** The folder's changes as a unified diff against `at` (diff with no revision, in a block). */
 export async function localDiff (client, dir, block, { paths = [] } = {}) {
   const changes = localChanges(dir, block, { paths })
@@ -226,3 +279,69 @@ export async function localDiff (client, dir, block, { paths = [] } = {}) {
   }
   return { changes: changes.map(({ bytes, ...c }) => c), text: out.join('') }
 }
+
+const absOf = (dir, p) => path.join(dir, ...p.split('/'))
+const removeEntry = (dir, p, mode) => { const abs = absOf(dir, p); if (mode === 'gitlink') { try { fs.rmdirSync(abs) } catch {} } else fs.rmSync(abs, { force: true }) }
+
+/** Takes away the folders a removed file leaves empty, up to the block folder. */
+function pruneEmpty (dir, p) {
+  for (let d = path.dirname(absOf(dir, p)); d.startsWith(dir + path.sep); d = path.dirname(d)) {
+    try { if (fs.readdirSync(d).length) return; fs.rmdirSync(d) } catch { return }
+  }
+}
+
+/**
+ * restore: puts the named paths back as they were at the folder's last commit (`at`), throwing
+ * away their uncommitted edits and deletions. Files nobody committed are left (clean removes them).
+ */
+export async function restore (client, dir, block, { paths }) {
+  if (!paths?.length) throw new Error('Which files? seam restore <paths> (. for everything here)')
+  const changes = localChanges(dir, block, { paths }).filter((c) => c.status !== 'added')
+  const entries = changes.map((c) => ({ path: c.path, ...block.files[c.path] }))
+  const get = await contentsFor(client, block.quilt, `c:${block.at}`, entries)
+  for (const e of entries) block.files[e.path] = { ...await writeEntry(dir, e, await get(e)), ...(e.term ? { term: e.term } : {}) }
+  saveBlock(dir, block)
+  return { restored: entries.map((e) => e.path) }
+}
+
+/**
+ * reset: makes the folder's files those of `rev` (default: the folder's last commit, throwing
+ * away every uncommitted edit). The folder stays on its square or line: what differs from there
+ * shows as uncommitted changes, so a commit makes the square match `rev`. Files nobody committed
+ * stay unless `rev` has them.
+ */
+export async function reset (client, dir, block, { rev } = {}) {
+  if (!rev) {
+    const r = await restore(client, dir, block, { paths: [dir] })
+    return { rev: block.at, written: r.restored.length, removed: 0, changes: 0 }
+  }
+  const t = await client.tree(block.quilt, rev, block.paths)
+  const local = new Map(localChanges(dir, block).map((c) => [c.path, c]))
+  const want = new Map(t.entries.map((e) => [e.path, e]))
+  const toWrite = t.entries.filter((e) => {
+    const known = block.files[e.path]
+    return local.has(e.path) || !known || known.blob !== e.blob || known.mode !== e.mode || (e.term || null) !== (known.term || null)
+  })
+  const get = await contentsFor(client, block.quilt, rev, toWrite)
+  let removed = 0
+  for (const e of toWrite) {
+    const rec = await writeEntry(dir, e, await get(e))
+    const known = block.files[e.path]
+    // Same as the folder's commit: clean again. Otherwise the manifest keeps the commit's record,
+    // so the file shows as changed.
+    if (known && known.blob === e.blob && known.mode === e.mode) block.files[e.path] = rec
+  }
+  for (const [p, f] of Object.entries(block.files)) {
+    if (want.has(p) || !fs.existsSync(absOf(dir, p))) continue
+    removeEntry(dir, p, f.mode); pruneEmpty(dir, p); removed++
+  }
+  saveBlock(dir, block)
+  return { rev: t.commit, written: toWrite.length, removed, changes: localChanges(dir, block).length }
+}
+
+/** clean: removes the files under `paths` that nobody committed and no .gitignore names. */
+export function clean (dir, block, { paths = [], dryRun = false } = {}) {
+  const added = localChanges(dir, block, { paths }).filter((c) => c.status === 'added').map((c) => c.path)
+  if (!dryRun) for (const p of added) { removeEntry(dir, p, 'file'); pruneEmpty(dir, p) }
+  return { removed: added, dry_run: dryRun }
+}

package/src/quilts/bucket.js

@@ -0,0 +1,25 @@
+// A private Supabase Storage bucket for a quilt's packs: write-once signed uploads, short-lived
+// signed downloads, listing. Ids come from the content, so an upload never replaces what is there.
+import { createClient } from '@supabase/supabase-js'
+
+const LINK_S = 10 * 60
+
+export class SupabaseBucket {
+  constructor ({ url, key, bucket }) {
+    this.bucket = createClient(url, key, { auth: { persistSession: false, autoRefreshToken: false } }).storage.from(bucket)
+  }
+
+  // Supabase signed uploads can't bound size: the bucket's file_size_limit caps each object.
+  async uploadTarget (room, name) {
+    const { data, error } = await this.bucket.createSignedUploadUrl(`${room}/${name}`, { upsert: false })
+    if (error && (String(error.statusCode) === '409' || /exists|duplicate/i.test(String(error.message)))) return { exists: true }
+    if (error) throw new Error(`storage: ${error.message}`)
+    return { method: 'PUT', url: data.signedUrl }
+  }
+
+  async downloadTarget (room, name) {
+    const { data, error } = await this.bucket.createSignedUrl(`${room}/${name}`, LINK_S)
+    if (error) throw new Error(`storage: ${error.message}`)
+    return { url: data.signedUrl }
+  }
+}

package/src/quilts/claims.js

@@ -0,0 +1,144 @@
+// Claims on a square's files (plans/quilt-source-control/06, "Claims on squares"): a claim says
+// "this square is working on these paths" so nobody else spends work on them. A write under a
+// claimed pattern from another open square on the same line is refused (412 claim_refused) and the
+// writer is told who holds it and why. A claim lasts while its square is open: merging, abandoning
+// or archiving the square lets go of it. Merges never check claims; overlapping work that was
+// written before a claim existed still meets at the merge (07).
+import { QuiltError, squareShort } from './errors.js'
+import { uuidv7 } from './ids.js'
+
+export const MAX_PATTERN = 500
+export const MAX_NOTE = 300
+export const MAX_CLAIMS = 200 // per square
+
+/** A path, folder or simple glob (*, **, ?) as a matcher over file paths. */
+export function globMatcher (pattern) {
+  const p = String(pattern).trim().replace(/^\.\//, '')
+  if (!/[*?]/.test(p)) {
+    const base = p.replace(/\/+$/, '')
+    return (rel) => rel === base || rel.startsWith(base + '/')
+  }
+  let re = ''
+  for (let i = 0; i < p.length; i++) {
+    const c = p[i]
+    if (c === '*' && p[i + 1] === '*') {
+      re += '.*'
+      i++
+      if (p[i + 1] === '/') i++
+    } else if (c === '*') re += '[^/]*'
+    else if (c === '?') re += '[^/]'
+    else re += c.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+  }
+  const rx = new RegExp(`^${re}$`)
+  return (rel) => rx.test(rel)
+}
+
+/** Whether two patterns can cover the same file (paths: files that exist now). */
+export function patternsOverlap (a, b, paths = []) {
+  if (a === b) return true
+  const ma = globMatcher(a)
+  const mb = globMatcher(b)
+  if (ma(b) || mb(a) || paths.some((p) => ma(p) && mb(p))) return true
+  // A glob reaches every file under the text before its first wildcard: when one pattern's stem
+  // is inside the other's, they may meet on a file that does not exist yet.
+  const stem = (p) => p.split(/[*?]/)[0]
+  const [sa, sb] = [stem(a), stem(b)]
+  if (sa === a && sb === b) return false
+  const [short, long] = sa.length <= sb.length ? [sa, sb] : [sb, sa]
+  return short !== '' && (long.startsWith(short.endsWith('/') ? short : short + '/') || long === short)
+}
+
+/** A claim pattern: a relative path, folder or glob, no `..`. */
+export function claimPattern (raw) {
+  const p = String(raw || '').trim().replace(/^\.\//, '')
+  if (!p || p.length > MAX_PATTERN || p.startsWith('/') || p.split('/').includes('..') || p.includes('\0') || p.includes('\\')) {
+    throw new QuiltError(400, 'bad_request', `a claim is a relative path, folder or glob (*, **, ?), up to ${MAX_PATTERN} characters`)
+  }
+  return p
+}
+
+const ACTIVE = new Set(['open', 'merging'])
+
+/** The claims that still hold: those of open squares. */
+export async function liveClaims (store, q) {
+  const rows = await store.claims(q)
+  if (!rows.length) return []
+  const squares = new Map()
+  const out = []
+  for (const c of rows) {
+    if (!squares.has(c.square_id)) squares.set(c.square_id, await store.getSquare(c.square_id))
+    const sq = squares.get(c.square_id)
+    if (sq && ACTIVE.has(sq.state)) out.push({ ...c, line: sq.line })
+  }
+  return out
+}
+
+/** Refuses a write to `paths` from square `sq` when another open square on its line claims one. */
+export async function guardClaims (store, q, sq, paths) {
+  if (!paths.length) return
+  // A stacked square writes under its parents' claims (06): it builds on their work.
+  const mine = new Set([sq.id])
+  for (let p = sq; p.parent_square && mine.size <= 10;) { mine.add(p.parent_square); p = await store.getSquare(p.parent_square); if (!p) break }
+  const others = (await liveClaims(store, q)).filter((c) => !mine.has(c.square_id) && c.line === sq.line)
+  for (const c of others) {
+    const m = globMatcher(c.pattern)
+    const hit = paths.find((p) => m(p))
+    if (hit) {
+      throw new QuiltError(412, 'claim_refused', `${hit} is claimed by ${c.holder} in ${squareShort(c.square_id)}${c.note ? ` (${c.note})` : ''}: wait for it, ask them to hand it over, or work on other files`,
+        { path: hit, claim: view(c) })
+    }
+  }
+}
+
+const view = (c) => ({ id: c.id, pattern: c.pattern, square: squareShort(c.square_id), square_id: c.square_id, line: c.line, holder: c.holder, note: c.note || '', at: c.at })
+
+export function claimOps (svc) {
+  const { store, now, quiltFor, squareByRef, writable, entriesOf, snapshot, fromStore } = svc.internals
+
+  /** GET /claims[?square=]: the claims that hold now, oldest first. */
+  async function claims (me, ref, { square } = {}) {
+    const q = await quiltFor(me, ref, 'read')
+    let rows = await liveClaims(store, q.id)
+    if (square) { const sq = await squareByRef(q.id, square); rows = rows.filter((c) => c.square_id === sq.id) }
+    return { claims: rows.sort((a, b) => a.at - b.at).map(view) }
+  }
+
+  /** POST /squares/:id/claims { pattern, note? }: claims paths for the square. */
+  async function claim (me, ref, sqRef, body = {}) {
+    const q = await quiltFor(me, ref, 'write')
+    const sq = await writable(me, q, sqRef)
+    if (sq.state !== 'open') throw new QuiltError(409, 'square_closed', `the square is ${sq.state}`)
+    const pattern = claimPattern(body.pattern)
+    const note = String(body.note || '')
+    if (note.length > MAX_NOTE) throw new QuiltError(400, 'bad_request', `a claim's note is up to ${MAX_NOTE} characters`)
+    const all = await liveClaims(store, q.id)
+    const mine = all.filter((c) => c.square_id === sq.id)
+    const same = mine.find((c) => c.pattern === pattern)
+    if (same) return view(same)
+    if (mine.length >= MAX_CLAIMS) throw new QuiltError(400, 'bad_request', `a square holds up to ${MAX_CLAIMS} claims`)
+    const others = all.filter((c) => c.square_id !== sq.id && c.line === sq.line)
+    if (others.length) {
+      const tip = (await store.getLine(q.id, sq.line))?.tip || sq.base
+      const paths = tip ? (await entriesOf(q.id, await snapshot(q.id, tip))).map((e) => e.path) : []
+      const taken = others.find((c) => patternsOverlap(c.pattern, pattern, paths))
+      if (taken) throw new QuiltError(409, 'claim_taken', `${taken.pattern} is already claimed by ${taken.holder} in ${squareShort(taken.square_id)}${taken.note ? ` (${taken.note})` : ''}`, { claim: view(taken) })
+    }
+    try {
+      const row = await store.createClaim({ quilt_id: q.id, id: uuidv7(now()), square_id: sq.id, pattern, holder: me.member_id, note, at: now() })
+      return view({ ...row, line: sq.line })
+    } catch (err) { throw fromStore(err) }
+  }
+
+  /** DELETE /squares/:id/claims/:claim (its id or its pattern): lets go of a claim. */
+  async function unclaim (me, ref, sqRef, which) {
+    const q = await quiltFor(me, ref, 'write')
+    const sq = await writable(me, q, sqRef)
+    const key = String(which || '').trim().replace(/^\.\//, '')
+    const c = (await store.claims(q.id)).find((x) => x.square_id === sq.id && (x.id === key || x.pattern === key))
+    if (!c) throw new QuiltError(404, 'not_found', `${squareShort(sq.id)} has no claim ${key}`)
+    try { await store.deleteClaim({ quilt_id: q.id, id: c.id }) } catch (err) { throw fromStore(err) }
+    return { ok: true, released: view({ ...c, line: sq.line }) }
+  }
+
+  return { claims, claim, unclaim }
+}