@heyquilt/seam 0.142.0 → 0.143.0

package/bin/seam.js

@@ -20,6 +20,7 @@ Docs: https://seam.heyquilt.com/docs
   seam login [--no-browser]          Sign in with your Seam account (seam.heyquilt.com)
   seam logout | seam whoami
   seam computers [list | signout <id or name>]   computers signed in to your account (seam login)
+  seam handle [<new>]                your name in your repos' addresses (<handle>/<repo>); with <new>, change it
   seam account delete --confirm <your email>   delete your Seam account (your patches stay)
   seam agent new <name> | list | key <name> | revoke <name> | relink [agent:<id>]   your agents and their keys
   seam oauth client new <name> --redirect <uri> | list | revoke <client_id>   apps that ask people for access (OAuth 2, PKCE)
@@ -131,6 +132,13 @@ async function main () {
   if (cmd === 'whoami') { const a = readAccount(); if (!a) { process.exitCode = 1; return console.log('Not signed in.') } return console.log(`${a.account.name} (${a.account.email})`) }
   if (cmd === 'agent') return agentCommand(argv[0], argv[1])
   if (cmd === 'computers') return computersCommand(argv[0], argv[1])
+  // Your handle (11.2, 2026-10-29): your repos are <handle>/<repo>, on the site and in every command.
+  if (cmd === 'handle') {
+    const go = signedIn()
+    if (!argv[0]) { const me = await go('GET', '/v1/me'); return console.log(me.account?.handle ? `${me.account.handle}: your repos are ${me.account.handle}/<repo>.` : 'Your account has no handle on this Seam server.') }
+    const r = await go('PUT', '/v1/me/handle', { handle: argv[0] })
+    return console.log(`Your handle is ${r.handle}: your repos are ${r.handle}/<repo> now, and their old addresses stop working.`)
+  }
   if (cmd === 'account') {
     const i = argv.indexOf('--confirm')
     if (argv[0] !== 'delete' || i < 0 || !argv[i + 1]) fail('seam account delete --confirm <your email>')

package/lib/quilts/attest.js

@@ -53,27 +53,40 @@ const keyIdOf = (raw) => 'ed25519:' + crypto.createHash('sha256').update(raw).di
  * The server's attestation key from SEAM_ATTESTATION_KEY (an Ed25519 private key: PKCS8 PEM, or
  * base64 of its PKCS8 DER), or a new one for this process when none is given.
  */
-export function attestationKey (secret) {
+export const attestationKey = (secret) => ed25519Key(secret, 'SEAM_ATTESTATION_KEY')
+
+/**
+ * An Ed25519 signing key from a setting's value (PKCS8 PEM, or base64 of its PKCS8 DER), or a new
+ * one for this process when none is given: { id, public_key, ephemeral, sign(text) → base64 }.
+ */
+export function ed25519Key (secret, setting) {
   let key
   if (secret) {
     const s = String(secret).trim()
-    key = s.includes('BEGIN') ? crypto.createPrivateKey(s) : crypto.createPrivateKey({ key: Buffer.from(s, 'base64'), format: 'der', type: 'pkcs8' })
-    if (key.asymmetricKeyType !== 'ed25519') throw new Error('SEAM_ATTESTATION_KEY is not an Ed25519 private key')
+    try {
+      key = s.includes('BEGIN') ? crypto.createPrivateKey(s) : crypto.createPrivateKey({ key: Buffer.from(s, 'base64'), format: 'der', type: 'pkcs8' })
+    } catch { throw new Error(`${setting} is not an Ed25519 private key (PKCS8 PEM or base64 DER)`) }
+    if (key.asymmetricKeyType !== 'ed25519') throw new Error(`${setting} is not an Ed25519 private key`)
   } else key = crypto.generateKeyPairSync('ed25519').privateKey
   const raw = crypto.createPublicKey(key).export({ format: 'der', type: 'spki' }).subarray(SPKI_PREFIX.length)
   return { id: keyIdOf(raw), public_key: raw.toString('base64'), ephemeral: !secret, sign: (text) => crypto.sign(null, Buffer.from(text), key).toString('base64') }
 }
 
+/** Whether `sig` (bytes) is an Ed25519 signature of `text` by the raw public key `publicKey` (base64). */
+export function ed25519Verify (publicKey, text, sig) {
+  try {
+    const pub = crypto.createPublicKey({ key: Buffer.concat([SPKI_PREFIX, Buffer.from(String(publicKey), 'base64')]), format: 'der', type: 'spki' })
+    return crypto.verify(null, Buffer.from(text), pub, sig)
+  } catch { return false }
+}
+
 /** Whether `a` is a good attestation of `row` under one of `keys` ([{ id, public_key }]). */
 export function verifyAttestation (a, row, keys) {
   if (!a) return 'unsigned'
   if (a.seq !== row.seq || a.kind !== row.kind || a.row_hash !== rowHash(row)) return 'mismatch'
   const k = keys.find((x) => x.id === a.key_id)
   if (!k) return 'unknown_key'
-  try {
-    const pub = crypto.createPublicKey({ key: Buffer.concat([SPKI_PREFIX, Buffer.from(k.public_key, 'base64')]), format: 'der', type: 'spki' })
-    if (!crypto.verify(null, Buffer.from(attestationText(a)), pub, Buffer.from(String(a.sig), 'base64'))) return 'bad_signature'
-  } catch { return 'bad_signature' }
+  if (!ed25519Verify(k.public_key, attestationText(a), Buffer.from(String(a.sig), 'base64'))) return 'bad_signature'
   return a.late ? 'late' : 'ok'
 }
 
@@ -188,7 +201,8 @@ export function attestationOps (svc, attester) {
  * against `keys` (pinned by the caller) or the server's published keys.
  */
 export async function verifyQuilt (client, quilt, { after = 0, keys = null } = {}) {
-  const pinned = keys || (await client.attestationKeys()).keys
+  // The published keys also hold the want-ticket key (tickets.js), which never signs a log row.
+  const pinned = keys || (await client.attestationKeys()).keys.filter((k) => !k.use || k.use === 'attestation')
   const rows = []; const atts = []
   let from = Number(after) || 0
   for (;;) {

package/lib/quilts/block.js

@@ -18,7 +18,7 @@ import { TreeReader, decodeNode, EMPTY_TREE } from './tree.js'
 import { globMatcher } from './claims.js'
 import { theCas } from './cas.js'
 import { fastMerge } from './fastmerge.js'
-import { diffMarkers, gitMarkers } from './conflict-format.js'
+import { diffMarkers, gitMarkers, findMarkers } from './conflict-format.js'
 
 /** How much of a large file is read at a time (10, streaming the cut). */
 export const READ_PIECE = 1024 * 1024
@@ -590,7 +590,8 @@ function settleRecord (block, m) {
 /**
  * The files a move left conflicted (planMerges) that are not settled yet, sorted. A file is settled
  * once its markers are gone (edited, deleted, restored), or, for one kept whole, once it matches
- * the folder's record; a settled one leaves block.conflicts (and block.json is saved).
+ * the folder's record; a settled one leaves block.conflicts (and block.json is saved). Markers of
+ * any kind left in it (its tag edited away, git's typed by hand) keep it open (07 ruling 2026-10-29).
  */
 export function pullConflicts (dir, block) {
   const c = block.conflicts
@@ -600,7 +601,7 @@ export function pullConflicts (dir, block) {
   let dropped = false
   for (const [p, x] of Object.entries(c)) {
     let still = false
-    if (x.tags?.length) { let bytes = null; try { bytes = fs.readFileSync(absOf(dir, p)) } catch {} still = !!bytes && x.tags.some((t) => bytes.includes(Buffer.from(`quilt-conflict ${t}`))) }
+    if (x.tags?.length) { let bytes = null; try { bytes = fs.readFileSync(absOf(dir, p)) } catch {} still = !!bytes && (x.tags.some((t) => bytes.includes(Buffer.from(`quilt-conflict ${t}`))) || !!findMarkers(bytes)) }
     if (!still && x.kind === 'whole') { changed ??= new Set(localChanges(dir, block).map((ch) => ch.path)); still = changed.has(p) }
     if (still) { open.push(p); continue }
     for (const t of x.tags || []) fs.rmSync(savedOurs(dir, t), { force: true })
@@ -612,6 +613,34 @@ export function pullConflicts (dir, block) {
   return open.sort(cmpPath)
 }
 
+/**
+ * As the server refuses it (service.js, 07 ruling 2026-10-29): a conflicted file among `paths` (a
+ * term from the server, or a conflict a move left) that no longer carries its tag but still holds
+ * conflict markers is refused, `markers_left`, naming the file and line. Here too for a sealed
+ * quilt, whose server cannot read the file.
+ */
+function refuseMarkersLeft (dir, block, paths, verb) {
+  for (const p of paths) {
+    const term = block.files[p]?.term
+    const tags = [...(block.conflicts?.[p]?.tags || []), ...(term ? [term.slice(0, 12)] : [])]
+    if (!tags.length) continue
+    let bytes = null
+    try { bytes = fs.readFileSync(absOf(dir, p)) } catch { continue }
+    if (tags.some((t) => bytes.includes(Buffer.from(`quilt-conflict ${t}`)))) continue
+    const m = findMarkers(bytes)
+    if (m) throw Object.assign(new Error(`${p}:${m.line} still holds conflict markers (${m.text}), so it does not settle the conflict: edit every marker block out, or seam resolve ${p} --ours | --theirs, then ${verb}.`), { code: 'markers_left', path: p, line: m.line })
+  }
+}
+
+/** 07 ruling 2026-10-29: markers in a file with no conflict are committed as written, with a warning. */
+function withLocalMarkers (block, changes, r) {
+  const found = changes.filter((c) => c.bytes && !block.files[c.path]?.term).map((c) => ({ c, m: findMarkers(c.bytes) })).filter((x) => x.m)
+  if (!found.length) return r
+  const have = new Set((r.warnings || []).filter((w) => w.kind === 'markers_in_file').map((w) => w.path))
+  const more = found.filter((x) => !have.has(x.c.path)).map((x) => ({ kind: 'markers_in_file', path: x.c.path, line: x.m.line, local: true }))
+  return more.length ? { ...r, warnings: [...(r.warnings || []), ...more] } : r
+}
+
 /** Refuses to commit (or move) while `paths` hold a conflict a move left. */
 function refuseConflicted (open, verb) {
   if (!open.length) return
@@ -782,7 +811,9 @@ export async function commitFolder (client, dir, block, { message, paths = [], a
   if (!block.square && !isLineCheckout(block)) throw new Error('This folder holds one revision, not a line; open a square (seam square open) to commit.')
   const changes = localChanges(dir, block, { paths })
   if (!changes.length) return { nothing: true }
-  refuseConflicted(pullConflicts(dir, block).filter((p) => changes.some((c) => c.path === p)), 'commit')
+  const open = pullConflicts(dir, block).filter((p) => changes.some((c) => c.path === p))
+  refuseMarkersLeft(dir, block, changes.filter((c) => c.status !== 'deleted').map((c) => c.path), 'commit')
+  refuseConflicted(open, 'commit')
   // A clone (a checkout of a line): the first commit opens a square by itself, titled by the
   // message and based on the commit the folder holds, so it undoes nothing main gained since.
   const opened = block.square ? null : await openForCommit(client, dir, block, message)
@@ -820,7 +851,7 @@ export async function commitFolder (client, dir, block, { message, paths = [], a
   block.at = r.square.head
   block.head = r.square.head
   saveBlock(dir, block)
-  const out = withLocalScan(block, changes, allow, r)
+  const out = withLocalMarkers(block, changes, withLocalScan(block, changes, allow, r))
   if (opened) out.opened = opened
   return out
 }
@@ -849,7 +880,9 @@ async function openForCommit (client, dir, block, message) {
  */
 export async function pull (client, dir, block) {
   // As git refuses to pull over unmerged files: the last pull's conflicts are settled first.
-  refuseConflicted(pullConflicts(dir, block), 'pull again')
+  const open = pullConflicts(dir, block)
+  refuseMarkersLeft(dir, block, open, 'pull again')
+  refuseConflicted(open, 'pull again')
   if (block.square) {
     // The square was merged (or abandoned) from elsewhere: the folder goes to its line's tip.
     const sq = await client.square(block.quilt, block.square)
@@ -884,7 +917,9 @@ export async function toLineTip (client, dir, block, line, tip) {
 export async function amendFolder (client, dir, block, { message, paths = [], allow = [] }) {
   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 })
-  refuseConflicted(pullConflicts(dir, block).filter((p) => changes.some((c) => c.path === p)), 'amend')
+  const open = pullConflicts(dir, block).filter((p) => changes.some((c) => c.path === p))
+  refuseMarkersLeft(dir, block, changes.filter((c) => c.status !== 'deleted').map((c) => c.path), 'amend')
+  refuseConflicted(open, 'amend')
   const blobs = changes.filter((c) => c.bytes || c.open).map((c) => c.open ? { kind: 'blob', id: c.blob, size: c.size, open: c.open } : { kind: 'blob', id: c.blob, bytes: block.sealed ? block._codec.seal(c.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' })
@@ -897,7 +932,7 @@ export async function amendFolder (client, dir, block, { message, paths = [], al
   block.at = r.square.head
   block.head = r.square.head
   saveBlock(dir, block)
-  return withLocalScan(block, changes, allow, r)
+  return withLocalMarkers(block, changes, withLocalScan(block, changes, allow, r))
 }
 
 /** The folder's changes as a unified diff against `at` (diff with no revision, in a block). */

package/lib/quilts/claims.js

@@ -2,8 +2,8 @@
 // "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).
+// or archiving the square lets go of it. Merges never check claims, and a claim never refuses work
+// written before it existed: that work commits, and overlapping work still meets at the merge (07).
 import { QuiltError, squareShort } from './errors.js'
 import { uuidv7 } from './ids.js'
 
@@ -200,20 +200,54 @@ export async function liveClaims (store, q, at = Date.now(), idleMs = 0) {
   return out
 }
 
+/** Whether live entry or tree entry `e` holds the same change as `ch` (a put of the same blob and mode, or a delete). */
+const sameChange = (e, ch) => ch.op === 'delete' ? !!e && e.op === 'delete' : !!e && e.op === ch.op && e.blob === ch.blob && (e.mode ?? null) === (ch.mode ?? null)
+
+/**
+ * 06 "Where a claim is checked" (ruling 2026-10-29): whether square `sq`'s change `ch` was written
+ * before claim `c` was granted, so the claim does not refuse it. It was when the square's live work
+ * already held the same change from before the claim's `at` (each live entry carries the time it was
+ * written, `at`; older rows only the row's), or when the square's head already holds it (`held`:
+ * resending it is not a new write).
+ */
+async function writtenBefore (ch, c, live, held) {
+  if (!ch) return false
+  const e = (live?.changes || []).find((x) => x.path === ch.path)
+  if (sameChange(e, ch) && Number(e.at ?? live.at ?? Infinity) < Number(c.at || 0)) return true
+  if (held) {
+    const h = await held(ch.path)
+    if (ch.op === 'delete' ? !h : (h && h.blob === ch.blob && h.mode === ch.mode)) return true
+  }
+  return false
+}
+
 /**
  * Refuses a write to `paths` from square `sq` when another open square on its line claims one.
  * Given the `writer` (a commit, not live work, which repeats), the refusal is also written to the
- * square's log so the writer hears claim.refused (12) wherever it reads events.
+ * square's log so the writer hears claim.refused (12) wherever it reads events. Given the write's
+ * `changes`, a path whose change was written before the claim existed is not refused (06): the
+ * square's live work held it from before the claim's `at`, or (`held(path)`, the head's entry) the
+ * head already has it. `live` is the square's live row when the caller has read it already.
  */
-export async function guardClaims (store, q, sq, paths, at = Date.now(), idleMs = 0, writer = null) {
+export async function guardClaims (store, q, sq, paths, at = Date.now(), idleMs = 0, writer = null, { changes = null, held = null, live } = {}) {
   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, at, idleMs)).filter((c) => !mine.has(c.square_id) && c.line === sq.line)
+  const byPath = changes ? new Map(changes.map((ch) => [ch.path, ch])) : null
   for (const c of others) {
     const m = globMatcher(c.pattern)
-    const hit = paths.find((p) => m(p))
+    let hit = null
+    for (const p of paths) {
+      if (!m(p)) continue
+      if (byPath) {
+        if (live === undefined) live = store.getLive ? await store.getLive(q, sq.id) : null
+        if (await writtenBefore(byPath.get(p), c, live, held)) continue
+      }
+      hit = p
+      break
+    }
     if (hit) {
       if (writer) {
         const pos = queueOf(await store.claimRequests(q), c).findIndex((r) => r.by_square === sq.id)

package/lib/quilts/cli.js

@@ -313,10 +313,10 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         const moved = r.amended.filter((a) => a.paths.length).map((a) => `${a.paths.join(', ')} into ${a.commit_before.slice(0, 12)}`)
         return print(r, `${moved.length ? `Absorbed ${moved.join('; ')} (${r.amended.length} commit(s) rewritten).` : 'Nothing to absorb.'}${r.left_live ? ` Still live: ${r.left_paths.join(', ')}.` : ''}`)
       }
-      // seam square fold [sq] --into sq:<id> | split [sq] <paths,...> <paths,...> | --by claim [--stacked] [--title t]
+      // seam square fold [sq] --into sq:<id> [--no-commit-live] | split [sq] <paths,...> <paths,...> | --by claim [--stacked] [--title t]
       if (sub === 'fold') {
         if (!flags['--into']) throw new Error('Fold into which square? seam square fold [sq:from] --into sq:<id>')
-        const r = await client.fold(needQuilt(), pos[1] || needSquare(), { into: flags['--into'], message })
+        const r = await client.fold(needQuilt(), pos[1] || needSquare(), { into: flags['--into'], message, ...(flags['--no-commit-live'] ? { commit_live: false } : {}) })
         return print(r, describeWrite(r, `Folded ${r.folded.short} into ${r.square.short}:`))
       }
       if (sub === 'split') {

package/lib/quilts/conflict-format.js

@@ -4,9 +4,10 @@
 // side's change laid onto the first side, `ontoFirst`) only the clashing regions are marked and the
 // rest of the file is merged text; a deleted side is an empty side labelled "(deleted by <who>)". Also the `git` format (diff3 markers with the `|||||||` base section, two sides
 // only). Every block's first line carries the term's tag, so a
-// file committed with these markers is still conflicted (service.js, block.js).
+// file committed with these markers is still conflicted (service.js, block.js). findMarkers finds
+// markers of any kind (no tag, an older tag, git's), which never settle a conflict (07 ruling 2026-10-29).
 import { diff3Merge } from 'node-diff3'
-import { hunks, splitLines } from './textdiff.js'
+import { hunks, splitLines, isText } from './textdiff.js'
 
 /** `old` → `now` as `-`/`+`/` ` lines (every line of both, in order). */
 export function lineDiff (old, now) {
@@ -264,3 +265,27 @@ export function resolveMarkers (regions, k) {
   const lines = regions.flatMap((r) => r.ok || r.sides[k].lines)
   return lines.length ? lines.join('\n') + '\n' : ''
 }
+
+// A conflict marker line: exactly seven `<` or `>` (Seam's and git's opening and closing lines), or
+// git's `|||||||` base line, then a space or the line's end. `=======`, `+++++++` and `%%%%%%%`
+// alone are not markers: a markdown underline or a diff's own lines look like them.
+const MARKER = /^(?:<{7}|>{7}|\|{7})(?: |$)/
+const NEEDLES = ['<<<<<<<', '>>>>>>>', '|||||||'].map((s) => Buffer.from(s))
+
+/**
+ * The first conflict marker in a file, as `{ line (1-based), text }`, or null. Markers count only
+ * at the start of a line (a CR before the newline is ignored); a file that is not text (binary,
+ * over 8 MiB) has none. Whatever their tag (the current term's, an older one's, none), markers in
+ * a conflicted file mean it is not settled (07 ruling 2026-10-29; service.js, block.js).
+ */
+export function findMarkers (bytes) {
+  if (!bytes || !bytes.length) return null
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes)
+  if (!NEEDLES.some((n) => buf.includes(n)) || !isText(buf)) return null
+  const lines = buf.toString('utf8').split('\n')
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i].endsWith('\r') ? lines[i].slice(0, -1) : lines[i]
+    if (MARKER.test(l)) return { line: i + 1, text: l.length > 80 ? l.slice(0, 80) + '…' : l }
+  }
+  return null
+}

package/lib/quilts/describe.js

@@ -140,7 +140,10 @@ export function describeWrite (r, verb = 'Done') {
   if (r.conflicted) bits.push(`${r.conflicted} conflicted path${r.conflicted === 1 ? '' : 's'}: ${(r.terms || []).map((t) => `${t.path} (${t.kind})`).join(', ')}`)
   const reused = (r.combined || []).filter((c) => c.how === 'reuse')
   if (reused.length) bits.push(`Settled the way it was settled before: ${reused.map((c) => `${c.path} (by ${c.by})`).join(', ')}`)
-  for (const w of r.warnings || []) bits.push(`Warning: ${w.path}${w.line ? `:${w.line}` : ''} looks like a secret (${w.rule}, ${w.id})${w.local ? ', found on this computer' : ''}`)
+  for (const w of r.warnings || []) {
+    if (w.kind === 'markers_in_file') bits.push(`Warning: ${w.path}:${w.line} holds conflict markers; it was committed as written${w.local ? ' (found on this computer)' : ''}`)
+    else bits.push(`Warning: ${w.path}${w.line ? `:${w.line}` : ''} looks like a secret (${w.rule}, ${w.id})${w.local ? ', found on this computer' : ''}`)
+  }
   return bits.join('\n')
 }
 

package/lib/quilts/tools.js

@@ -138,7 +138,7 @@ export const SEAM_DESCRIPTIONS = {
   seam_events: 'What happened to your work since you last looked: patch.merged (a patch changed files your open square changed, and whether your merge would now conflict), conflict.added (a conflict was kept in your square), square.handoff, square.restacked (your stacked square was moved onto its parent\'s new head or the line, with how many conflicts it now holds), check.requested (you run a check a line names you for: run it on the commit and report with seam_check and its run_key). Pass after (the cursor from the last answer) to get only new ones. Pass wait (seconds, up to 30) to wait for the next one instead of answering at once.',
   seam_events_webhook: 'Has the quilt server POST your events to a URL (signed with HMAC-SHA256 over <timestamp>.<body>, retried 3 times), so you are woken instead of polling: url, events (default all), secret (made for you if left out). url: "off" removes them all. add: true keeps your other webhooks (up to 5); remove: true removes the one at url.',
   seam_absorb: 'Puts your square\'s uncommitted live work into the commit of the square that last changed each file (amending it and rewriting the commits above it), so a fix to commit 2 of 5 needs no manual rebase. Files no commit of the square changed stay live.',
-  seam_fold: 'Folds a square (square) into another square you hold (into): its work becomes one commit there and the square closes. Overlapping changes become conflict markers in the target.',
+  seam_fold: 'Folds a square (square) into another square you hold (into): its work becomes one commit there and the square closes. Live work it shared (seam_live_set) is committed on it first and goes along (commit_live: false refuses with live_work instead). Overlapping changes become conflict markers in the target.',
   seam_split: 'Splits your square: by paths (groups: [[paths], ...]) or by claim (one group per claim on the square that covers a changed path; the claim and its holder go with it). Each group moves to a new square (same base) as one commit; the largest group, and paths no group names, stay in this square. stacked: true chains the new squares on this one in order instead of opening them side by side.',
   seam_log: 'History, newest first: rev (default main, or your square, or a..b), paths to limit it, limit (default 20). follow: true with one path follows the file through its renames; search: "<text>" keeps only commits that changed how many times the text appears (git log -S); match: "<regex>" keeps commits whose added or removed lines match (git log -G). message (with message_regex, ignore_case) filters on the commit message (git log --grep); author (member id or part of a name), on_behalf_of, task, since and until (an ISO date, or 2h, 3d, 1w) filter on who, what for and when. group_by (author, on_behalf_of, task, tool) gives counts with lines added and removed instead of commits; graph: true names the square each merge brought in; include_hidden: true shows a square\'s commits replaced by an amend. When there is more, pass the answer\'s cursor for the next page. Each patch on main is one line\'s merge. With one path on a line, existed says whether it was ever there and, if it is gone now, last_present is the last patch it was there in.',
   seam_describe: 'Names a revision (rev, default main) by the nearest tag behind it: v1.0 on the tag itself, v1.0-3-<commit> three commits past it, the commit alone when no tag is behind it.',
@@ -304,7 +304,7 @@ export const SEAM_INPUTS = {
   seam_events: { quilt: QUILT, after: z.number().int().min(0).optional(), wait: z.number().int().min(0).max(30).optional(), kinds: z.array(z.enum(['patch.merged', 'patch.reverted', 'conflict.added', 'square.handoff', 'square.restacked', 'check.requested', 'check.cancelled', 'check.culprit', 'check.verdict', 'watch.triggered', 'policy.needed', 'review.comment', 'review.decision', 'review.requested', 'review.stale', 'claim.granted', 'claim.refused', 'claim.expired', 'claim.handoff', 'export.state'])).optional() },
   seam_events_webhook: { quilt: QUILT, url: z.string().max(2000), events: z.array(z.enum(['patch.merged', 'patch.reverted', 'conflict.added', 'square.handoff', 'square.restacked', 'check.requested', 'check.cancelled', 'check.culprit', 'check.verdict', 'watch.triggered', 'policy.needed', 'review.comment', 'review.decision', 'review.requested', 'review.stale', 'claim.granted', 'claim.refused', 'claim.expired', 'claim.handoff', 'export.state'])).optional(), secret: z.string().min(16).max(200).optional(), add: z.boolean().optional(), remove: z.boolean().optional() },
   seam_absorb: { quilt: QUILT, square: SQUARE },
-  seam_fold: { quilt: QUILT, square: SQUARE, into: z.string().max(100).describe('The square (sq:…) that takes the work'), message: z.string().max(65536).optional() },
+  seam_fold: { quilt: QUILT, square: SQUARE, into: z.string().max(100).describe('The square (sq:…) that takes the work'), message: z.string().max(65536).optional(), commit_live: z.boolean().optional().describe('Default true: the square\'s shared live work is committed on it first and folded with it; false refuses (live_work) while it has any') },
   seam_split: { quilt: QUILT, square: SQUARE, by: z.enum(['paths', 'claim']).optional().describe('paths (the default) or claim'), groups: z.array(z.array(z.string().max(1000)).min(1).max(2000)).min(1).max(20).optional().describe('Paths (files or directories) per new square, for by: paths'), titles: z.array(z.string().max(200)).max(20).optional(), stacked: z.boolean().optional().describe('Chain the new squares on this one in order') },
   seam_merge: { quilt: QUILT, square: SQUARE, from: z.string().max(200).optional().describe('Merge this square (sq:…) or revision into your square instead of merging your square into a line'), into: z.string().max(100).optional().describe('The line, default main'), message: z.string().max(65536).optional(), dry_run: z.boolean().optional(), on_conflict: z.enum(['rebase', 'leave']).optional(), commit_live: z.boolean().optional().describe('Default true: your square\'s shared live work (seam_live_set) is committed first and merged with it; false merges the committed head as it stands') },
   seam_rebase: { quilt: QUILT, square: SQUARE, onto: REV },
@@ -503,7 +503,7 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
         return `${moved.length ? `Absorbed ${moved.join('; ')} (${r.amended.length} commit(s) rewritten).` : 'Nothing to absorb.'}${r.left_live ? ` Still live: ${r.left_paths.join(', ')}.` : ''}` + (r.amended.length ? await sync(r.square.head, r.square) : '')
       }
       case 'seam_fold': {
-        const r = await client.fold(needQuilt(), needSquare(), { into: args.into, message: args.message, ...(inFolder ? { expect_head: block.head } : {}) })
+        const r = await client.fold(needQuilt(), needSquare(), { into: args.into, message: args.message, ...(args.commit_live === false ? { commit_live: false } : {}), ...(inFolder ? { expect_head: block.head } : {}) })
         return describeWrite(r, `Folded ${r.folded.short} into ${r.square.short}:`)
       }
       case 'seam_split': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyquilt/seam",
-  "version": "0.142.0",
+  "version": "0.143.0",
   "description": "seam: Seam's command. Git's verbs for source control that runs on the server, built for many agents and people at once.",
   "license": "UNLICENSED",
   "type": "module",