@heyquilt/seam 0.26.0 → 0.130.0

package/lib/quilts/cli.js

@@ -6,15 +6,22 @@ import path from 'node:path'
 import fs from 'node:fs'
 import os from 'node:os'
 import { quiltClient } from './client.js'
-import { runChecks } from './runner.js'
-import { findBlock, checkout, status as blockStatus, commitFolder, amendFolder, syncTo, localDiff, saveBlock, restore, reset, clean, localChanges } from './block.js'
-import { describeLog, describeShow, describeDiff, describeBlame, describeStatus, describeMerge, describeWrite, describeSquare, describeSquareStatus, describeEvents, describeTag, describeRelease, describeImport, describeImportRecord, describeRestore, describeReset, describeClean, describeLive, describeClaims, describeResolutions, describeLiveSet, describeMergeBase, describeGrep, describeBisect, describeCheck, describeReviews, describeReviewed, describeSquareCheck, describePolicy, describeKeys, describeTokens, describeNewToken, describeCheckRuns, describeRerun } from './describe.js'
+import { runChecks, readRunnerConfig, listenForWork } from './runner.js'
+import { startDaemon, askDaemon } from './daemon.js'
+import { rebuild as rebuildBlock, conflictStyle } from './block.js'
+import { describeRebuild, describeOpened } from './describe.js'
+import { findBlock, checkout, status as blockStatus, commitFolder, amendFolder, syncTo, localDiff, saveBlock, pull, toLineTip, restore, reset, clean, localChanges, bytesOf, livePatch } from './block.js'
+import { describeLog, describeShow, describeDiff, describeBlame, describeStatus, describeMerge, describeWrite, describeSquare, describeSquareStatus, describeEvents, describeTag, describeRelease, describeImport, describeImportRecord, describeRestore, describeReset, describeClean, describeLive, describeClaims, describeHandoff, describeFinished, describeResolutions, describeLiveSet, describeLiveJoin, describeMergeBase, describeStack, describeStackDiff, describeGrep, describeBisect, describeCheck, describeReviews, describeInterdiff, describeReviewed, describeSquareCheck, describePolicy, describeKeys, describeTokens, describeNewToken, describeBlock, describeBlocks, describeProtections, describeTeams, describeAccess, describeRedacted, describeRedactions, describeMetrics, describeSquarePolicy, describePolicyVersions, describeOrg, describeOrgs, describeOrgTeams, describeCheckRuns, describeRerun, describeAncestor, describeContains, describePipeline, describeWatches, describeSearch, describePublicReads } from './describe.js'
+import { verifyQuilt, describeVerify } from './attest.js'
+import { confirmWithLocalKey } from './linepolicy.js'
+import { describeAgentToken, describeAgentTokens } from './agent-tokens.js'
+import { codecFor, catBytes, startSealed, startSealedIfNew, grantSealed, rotateSealed, ensureSealingKey, describeSeal } from './sealed.js'
 import { signWithLocalKey, localKey, makeLocalKey, signingKeyFile } from './signing.js'
 
 export const API_URL = 'https://api.seam.heyquilt.com'
 
 /** The verbs `seam` answers. */
-export const SEAM_VERBS = new Set(['quilts', 'square', 'checkout', 'status', 'commit', 'log', 'show', 'diff', 'merge', 'rebase', 'revert', 'cherry-pick', 'blame', 'resolve', 'cat', 'ls', 'import', 'export', 'events', 'tag', 'release', 'line', 'restore', 'reset', 'clean', 'live', 'bisect', 'grep', 'describe', 'merge-base', 'claim', 'unclaim', 'check', 'checks', 'resolutions', 'review', 'sign', 'key', 'token', 'runner'])
+export const SEAM_VERBS = new Set(['quilts', 'square', 'checkout', 'status', 'commit', 'log', 'show', 'diff', 'merge', 'rebase', 'revert', 'cherry-pick', 'blame', 'resolve', 'cat', 'ls', 'import', 'export', 'events', 'tag', 'release', 'line', 'restore', 'reset', 'clean', 'live', 'bisect', 'grep', 'describe', 'merge-base', 'stack', 'claim', 'unclaim', 'check', 'checks', 'resolutions', 'review', 'sign', 'key', 'token', 'block', 'runner', 'protect', 'team', 'verify', 'redact', 'metrics', 'seal', 'policy', 'org', 'watch', 'search', 'contains', 'daemon', 'clone', 'pull'])
 
 /** `ci=agent:ci,lint=agent:a+agent:b` → { ci: ['agent:ci'], lint: ['agent:a', 'agent:b'] }; `none` clears them. */
 export function parseRunners (text) {
@@ -41,8 +48,42 @@ export function parseTiers (text) {
 }
 
 /** `test/**,**\/*.test.js` → a list; `none` clears it. */
+/** --pre-merge-checks on|off */
+export function parseOnOff (text, flag) {
+  if (text === 'on' || text === 'true') return true
+  if (text === 'off' || text === 'false') return false
+  throw new Error(`${flag}: on or off (got ${text})`)
+}
+
+/** `db_branch=supabase:abcd,infra=v2` → { db_branch: 'supabase:abcd', infra: 'v2' } (square open --stack). */
+export function parseStackFlag (text) {
+  const out = {}
+  for (const part of String(text).split(',').map((s) => s.trim()).filter(Boolean)) {
+    const i = part.indexOf('=')
+    if (i < 1) throw new Error(`--stack: key=value pairs separated by commas, e.g. db_branch=supabase:abcd (got ${part})`)
+    out[part.slice(0, i).trim()] = part.slice(i + 1).trim()
+  }
+  return out
+}
+
+/** `10/120` → { patches: 10, seconds: 120 }; `none` → null (a batch per merge). */
+export const parseBatch = (text) => {
+  if (text === 'none') return null
+  const m = /^(\d+)\/(\d+)$/.exec(text)
+  if (!m) throw new Error(`--batch: <patches>/<seconds>, e.g. 10/120, or none (got ${text})`)
+  return { patches: Number(m[1]), seconds: Number(m[2]) }
+}
 export const parseGlobs = (text) => text === 'none' ? null : text.split(',').map((x) => x.trim()).filter(Boolean)
-const VALUE_FLAGS = new Set(['-m', '--quilts', '--message', '-n', '--max-count', '--into', '--onto', '--on-conflict', '--quilt', '--square', '--dir', '--line', '--task', '--level', '--title', '--slug', '--format', '--expect-tip', '--side', '--file', '--batch', '--to', '--note', '--after', '--kinds', '--webhook', '--secret', '--branch', '--from', '-S', '--run', '--marks', '--patch', '--on', '--path', '--checks', '--name', '--public-key', '--interval', '--credential', '--as', '--runners', '--run-key', '--state', '--tier', '--tiers', '--tests', '--ci-config', '--commit', '--check', '--log-url'])
+// seam token agent new --checks [true|false] --rate commit_rate=10,merge_rate=5 (11.5, 11.9).
+export function agentTokenExtras (flags) {
+  const out = {}
+  const c = flags['--checks']
+  if (c != null) out.checks = c === true || c === 'true' ? true : c === 'false' ? false : c
+  if (flags['--rate']) out.rate = Object.fromEntries(String(flags['--rate']).split(',').map((x) => x.trim()).filter(Boolean).map((x) => { const [k, v] = x.split('='); return [k.trim(), Number(v)] }))
+  return out
+}
+
+const VALUE_FLAGS = new Set(['--authors', '--debounce', '-m', '--installation', '--quilts', '--message', '-n', '--max-count', '--into', '--onto', '--on-conflict', '--quilt', '--square', '--dir', '--line', '--task', '--level', '--title', '--slug', '--format', '--expect-tip', '--side', '--file', '--batch', '--to', '--note', '--after', '--kinds', '--webhook', '--secret', '--branch', '--from', '-S', '--run', '--marks', '--patch', '--on', '--path', '--checks', '--name', '--public-key', '--interval', '--credential', '--as', '--runners', '--run-key', '--state', '--tier', '--tiers', '--tests', '--ci-config', '--commit', '--check', '--log-url', '--at', '--human-only', '--keys', '--reason', '--without', '--allow', '--rules', '--org', '--role', '--agent', '--paths', '--squares', '--hours', '--pre-merge-checks', '--by', '--mode', '--machine', '--add', '--remove', '--exclude', '--max-fetch-bytes', '--expires', '--out', '--auto-combine', '--needs-stack', '--monotonic-stack', '--migrations-in-order', '--rule', '--bisect-width', '--classes', '--min-lines', '-L', '--ignore-rev', '--reverse', '--grep', '-G', '--author', '--on-behalf-of', '--since', '--until', '--group-by', '--cursor', '-U', '--unified', '--renames', '--config', '--only', '--listen', '--idle-exit', '--wait', '--days', '--with', '--stack', '--scope', '--suggest', '--to-line', '--approval-survives', '--stack-defaults', '--stack-keys', '--lfs-url', '--lfs-threshold', '--offset', '--length', '--rate'])
 
 export function parse (argv) {
   const pos = []; const flags = {}; const paths = []
@@ -53,7 +94,8 @@ export function parse (argv) {
     if (a === '--') { rest = true; continue }
     const eq = a.match(/^(--[\w-]+)=(.*)$/)
     if (eq) { flags[eq[1]] = eq[2]; continue }
-    if (VALUE_FLAGS.has(a)) { flags[a] = argv[++i]; continue }
+    // A value flag never takes the next flag as its value (`protect add … --exclude --quilt q`): it is then on.
+    if (VALUE_FLAGS.has(a)) { const v = argv[i + 1]; if (v === undefined || /^--[\w-]/.test(v)) flags[a] = true; else { flags[a] = v; i++ } continue }
     if (/^-n\d+$/.test(a)) { flags['-n'] = a.slice(2); continue }
     if (a.startsWith('-') && a.length > 1) { flags[a] = true; continue }
     pos.push(a)
@@ -70,11 +112,15 @@ export function connect (block, token) {
 }
 
 /** Runs one verb; returns the text to print (or JSON with --json). `token` is the signed-in person's, when there is one. */
-export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, out = (s) => process.stdout.write(s.endsWith('\n') ? s : s + '\n') } = {}) {
+export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, out = (s) => process.stdout.write(s.endsWith('\n') ? s : s + '\n'), stop = () => false } = {}) {
   const { pos, flags, paths } = parse(argv)
   const found = findBlock(cwd)
   const block = found?.block
-  const { client, api } = connect(block, token)
+  // Reading an archive needs no server and no sign-in (14, exit path).
+  const offline = cmd === 'export' && (pos[0] === 'check' || pos[0] === 'extract' || (pos[0] === 'git' && !!flags['--from']))
+  const { client, api } = offline ? { client: null, api: null } : connect(block, token)
+  // A sealed quilt's block opens and seals its files with the key this computer holds (11.11).
+  if (!offline && block?.sealed && !block._codec) block._codec = await codecFor(client, block.quilt)
   const quilt = flags['--quilt'] || block?.quilt
   const needQuilt = () => { if (!quilt) throw new Error('Name the quilt with --quilt <slug or id> (or run this inside a block folder).'); return quilt }
   const needSquare = () => { const s = flags['--square'] || block?.square; if (!s) throw new Error('No square here: run this in a block folder, or pass --square sq:<id>.'); return s }
@@ -84,8 +130,65 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
 
   switch (cmd) {
     case 'quilts': {
-      if (pos[0] === 'new') { const q = await client.createQuilt({ slug: pos[1], name: flags['--title'] }); return print(q, `Made quilt ${q.slug} (${q.id}).`) }
-      if (pos[0] === 'add') { const r = await client.addMember(needQuilt(), { member_id: pos[1], level: flags['--level'] || 'write' }); return print(r, `${r.member_id}: ${r.level || 'removed'}`) }
+      if (pos[0] === 'new') {
+        const q = await client.createQuilt({ slug: pos[1], name: flags['--title'], ...(flags['--sealed'] ? { sealed: true } : {}), ...(flags['--org'] ? { org: flags['--org'] } : {}) })
+        if (!flags['--sealed']) return print(q, `Made quilt ${q.slug} (${q.id}).`)
+        // Its key is made here and wrapped for this computer; the server never holds it.
+        await startSealed(client, q.id, q.owner)
+        return print(q, `Made sealed quilt ${q.slug} (${q.id}). Its key is on this computer only: give it to other members with seam seal grant <member id>.`)
+      }
+      if (pos[0] === 'agents-make-lines') {
+        if (!['on', 'off'].includes(pos[1])) throw new Error('seam quilts agents-make-lines on|off --quilt <q>')
+        const r = await client.setAgentsMakeLines(needQuilt(), pos[1] === 'on')
+        return print(r, r.agents_make_lines ? `Agents may make lines, tags and releases in ${r.quilt}.` : `Only people make lines, tags and releases in ${r.quilt}.`)
+      }
+      if (pos[0] === 'move') {
+        if (!flags['--org']) throw new Error('seam quilts move --quilt <q> --org <org>')
+        const r = await client.setQuiltOwner(needQuilt(), flags['--org'])
+        return print(r, `${r.quilt} now belongs to ${r.org}.`)
+      }
+      if (pos[0] === 'sealed') {
+        if (!['on', 'off'].includes(pos[1])) throw new Error('seam quilts sealed on|off --quilt <q>')
+        const r = await client.setSealed(needQuilt(), pos[1] === 'on')
+        if (!r.sealed) return print(r, `${r.quilt} is not sealed: the server reads its files.`)
+        // As for seam quilts new --sealed: the key is made here and wrapped for this computer.
+        await startSealedIfNew(client, r.quilt_id)
+        return print(r, `${r.quilt} is sealed. Its key is on this computer only: give it to other members with seam seal grant <member id>.`)
+      }
+      if (pos[0] === 'public') {
+        if (!['on', 'off'].includes(pos[1])) throw new Error('seam quilts public on|off --quilt <q>')
+        const r = await client.setPublic(needQuilt(), pos[1] === 'on')
+        return print(r, r.public ? `${r.quilt} is public: anyone can read it, signed in or not. Share ${r.page || `${api}/v1/quilts/${r.quilt_id}`}` : `${r.quilt} is private again.`)
+      }
+      if (pos[0] === 'infra-paths') {
+        // seam quilts infra-paths <glob,glob> | default | none: what seam stack derives infra from.
+        if (!pos[1]) throw new Error('seam quilts infra-paths <glob,glob>|default|none --quilt <q>')
+        const r = await client.setInfraPaths(needQuilt(), pos[1] === 'none' ? null : pos[1] === 'default' ? 'default' : parseGlobs(pos[1]))
+        return print(r, r.infra_paths ? `${r.quilt} derives infra from ${r.infra_paths.join(', ')}.` : `${r.quilt} derives no infra.`)
+      }
+      if (pos[0] === 'public-reads') {
+        // seam quilts public-reads: what readers with no sign-in fetched, per hashed address and 10 minutes (11.10).
+        const r = await client.publicReads(needQuilt())
+        return print(r, describePublicReads(r))
+      }
+      if (pos[0] === 'owner-idle-hours') {
+        // seam quilts owner-idle-hours <1..24> | default: how long an owner claim holds after its square's last write there.
+        if (!pos[1]) throw new Error('seam quilts owner-idle-hours <1..24>|default --quilt <q>')
+        const r = await client.setOwnerIdleHours(needQuilt(), pos[1] === 'default' ? null : Number(pos[1]))
+        return print(r, `${r.quilt}'s owner claims let go after ${r.owner_idle_hours ?? 2} quiet hours.`)
+      }
+      if (pos[0] === 'migrations-dir') {
+        // seam quilts migrations-dir <folder> | none | default: where seam stack derives db_migration from.
+        if (!pos[1]) throw new Error('seam quilts migrations-dir <folder>|none|default --quilt <q>')
+        const r = await client.setMigrationsDir(needQuilt(), pos[1] === 'none' ? '' : pos[1] === 'default' ? null : pos[1])
+        return print(r, r.migrations_dir === null ? `${r.quilt} derives db_migration from supabase/migrations.` : r.migrations_dir ? `${r.quilt} derives db_migration from ${r.migrations_dir}.` : `${r.quilt} derives no db_migration.`)
+      }
+      if (pos[0] === 'secret-scanning') {
+        if (!pos[1]) { const q = await client.quilt(needQuilt()); return print({ secret_scanning: q.secret_scanning }, `Secret scanning on ${q.slug}: ${q.secret_scanning}.`) }
+        const r = await client.setSecretScanning(needQuilt(), pos[1])
+        return print(r, `Secret scanning on ${r.quilt}: ${r.secret_scanning}.`)
+      }
+      if (pos[0] === 'add') { const r = await client.addMember(needQuilt(), { ...(String(pos[1] || '').includes('@') ? { email: pos[1] } : { member_id: pos[1] }), level: flags['--level'] || 'write' }); return print(r, r.invited ? `Invited ${r.email} (${r.level}): ${r.emailed ? 'Seam emailed them a link' : `send them ${r.sign_up}`}. They are in the quilt from their first sign-in.` : `${r.member_id}: ${r.level || 'removed'}`) }
       if (pos[0] === 'show') { const q = await client.quilt(pos[1] || needQuilt()); return print(q, `${q.slug} (${q.id})\n${q.lines.map((l) => `  ${l.name}: ${l.patch_count} patches, tip ${l.tip ? l.tip.slice(0, 12) : '(empty)'}`).join('\n')}`) }
       const list = await client.quilts()
       return print(list, list.length ? list.map((q) => `${q.slug}  ${q.id}  (${q.level})`).join('\n') : 'No quilts yet.')
@@ -114,12 +217,18 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         const tiers = flags['--tiers'] === undefined ? undefined : parseTiers(String(flags['--tiers']))
         const tests = flags['--tests'] === undefined ? undefined : parseGlobs(String(flags['--tests']))
         const ciConfig = flags['--ci-config'] === undefined ? undefined : parseGlobs(String(flags['--ci-config']))
-        const extra = { ...(tiers !== undefined ? { tiers } : {}), ...(tests !== undefined ? { tests } : {}), ...(ciConfig !== undefined ? { ci_config: ciConfig } : {}) }
+        // --human-only "supabase/migrations/**": paths agents read and never change on this line
+        const humanOnly = flags['--human-only'] === undefined ? undefined : parseGlobs(String(flags['--human-only']))
+        // --only deploy=src/**+!src/vault/**: the paths each check is about (it runs only when they change)
+        const only = flags['--only'] === undefined ? undefined : parseRunners(String(flags['--only']))
+        // --rules <file.json>: { rules, classes?, mode? }, what each kind of change needs (13)
+        const ruleFile = flags['--rules'] ? JSON.parse(fs.readFileSync(path.resolve(cwd, flags['--rules']), 'utf8')) : null
+        const extra = { ...(tiers !== undefined ? { tiers } : {}), ...(tests !== undefined ? { tests } : {}), ...(ciConfig !== undefined ? { ci_config: ciConfig } : {}), ...(humanOnly !== undefined ? { human_only: humanOnly } : {}), ...(only !== undefined ? { only } : {}), ...(ruleFile ? (Array.isArray(ruleFile) ? { rules: ruleFile } : ruleFile) : {}), ...(flags['--pre-merge-checks'] !== undefined ? { pre_merge_checks: parseOnOff(String(flags['--pre-merge-checks']), '--pre-merge-checks') } : {}), ...(flags['--auto-combine'] !== undefined ? { auto_combine: flags['--auto-combine'] } : {}), ...(flags['--approval-survives'] !== undefined ? { approval_survives: flags['--approval-survives'] === 'default' ? null : String(flags['--approval-survives']) } : {}), ...(flags['--batch'] !== undefined ? { batch: parseBatch(String(flags['--batch'])) } : {}), ...(flags['--bisect-width'] !== undefined ? { bisect_width: Number(flags['--bisect-width']) } : {}), ...(flags['--needs-stack'] !== undefined ? { needs_stack: ['none', true].includes(flags['--needs-stack']) ? null : String(flags['--needs-stack']).split(',').map((s) => s.trim()).filter(Boolean) } : {}), ...(flags['--monotonic-stack'] !== undefined ? { monotonic_stack: ['none', true].includes(flags['--monotonic-stack']) ? null : String(flags['--monotonic-stack']).split(',').map((s) => s.trim()).filter(Boolean) } : {}), ...(flags['--migrations-in-order'] !== undefined ? { migrations_in_order: parseOnOff(String(flags['--migrations-in-order']), '--migrations-in-order') } : {}), ...(flags['--stack-defaults'] !== undefined ? { stack_defaults: ['none', true].includes(flags['--stack-defaults']) ? null : parseStackFlag(flags['--stack-defaults']) } : {}) }
         if (pos[2] === undefined && checks === undefined && runners === undefined && !Object.keys(extra).length) { const p = await client.linePolicy(needQuilt(), pos[1]); return print(p, describePolicy(p)) }
         const p = await client.setLinePolicy(needQuilt(), pos[1], { ...(pos[2] !== undefined ? { approvals: Number(pos[2]) } : {}), ...(checks ? { checks } : {}), ...(runners !== undefined ? { runners } : {}), ...extra })
         return print(p, describePolicy(p))
       }
-      throw new Error('seam line [list] | new release/<name> [--from <rev>] | freeze <line> | unfreeze <line> | require <line> [<approvals>] [--checks ci,lint] [--runners ci=<member>] [--tiers e2e=post_merge] [--tests test/**] [--ci-config ops/**]')
+      throw new Error('seam line [list] | new release/<name> [--from <rev>] | freeze <line> | unfreeze <line> | require <line> [<approvals>] [--checks ci,lint] [--runners ci=<member>] [--tiers e2e=post_merge] [--tests test/**] [--ci-config ops/**] [--human-only supabase/migrations/**] [--pre-merge-checks on|off] [--approval-survives none|whitespace|comment-only|docs|default] [--auto-combine lines|additive|whitespace] [--batch 10/120] [--bisect-width 8] [--needs-stack db_branch,db_migration|none] [--monotonic-stack db_migration|none] [--migrations-in-order on|off]')
     }
     case 'tag':
     case 'release': {
@@ -135,39 +244,76 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       return print(x, `Released ${x.name} at ${where(x)}. Read it as tag:${x.name}.`)
     }
     case 'events': {
-      // seam events [--after n] [--kinds a,b] | --webhook <url> [--secret s] [--kinds a,b] | --webhook off
+      // seam events [--after n] [--kinds a,b] [--wait seconds | --follow] | --webhook <url> [--add | --remove] [--secret s] [--kinds a,b] | --webhook off
       const kinds = flags['--kinds'] ? String(flags['--kinds']).split(',') : undefined
       if (flags['--webhook']) {
         const off = flags['--webhook'] === 'off'
-        const r = await client.subscribe(needQuilt(), off ? { url: null } : { url: flags['--webhook'], secret: flags['--secret'], events: kinds })
-        return print(r, off ? 'Webhook removed.' : `Events (${r.events.join(', ')}) now POST to ${r.url}${r.secret ? `\nSigning secret (shown once): ${r.secret}` : ''}`)
+        if (!off && flags['--remove']) { const r = await client.subscribe(needQuilt(), { url: flags['--webhook'], remove: true }); return print(r, `Webhook to ${r.url} removed.${r.hooks.length ? ` Still posting to ${r.hooks.map((h) => h.url).join(', ')}.` : ''}`) }
+        const r = await client.subscribe(needQuilt(), off ? { url: null } : { url: flags['--webhook'], secret: flags['--secret'], events: kinds, ...(flags['--add'] ? { add: true } : {}) })
+        return print(r, off ? 'Webhooks removed.' : `Events (${r.events.join(', ')}) now POST to ${r.url}${r.hooks?.length > 1 ? ` (and ${r.hooks.length - 1} more webhook(s) of yours)` : ''}${r.secret ? `\nSigning secret (shown once): ${r.secret}` : ''}`)
+      }
+      if (flags['--follow']) {
+        // Prints each event as it arrives (a loop of 30-second long-polls) until stopped; --json: one line per event.
+        let after = flags['--after']
+        while (!stop()) {
+          const r = await client.events(needQuilt(), { after, kinds, wait: 30 })
+          if (r.events.length) out(json ? r.events.map((e) => JSON.stringify(e)).join('\n') : describeEvents(r))
+          after = r.after
+        }
+        return
       }
-      const r = await client.events(needQuilt(), { after: flags['--after'], kinds })
+      const r = await client.events(needQuilt(), { after: flags['--after'], kinds, ...(flags['--wait'] ? { wait: flags['--wait'] } : {}) })
       return print(r, describeEvents(r))
     }
     case 'square': {
       const sub = pos[0] || 'list'
       if (sub === 'open') {
-        const sq = await client.openSquare(needQuilt(), { title: pos.slice(1).join(' ') || flags['--title'] || 'untitled', line: flags['--line'], task_id: flags['--task'], ...(flags['--on'] ? { on: flags['--on'] } : {}) })
+        const sq = await client.openSquare(needQuilt(), { title: pos.slice(1).join(' ') || flags['--title'] || 'untitled', line: flags['--line'], task_id: flags['--task'], ...(flags['--on'] ? { on: flags['--on'] } : {}), ...(flags['--another'] ? { another: true } : {}), ...(flags['--stack-keys'] || typeof flags['--stack'] === 'string' ? { stack: parseStackFlag(flags['--stack-keys'] || flags['--stack']) } : {}) })
         let text = describeSquare(sq)
         if (flags['--dir']) {
           const dir = path.resolve(cwd, flags['--dir'])
-          await checkout(client, { quilt: needQuilt(), square: sq.id, paths, dir, api })
+          await checkout(client, { quilt: needQuilt(), square: sq.id, squareRow: sq, paths, dir, api, codec: await codecFor(client, needQuilt()) })
           text += `\nChecked out into ${dir}.`
         }
         return print(sq, text)
       }
-      // seam square handoff [sq] --to <member> [--note text] | abandon [sq] | reopen [sq]
+      // seam square handoff [sq] --to <member> [--note text] | abandon [sq] [--cascade] | reopen [sq] | archive [sq] | unarchive [sq] | hide [sq] | unhide [sq] | edit [sq] [--title t] [--task id] [--line name] | share [sq] --with <member> | unshare [sq] --with <member> | reparent [sq] --onto <sq>|--line
       if (sub === 'handoff') { const sq = await client.handoff(needQuilt(), pos[1] || needSquare(), { to: flags['--to'], note: flags['--note'] }); return print(sq, `Handed ${sq.short || sq.id} to ${sq.holder}.`) }
-      if (sub === 'abandon') { const sq = await client.abandon(needQuilt(), pos[1] || needSquare()); return print(sq, `Abandoned ${sq.short || sq.id}; seam square reopen brings it back.`) }
+      if (sub === 'abandon') { const sq = await client.abandon(needQuilt(), pos[1] || needSquare(), flags['--cascade'] ? { children: 'cascade' } : {}); return print(sq, `Abandoned ${sq.short || sq.id}${sq.cascaded ? ` and the ${sq.cascaded.length} square(s) of yours stacked on it` : ''}; seam square reopen brings it back.`) }
       // seam square merged [sq] --as <git sha>: closes a square whose work went into git by hand (admins, during a follow)
       if (sub === 'merged') {
         if (!flags['--as']) throw new Error('Which git commit holds the work? seam square merged [sq:id] --as <sha>')
         const sq = await client.squareMerged(needQuilt(), pos[1] || needSquare(), { git_sha: flags['--as'] })
         return print(sq, `${sq.short || sq.id} is merged by hand: patch ${sq.merged.patch_no} on ${sq.merged.line} (git ${sq.merged.git_sha.slice(0, 12)}).`)
       }
+      if (sub === 'edit') {
+        const body = { ...(flags['--title'] !== undefined ? { title: flags['--title'] } : {}), ...(flags['--task'] !== undefined ? { task_id: flags['--task'] === 'none' ? null : flags['--task'] } : {}), ...(flags['--line'] !== undefined ? { line: flags['--line'] } : {}) }
+        if (!Object.keys(body).length) throw new Error('What to change? seam square edit [sq:id] --title "…" | --task <id|none> | --line <name>')
+        const sq = await client.editSquare(needQuilt(), pos[1] || needSquare(), body)
+        return print(sq, `Edited ${describeSquare(sq)}.`)
+      }
+      if (sub === 'reparent') {
+        if (!flags['--onto'] && !flags['--line']) throw new Error('Onto what? seam square reparent [sq:id] --onto <sq:id> | --line')
+        const r = await client.reparent(needQuilt(), pos[1] || needSquare(), { to: flags['--line'] ? 'line' : flags['--onto'] })
+        return print(r, r.noop ? 'Already there.' : `${r.square.short || r.square.id} now ${r.reparented.to ? `stacks on ${r.reparented.to}` : `sits on ${r.square.line}'s tip`}${r.conflicted ? `, with ${r.conflicted} conflict(s) to settle` : ''}. Run seam checkout ${r.square.short} to bring a folder there.`)
+      }
+      if (sub === 'share' || sub === 'unshare') {
+        if (!flags['--with']) throw new Error(`With whom? seam square ${sub} [sq:id] --with <member>`)
+        const sq = await client[sub](needQuilt(), pos[1] || needSquare(), { member: flags['--with'] })
+        return print(sq, `${sq.short || sq.id}'s writers: ${(sq.writers || []).join(', ') || 'only its holder'}.`)
+      }
+      if (sub === 'archive') { const sq = await client.archive(needQuilt(), pos[1] || needSquare()); return print(sq, `Archived ${sq.short || sq.id}: its claims are released and seam squares --archived lists it. A commit to it, or seam square unarchive, wakes it.`) }
+      if (sub === 'unarchive') { const sq = await client.unarchive(needQuilt(), pos[1] || needSquare()); return print(sq, `${sq.short || sq.id} is awake again; its claims were not restored.`) }
+      if (sub === 'hide') { const sq = await client.hide(needQuilt(), pos[1] || needSquare()); return print(sq, `Hid ${sq.short || sq.id}; it stays open, and seam squares --hidden lists it.`) }
+      if (sub === 'unhide') { const sq = await client.unhide(needQuilt(), pos[1] || needSquare()); return print(sq, `${sq.short || sq.id} is listed again.`) }
       if (sub === 'reopen') { const sq = await client.reopen(needQuilt(), pos[1] || needSquare()); return print(sq, `Reopened ${sq.short || sq.id}; you hold it.`) }
-      // seam square fold [sq] --into sq:<id> | split [sq] <paths,...> <paths,...> [--title t]
+      // seam square absorb [sq]: live work into the commit of the square that last changed each file
+      if (sub === 'absorb') {
+        const r = await client.absorb(needQuilt(), pos[1] || needSquare(), {})
+        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]
       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 })
@@ -176,16 +322,36 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       if (sub === 'split') {
         const own = pos[1] && pos[1].startsWith('sq:')
         const groups = pos.slice(own ? 2 : 1).map((g) => g.split(',').filter(Boolean))
-        if (!groups.length) throw new Error('Split by which paths? seam square split [sq] docs,README.md src (one group per new square)')
-        const r = await client.split(needQuilt(), own ? pos[1] : needSquare(), { by: 'paths', groups, ...(flags['--title'] ? { titles: [flags['--title']] } : {}) })
+        const by = flags['--by'] || 'paths'
+        if (by === 'paths' && !groups.length) throw new Error('Split by which paths? seam square split [sq] docs,README.md src (one group per new square), or --by claim')
+        const r = await client.split(needQuilt(), own ? pos[1] : needSquare(), { by, ...(by === 'paths' ? { groups } : {}), ...(flags['--stacked'] ? { stacked: true } : {}), ...(flags['--title'] ? { titles: [flags['--title']] } : {}) })
         const text = [`Kept in ${r.square.short}: ${r.kept.join(', ') || '(nothing)'}`, ...r.squares.map((q) => `New ${describeSquare(q)}: ${q.paths.join(', ')}`)].join('\n')
         if (found && block.square === r.square.id) { const st = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); return print(r, `${text}\n${st.written} file(s) updated in the folder.`) }
         return print(r, text)
       }
       if (sub === 'show') { const sq = await client.square(needQuilt(), pos[1] || needSquare()); return print(sq, describeSquareStatus(sq)) }
-      const list = await client.squares(needQuilt(), { state: flags['--all'] ? undefined : (flags['--state'] || 'open'), mine: !!flags['--mine'] })
+      const list = await client.squares(needQuilt(), { state: flags['--all'] ? undefined : (flags['--state'] || 'open'), mine: !!flags['--mine'], hidden: !!flags['--hidden'], archived: !!flags['--archived'] })
       return print(list, list.length ? list.map(describeSquare).join('\n') : 'No open squares.')
     }
+    case 'clone': {
+      // seam clone <repo> [dir]: main (or --line), ready to work: the first commit opens a square.
+      const repo = pos[0] || flags['--quilt']
+      if (!repo) throw new Error('seam clone <repo> [folder] [--line <line>]')
+      const line = flags['--line'] || 'main'
+      const name = String(repo).split('/').pop()
+      const dir = path.resolve(cwd, pos[1] || flags['--dir'] || name)
+      const r = await checkout(client, { quilt: repo, rev: line, paths, dir, api, codec: await codecFor(client, repo) })
+      return print({ dir, files: r.files, block: { ...r.block, files: undefined } }, `Cloned ${repo} (${line}, ${r.files} file(s)) into ${dir}.\nEdit, then seam commit -m "…": the first commit opens a square for it; seam merge lands it, seam pull brings others' patches in.`)
+    }
+    case 'pull': {
+      if (!found) throw new Error('seam pull works in a block folder: run it in a folder made by seam clone or seam checkout.')
+      const r = await pull(client, found.dir, block)
+      const kept = r.kept?.length ? `\nKept your own version of ${r.kept.join(', ')} (changed on both sides): compare with seam diff.` : ''
+      if (r.noop) return print(r, block.square ? `Already up to date: ${block.square_short || block.square} sits on ${block.line}'s tip.` : `Already up to date with ${block.line}.`)
+      if (r.left) return print(r, `${r.left.square} was ${r.left.state}; the folder is now on ${r.line} (${r.at.slice(0, 12)}, ${r.written} file(s) updated).` + kept)
+      if (r.rebased) return print(r, describeWrite(r.result, 'Rebased') + `\n${r.written} file(s) updated in the folder.` + kept)
+      return print(r, `Pulled ${r.line} (now ${r.at.slice(0, 12)}): ${r.written} file(s) updated.` + kept)
+    }
     case 'checkout': {
       const target = pos[0]
       if (!target) throw new Error('seam checkout <sq:id | revision> [--dir folder] [-- paths]')
@@ -201,17 +367,23 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         return print(r, `Switched to ${sq ? `${sq.short} "${sq.title}"` : target} (${r.written} file(s) written).`)
       }
       const dir = path.resolve(cwd, flags['--dir'] || (isSquare ? target.replace(':', '-') : 'seam-checkout'))
-      const r = await checkout(client, { quilt: needQuilt(), ...(isSquare ? { square: target } : { rev: target }), paths, dir, api })
+      const r = await checkout(client, { quilt: needQuilt(), ...(isSquare ? { square: target } : { rev: target }), paths, dir, api, codec: await codecFor(client, needQuilt()) })
       return print({ dir, files: r.files, block: { ...r.block, files: undefined } }, `Checked out ${r.files} file(s) of ${isSquare ? target : target} under ${r.block.paths.map((p) => p || '/').join(', ')} into ${dir}.`)
     }
     case 'runner': {
       // seam runner --check ci[,lint] --run "npm test" [--dir <folder>] [--interval <s>] [--log-url <template>] [--once] [--keep]
-      const checks = String(flags['--check'] || '').split(',').map((c) => c.trim()).filter(Boolean)
-      if (!checks.length || !flags['--run'] || flags['--run'] === true) throw new Error('seam runner --check <name>[,<name>] --run "<command>" [--dir <folder>] [--interval <seconds>] [--log-url <template>] [--once]')
-      const q = needQuilt()
+      // seam runner --config runner.json: { quilt?, checks: { "<check>": "<command>" } }, one command per check
+      const conf = flags['--config'] ? readRunnerConfig(fs.readFileSync(path.resolve(cwd, String(flags['--config'])), 'utf8')) : null
+      const checks = conf ? Object.keys(conf.commands) : String(flags['--check'] || '').split(',').map((c) => c.trim()).filter(Boolean)
+      if (!conf && (!checks.length || !flags['--run'] || flags['--run'] === true)) throw new Error('seam runner --check <name>[,<name>] --run "<command>" | --config <file> [--dir <folder>] [--interval <seconds>] [--log-url <template>] [--once]')
+      const q = flags['--quilt'] || conf?.quilt || needQuilt()
       const say = (l) => { if (!flags['--json']) console.log(l) }
-      if (!flags['--once']) say(`seam runner: running ${checks.join(', ')} for ${q} with: ${flags['--run']} (Ctrl-C to stop)`)
-      const done = await runChecks({ client, quilt: q, checks, run: String(flags['--run']), api, once: !!flags['--once'], keep: !!flags['--keep'], ...(flags['--dir'] ? { dir: path.resolve(cwd, flags['--dir']) } : {}), ...(flags['--interval'] ? { intervalMs: Math.max(1, Number(flags['--interval'])) * 1000 } : {}), ...(flags['--log-url'] ? { logUrl: String(flags['--log-url']) } : {}), say })
+      if (!flags['--once']) say(`seam runner: running ${checks.join(', ')} for ${q}${conf ? ` (${flags['--config']})` : ` with: ${flags['--run']}`} (Ctrl-C to stop)`)
+      // --listen <port>: Seam's webhook wakes it; --idle-exit <seconds>: it stops when there is nothing to do
+      const listener = flags['--listen'] ? listenForWork({ port: Number(flags['--listen']), secret: process.env.SEAM_WEBHOOK_SECRET || null, say }) : null
+      const idle = flags['--idle-exit'] ? Number(flags['--idle-exit']) * 1000 : 0
+      const done = await runChecks({ client, quilt: q, checks, ...(conf ? { commands: conf.commands } : { run: String(flags['--run']) }), ...(listener ? { wake: listener.wake } : {}), ...(idle ? { idleExitMs: idle } : {}), api, once: !!flags['--once'], keep: !!flags['--keep'], ...(flags['--dir'] ? { dir: path.resolve(cwd, flags['--dir']) } : {}), ...(flags['--interval'] ? { intervalMs: Math.max(1, Number(flags['--interval'])) * 1000 } : {}), ...(flags['--log-url'] ? { logUrl: String(flags['--log-url']) } : {}), say })
+      listener?.server.close()
       return print({ runs: done }, done.length ? `Ran ${done.length} check run(s).` : 'Nothing queued.')
     }
     case 'status': {
@@ -221,25 +393,71 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
     }
     case 'review': {
       // seam review [sq] (the reviews and where the square stands)
-      // seam review approve|request-changes|comment|dismiss [sq] [-m <text>] [--path <file> [--line <n>]]
-      const VERDICT = { approve: 'approve', 'request-changes': 'request_changes', comment: 'comment', dismiss: 'dismiss' }
+      // seam review approve|request-changes|comment|dismiss [sq] [-m <text>] [--path <file> [--line <n>]] [--scope <glob>,<glob> (approve: only these paths)]
+      // seam review request [sq] [--to <member>[,<member>]] [-m <why>]: asks them, and whoever the line's unmet rules name, for a review
+      const VERDICT = { approve: 'approve', 'request-changes': 'request_changes', comment: 'comment', dismiss: 'dismiss', request: 'request' }
       const kind = VERDICT[pos[0]]
       const sq = (kind ? pos[1] : pos[0]) || needSquare()
+      // seam review interdiff [sq] [--since <rev>]: what changed since you reviewed (or since <rev>)
+      if (pos[0] === 'interdiff') { const r = await client.interdiff(needQuilt(), pos[1] || needSquare(), flags['--since'] ? { since: String(flags['--since']) } : {}); return print(r, describeInterdiff(r)) }
+      // seam review apply <review id> [sq]: applies a suggestion as a commit on the square (you must be its holder or a writer)
+      if (pos[0] === 'apply') {
+        if (!pos[1]) throw new Error('Which suggestion? seam review apply <review id> [square] (the id is in seam review)')
+        const r = await client.applySuggestion(needQuilt(), pos[2] || needSquare(), pos[1])
+        return print(r, `Applied the suggestion as ${r.result.id.slice(0, 12)} on ${r.square.id || pos[2] || 'the square'}.`)
+      }
       if (!kind) { const r = await client.reviews(needQuilt(), sq); return print(r, describeReviews(r)) }
-      const r = await client.review(needQuilt(), sq, { kind, body: message || '', ...(flags['--path'] ? { path: flags['--path'] } : {}), ...(flags['--line'] ? { line: Number(flags['--line']) } : {}) })
+      const r = await client.review(needQuilt(), sq, { kind, body: message || '', ...(kind === 'request' && flags['--to'] ? { asked: String(flags['--to']).split(',').map((m) => m.trim()).filter(Boolean) } : {}), ...(flags['--path'] ? { path: flags['--path'] } : {}), ...(flags['--line'] ? { line: Number(flags['--line']) } : {}), ...(kind === 'approve' && flags['--scope'] ? { scope: String(flags['--scope']).split(',').map((g) => g.trim()).filter(Boolean) } : {}), ...(flags['--suggest'] != null ? { suggestion: { text: String(flags['--suggest']).replace(/\\n/g, '\n'), ...(flags['--to-line'] ? { to_line: Number(flags['--to-line']) } : {}) } } : {}) })
       return print(r, describeReviewed(r))
     }
+    case 'watch': {
+      // seam watch (yours; --all: everyone's) | seam watch <glob>... [--classes logic,schema] [--min-lines 50] [--line main] [--note why] | seam watch remove <id>
+      if (pos[0] === 'remove') {
+        if (!pos[1]) throw new Error('Which one? seam watch remove <id>')
+        const r = await client.unwatch(needQuilt(), pos[1])
+        return print(r, `Stopped watching (${r.removed}).`)
+      }
+      if (!pos.length) { const ws = await client.watches(needQuilt(), { all: !!flags['--all'] }); return print(ws, describeWatches(ws)) }
+      const w = await client.watch(needQuilt(), { paths: pos, ...(flags['--classes'] ? { classes: String(flags['--classes']).split(',').map((c) => c.trim()).filter(Boolean) } : {}), ...(flags['--min-lines'] != null ? { min_lines: Number(flags['--min-lines']) } : {}), ...(flags['--line'] ? { lines: [flags['--line']] } : {}), ...(flags['--note'] ? { note: flags['--note'] } : {}) })
+      return print(w, `Watching ${w.paths.join(', ')}${w.classes ? ` for ${w.classes.join(', ')} changes` : ''}${w.min_lines != null ? ` over ${w.min_lines} lines` : ''}: each matching patch sends you watch.triggered (seam events). ${w.id}`)
+    }
     case 'claim': {
-      // seam claim (lists the quilt's claims) | seam claim <pattern>... [--note <why>] (claims them for your square)
+      // seam claim (lists the quilt's claims) | seam claim <pattern>... [--note <why>] [--expires <seconds>] (claims them for your square)
       if (!pos.length) { const cs = await client.claims(needQuilt(), flags['--square']); return print(cs, describeClaims(cs)) }
+      // seam claim request <claim id|pattern> --title <what for> [-m <plan>] | seam claim withdraw <request id> | seam claim handoff <pattern> [--to <request id>] [--note <context>] | seam claim finish [--note <context>]
+      if (pos[0] === 'request') {
+        if (!pos[1] || !flags['--title']) throw new Error('seam claim request <claim id|pattern> --title <what you need it for> [-m <your plan>]')
+        const r = await client.requestClaim(needQuilt(), { claim: pos[1], square: needSquare(), title: flags['--title'], ...(message ? { description: message } : {}) })
+        return print(r, `Waiting for ${pos[1]} as request ${r.id}: the holder hands it over when done (seam claim withdraw ${r.id} to stop waiting).`)
+      }
+      if (pos[0] === 'withdraw') { if (!pos[1]) throw new Error('seam claim withdraw <request id>'); const r = await client.withdrawRequest(needQuilt(), pos[1]); return print(r, `Withdrew request ${pos[1]}.`) }
+      if (pos[0] === 'handoff') {
+        if (!pos[1]) throw new Error('seam claim handoff <pattern|claim id> [--to <request id>] [--note <what you changed and what is left>]')
+        const r = await client.handoffClaim(needQuilt(), needSquare(), { claim: pos[1], ...(flags['--to'] ? { to: flags['--to'] } : {}), ...(flags['--note'] || message ? { note: flags['--note'] || message } : {}) })
+        return print(r, describeHandoff(r))
+      }
+      if (pos[0] === 'finish') {
+        const r = await client.finishClaims(needQuilt(), needSquare(), flags['--note'] || message ? { note: flags['--note'] || message } : {})
+        return print(r, describeFinished(r))
+      }
       const sq = needSquare()
       const made = []
-      for (const p of pos) made.push(await client.claim(needQuilt(), sq, { pattern: p, note: flags['--note'] || message }))
-      return print(made, made.map((c) => `Claimed ${c.pattern} for ${c.square}: writes to it from other squares on ${c.line} are refused until the square merges or you run seam unclaim ${c.pattern}.`).join('\n'))
+      for (const p of pos) made.push(await client.claim(needQuilt(), sq, { pattern: p, note: flags['--note'] || message, ...(flags['--expires'] ? { expires_in: Number(flags['--expires']) } : {}) }))
+      return print(made, made.map((c) => `Claimed ${c.pattern} for ${c.square}: writes to it from other squares on ${c.line} are refused until ${c.expires_at ? `${new Date(c.expires_at).toISOString()}, ` : ''}the square merges or you run seam unclaim ${c.pattern}.`).join('\n'))
     }
     case 'check': {
       // seam check <name> red|green|flaky [--line main] [--patch n] | seam check <name> green|red --square <sq>
       const [name, status] = pos
+      if (name === 'pipeline') {
+        // seam check pipeline <check> [--line main] [--stop]: the open bisect of a red check and the last one's outcome; --stop ends it (admin)
+        if (!status) throw new Error('seam check pipeline <check> [--line <line>] [--stop]')
+        if (flags['--stop']) {
+          const s = await client.stopPipeline(needQuilt(), flags['--line'] || 'main', status)
+          return print(s, s.stopped ? `Stopped the bisect of ${status} on ${flags['--line'] || 'main'} (patches ${s.bisect.range[0] + 1} to ${s.bisect.range[1]}): its waiting runs are cancelled and nothing is reverted.` : `No bisect of ${status} is open on ${flags['--line'] || 'main'}.`)
+        }
+        const r = await client.pipeline(needQuilt(), flags['--line'] || 'main', status)
+        return print(r, describePipeline(r))
+      }
       if (name === 'rerun') {
         // seam check rerun <check> --square <sq> | --line <line> [--commit <id>]: ask its runners again
         if (!status) throw new Error('seam check rerun <check> --square <square> | --line <line> [--commit <id>]')
@@ -268,6 +486,27 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       for (const p of pos) out.push(await client.unclaim(needQuilt(), sq, p))
       return print(out, out.map((r) => `Let go of ${r.released.pattern}.`).join('\n'))
     }
+    case 'daemon': {
+      // seam daemon (foreground: watches this block folder and shares each change as live work) | seam daemon status | flush | stop
+      if (!found) throw new Error('seam daemon watches a block folder: run it in a folder made by seam checkout or seam square open.')
+      const sub = pos[0]
+      if (sub === 'status' || sub === 'flush' || sub === 'stop' || sub === 'rebuild') {
+        const r = await askDaemon(found.dir, sub, sub === 'status' ? 'GET' : 'POST')
+        if (!r) return print({ running: false }, `No daemon is running for ${found.dir}: start one with seam daemon.`)
+        if (sub === 'stop') return print(r, 'The daemon is stopping.')
+        if (sub === 'rebuild') return print(r, describeRebuild(r))
+        return print(r, `Watching ${r.dir} on ${String(r.square).startsWith("sq:") ? r.square : `sq:${r.square}`} (${r.state}): sent ${r.sent} time(s)${r.pending.length ? `, ${r.pending.length} path(s) waiting` : ''}${r.last_error ? `. ${r.last_error}` : ''}.`)
+      }
+      if (sub) throw new Error(`seam daemon ${sub}? seam daemon | daemon status | daemon flush | daemon rebuild | daemon stop`)
+      const d = await startDaemon({ client, dir: found.dir, codec: block._codec || null, ...(flags['--debounce'] != null ? { debounceMs: Number(flags['--debounce']) } : {}) })
+      if (!json) out(`seam daemon: sharing each change in ${found.dir} as live work on ${block.square} (Ctrl-C to stop; control API on 127.0.0.1:${d.port}).`)
+      const onSignal = () => d.stop()
+      process.once('SIGINT', onSignal); process.once('SIGTERM', onSignal)
+      const wait = setInterval(() => { if (stop()) d.stop() }, 500)
+      await d.stopped()
+      clearInterval(wait); process.off('SIGINT', onSignal); process.off('SIGTERM', onSignal)
+      return print(d.status(), 'The daemon stopped.')
+    }
     case 'live': {
       // seam live [sq] | live share (a block folder's uncommitted edits) | live clear
       const sub = pos[0]
@@ -275,10 +514,21 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         const sqRef = flags['--square'] || block?.square
         if (!sqRef) throw new Error(`seam live ${sub} works in a block folder on a square (or pass --square sq:<id>).`)
         if (sub === 'share' && !found) throw new Error('seam live share sends a block folder\'s uncommitted edits: run it in a folder made by seam checkout.')
-        const changes = sub === 'clear' ? [] : localChanges(found.dir, block).map((c) => c.status === 'deleted' ? { path: c.path, op: 'delete' } : { path: c.path, op: 'put', content: c.bytes.toString('base64'), mode: c.mode })
+        // seam live share <paths>: only those paths, merged into what the square shares (others' paths stay).
+        const named = sub === 'share' ? [...pos.slice(1), ...paths] : []
+        if (named.length) {
+          const r = await client.patchLive(needQuilt(), sqRef, livePatch(found.dir, block, named.map((p) => path.resolve(cwd, p))))
+          return print(r, describeLiveSet(r))
+        }
+        const changes = sub === 'clear' ? [] : localChanges(found.dir, block).map((c) => c.status === 'deleted' ? { path: c.path, op: 'delete' } : { path: c.path, op: 'put', content: bytesOf(c).toString('base64'), mode: c.mode })
         const r = await client.setLive(needQuilt(), sqRef, { changes })
         return print(r, describeLiveSet(r))
       }
+      if (sub === 'join') {
+        // seam live join [sq] [--member <member>]: whether a member may load the square's live work whole
+        const r = await client.liveJoin(needQuilt(), pos[1] || needSquare(), flags['--member'])
+        return print(r, describeLiveJoin(r))
+      }
       const r = await client.live(needQuilt(), sub || needSquare())
       return print(r, describeLive(r))
     }
@@ -296,6 +546,8 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       if (!found) {
         throw new Error('seam commit seals a block folder\'s changes; run it in a folder made by seam checkout.')
       }
+      // --allow sf_…,sf_…: secret findings a person has checked and lets through (11.9).
+      const allowed = flags['--allow'] ? String(flags['--allow']).split(',').map((x) => x.trim()).filter(Boolean) : []
       // --sign: signs the new commit with this computer's key (seam key add).
       const signed = async (r) => {
         if (!flags['--sign'] || !r?.result?.id) return ''
@@ -304,28 +556,65 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         return `\nSigned with ${s.signature.key}.`
       }
       if (flags['--amend']) {
-        const r = await amendFolder(client, found.dir, block, { message, paths: [...pos, ...paths].map((p) => path.resolve(cwd, p)) })
+        const r = await amendFolder(client, found.dir, block, { message, paths: [...pos, ...paths].map((p) => path.resolve(cwd, p)), allow: allowed })
         const s = await signed(r)
         return print(r, describeWrite(r, `Amended ${r.amended.slice(0, 12)} as`) + s)
       }
       if (!message) throw new Error('Say what changed: seam commit -m "message" [paths...]')
-      const r = await commitFolder(client, found.dir, block, { message, paths: [...pos, ...paths].map((p) => path.resolve(cwd, p)) })
+      const r = await commitFolder(client, found.dir, block, { message, paths: [...pos, ...paths].map((p) => path.resolve(cwd, p)), allow: allowed })
       if (r.nothing) return print(r, 'Nothing to commit.')
       const s = await signed(r)
-      return print(r, describeWrite(r, 'Committed') + s)
+      return print(r, describeOpened(r) + describeWrite(r, 'Committed') + s)
     }
     case 'sign': {
       // seam sign [rev]: signs a commit you made (default: your square's head, or main's tip).
       const r = await signWithLocalKey(client, needQuilt(), pos[0] || (block?.square ? block.square_short : block?.line) || 'main')
       return print(r, `Signed ${r.short} with ${r.signature.key}.`)
     }
+    case 'block': {
+      // seam block [list] [--square <s>] [--mine] | open <square> [--paths a,b] [--mode sparse|virtual|api-only] [--machine <name>] [--at <rev>] [--read-only] [--exclude <globs>] [--max-fetch-bytes <n>] | touch <id> [--add a,b] [--remove a,b] | close <id>
+      const sub = pos[0] || 'list'
+      const csv = (f) => flags[f] == null ? undefined : String(flags[f]).split(',').map((x) => x.trim()).filter(Boolean)
+      const usage = 'seam block [list] | rebuild | open <square> [--paths a,b] [--mode sparse|virtual|api-only] [--machine <name>] [--at <rev>] [--read-only] | touch <id> [--add a,b] [--remove a,b] | close <id>'
+      if (sub === 'rebuild') {
+        // seam block rebuild: finishes a move of this folder that stopped part way (the journal in .seam)
+        if (!found) throw new Error('seam block rebuild works on a block folder; run it in a folder made by seam checkout.')
+        const r = await rebuildBlock(client, found.dir, block)
+        return print(r, describeRebuild(r))
+      }
+      if (sub === 'list') { const r = await client.blocks(needQuilt(), { square: flags['--square'], mine: flags['--mine'] ? 1 : undefined }); return print(r, describeBlocks(r)) }
+      if (sub === 'open') {
+        if (!pos[1]) throw new Error(usage)
+        const r = await client.openBlock(needQuilt(), { square: pos[1], paths: csv('--paths'), mode: flags['--mode'], machine: flags['--machine'] || os.hostname(), at: flags['--at'], read_only: flags['--read-only'] === true || undefined, exclude: csv('--exclude'), max_fetch_bytes: flags['--max-fetch-bytes'] == null ? undefined : Number(flags['--max-fetch-bytes']) })
+        return print(r, `Opened ${describeBlock(r)}`)
+      }
+      if (sub === 'touch') { if (!pos[1]) throw new Error(usage); const r = await client.touchBlock(needQuilt(), pos[1], { add: csv('--add'), remove: csv('--remove') }); return print(r, describeBlock(r)) }
+      if (sub === 'close') { if (!pos[1]) throw new Error(usage); const r = await client.closeBlock(needQuilt(), pos[1]); return print(r, `Closed block ${r.id}: the square and the folder's files are untouched.`) }
+      throw new Error(usage)
+    }
     case 'token': {
-      // seam token [list] | new <name> [--level read|write] | revoke <id or name>
+      // seam token [list] | new <name> [--level read|write] [--days 1-365] | revoke <id or name>
+      // seam token agent [list] | new [--agent agent:<id>] [--level read|write|merge] [--squares own|sq:…,…] [--paths src,docs] [--hours 8] [--checks] [--rate commit_rate=10,merge_rate=5] | revoke <id>
       const sub = pos[0] || 'list'
+      if (sub === 'agent') {
+        const act = pos[1] || 'list'
+        if (act === 'list') { const r = await client.agentTokens(needQuilt()); return print(r, describeAgentTokens(r)) }
+        if (act === 'new') {
+          const squares = flags['--squares'] && flags['--squares'] !== 'own' ? String(flags['--squares']).split(',').map((x) => x.trim()).filter(Boolean) : 'own'
+          const r = await client.createAgentToken(needQuilt(), { ...(flags['--agent'] ? { agent: flags['--agent'] } : {}), max_level: flags['--level'] || 'write', squares, paths: flags['--paths'] ? String(flags['--paths']).split(',').map((x) => x.trim()).filter(Boolean) : [], ...(flags['--hours'] ? { ttl_s: Math.round(Number(flags['--hours']) * 3600) } : {}), ...agentTokenExtras(flags) })
+          return print(r, describeAgentToken(r))
+        }
+        if (act === 'revoke') {
+          if (!pos[2]) throw new Error('seam token agent revoke <id>')
+          const r = await client.revokeAgentToken(needQuilt(), pos[2])
+          return print(r, `Revoked agent token ${r.id}: it no longer reaches the quilt.`)
+        }
+        throw new Error('seam token agent [list] | new [--agent agent:<id>] [--level read|write|merge] [--squares own|…] [--paths …] [--hours n] | revoke <id>')
+      }
       if (sub === 'list') { const r = await client.tokens(needQuilt()); return print(r, describeTokens(r)) }
       if (sub === 'new') {
-        if (!pos[1]) throw new Error('seam token new <name> [--level read|write]')
-        const r = await client.createToken(needQuilt(), { name: pos[1], level: flags['--level'] || 'read' })
+        if (!pos[1]) throw new Error('seam token new <name> [--level read|write] [--days 1-365]')
+        const r = await client.createToken(needQuilt(), { name: pos[1], level: flags['--level'] || 'read', ...(flags['--days'] ? { expires_in_days: Number(flags['--days']) } : {}) })
         return print(r, describeNewToken(r))
       }
       if (sub === 'revoke') {
@@ -333,7 +622,137 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         const r = await client.revokeToken(needQuilt(), pos[1])
         return print(r, `Revoked token ${r.name} (${r.id}): it no longer reaches the quilt.`)
       }
-      throw new Error('seam token [list] | new <name> [--level read|write] | revoke <id or name>')
+      throw new Error('seam token [list] | new <name> [--level read|write] [--days 1-365] | revoke <id or name>')
+    }
+    case 'org': {
+      // seam org [list] | new <slug> [--title <name>] | show <org> | add <org> <member> [--role member|admin|owner] | remove <org> <member>
+      const sub = pos[0] || 'list'
+      if (sub === 'list') { const r = await client.orgs(); return print(r, describeOrgs(r)) }
+      if (sub === 'new') { if (!pos[1]) throw new Error('seam org new <slug>'); const r = await client.createOrg({ slug: pos[1], name: flags['--title'] }); return print(r, `Made org ${r.slug}; you are its owner. Make its quilts with seam quilts new <slug> --org ${r.slug}.`) }
+      if (sub === 'show') { if (!pos[1]) throw new Error('seam org show <org>'); const r = await client.org(pos[1]); return print(r, describeOrg(r)) }
+      if (sub === 'add' || sub === 'remove') {
+        if (!pos[1] || !pos[2]) throw new Error(`seam org ${sub} <org> <member>${sub === 'add' ? ' [--role member|admin|owner]' : ''}`)
+        const r = await client.setOrgMember(pos[1], pos[2], sub === 'add' ? (flags['--role'] || 'member') : null)
+        return print(r, (r.invited ? `Invited ${r.email}: ${r.emailed ? 'Seam emailed them a link' : `send them ${r.sign_up}`}. They are in the org from their first sign-in.\n` : '') + describeOrg(r))
+      }
+      if (sub === 'team') {
+        // seam org team <org> <name> <member>... : the team's members, replaced whole; none removes it.
+        if (!pos[1] || !pos[2]) throw new Error('seam org team <org> <name> [<member>...]')
+        const r = await client.setOrgTeam(pos[1], pos[2], pos.slice(3))
+        return print(r, describeOrgTeams(r))
+      }
+      throw new Error('seam org [list] | new <slug> | show <org> | add <org> <member> [--role r] | remove <org> <member> | team <org> <name> [<member>...]')
+    }
+    case 'policy': {
+      // seam policy versions|approve|reject|confirm <line> [<version>]: a line's policy versions (11.4)
+      if (['versions', 'approve', 'reject', 'confirm'].includes(pos[0])) {
+        if (!pos[1]) throw new Error(`seam policy ${pos[0]} <line>${pos[0] === 'versions' ? '' : ' <version>'}`)
+        const q = needQuilt()
+        if (pos[0] !== 'versions' && !pos[2]) throw new Error(`seam policy ${pos[0]} ${pos[1]} <version>`)
+        let r
+        if (pos[0] === 'versions') r = await client.linePolicyVersions(q, pos[1])
+        else if (pos[0] === 'approve') r = await client.decideLinePolicy(q, pos[1], pos[2], 'approve')
+        else if (pos[0] === 'reject') r = await client.decideLinePolicy(q, pos[1], pos[2], 'reject')
+        else r = await confirmWithLocalKey(client, q, pos[1], Number(pos[2]))
+        return print(r, describePolicyVersions(r))
+      }
+      // seam policy [check] [sq] [--line <line>]: the square's change classes and what its line's rules need
+      const sq = (pos[0] === 'check' ? pos[1] : pos[0]) || needSquare()
+      const r = await client.squarePolicy(needQuilt(), sq, flags['--line'] ? { line: flags['--line'] } : {})
+      return print(r, describeSquarePolicy(r))
+    }
+    case 'seal': {
+      // seam seal [status] | key | grant <member> | rotate [--without <member>,...]
+      const sub = pos[0] || 'status'
+      if (sub === 'key') { const k = await ensureSealingKey(client); return print({ key_id: k.id, public_key: k.public_key }, `This computer's sealing key is ${k.id}. A member who holds a sealed quilt's key gives it to you with seam seal grant <your member id>.`) }
+      const q = needQuilt()
+      if (sub === 'status') { const r = await client.seal(q); return print(r, describeSeal(r)) }
+      if (sub === 'grant') {
+        if (!pos[1]) throw new Error('seam seal grant <member id>')
+        const r = await grantSealed(client, q, pos[1])
+        return print(r, describeSeal(r))
+      }
+      if (sub === 'rotate') {
+        const r = await rotateSealed(client, q, { without: flags['--without'] ? String(flags['--without']).split(',').map((x) => x.trim()).filter(Boolean) : [] })
+        return print(r, describeSeal(r))
+      }
+      throw new Error('seam seal [status] | key | grant <member id> | rotate [--without <member id>,...]')
+    }
+    case 'metrics': {
+      // seam metrics: the numbers Seam keeps for the quilt that ops/alerts.yml names, and which are past their threshold (admin)
+      const r = await client.metrics(needQuilt()); return print(r, describeMetrics(r))
+    }
+    case 'redact': {
+      // seam redact <blob id | path[@rev]> --reason "<why>" [--yes] | seam redact list
+      const q = needQuilt()
+      if (!pos[0] || pos[0] === 'list') { const r = await client.redactions(q); return print(r, describeRedactions(r)) }
+      if (!flags['--reason']) throw new Error('seam redact <blob id | path[@rev]> --reason "<why>": the reason is kept in the log')
+      let blob = pos[0]
+      if (!/^[0-9a-f]{64}$/.test(blob)) {
+        const at = blob.lastIndexOf('@')
+        const [p, rev] = at > 0 ? [blob.slice(0, at), blob.slice(at + 1)] : [blob, flags['--square'] || block?.square || 'main']
+        blob = (await client.cat(q, rev, p)).blob
+        if (!blob) throw new Error(`${p} has no content to redact at ${rev}`)
+      }
+      if (!flags['--yes']) throw new Error(`Redacting ${blob.slice(0, 12)} cannot be undone: every copy of those bytes leaves the quilt. Run it again with --yes.`)
+      const r = await client.redact(q, { blob, reason: flags['--reason'] })
+      return print(r, describeRedacted(r))
+    }
+    case 'verify': {
+      // seam verify [--after <seq>] [--keys <file.json>]: checks the quilt's log against the server's signatures, on this computer
+      const keys = flags['--keys'] ? JSON.parse(fs.readFileSync(path.resolve(cwd, flags['--keys']), 'utf8')) : null
+      const v = await verifyQuilt(client, needQuilt(), { after: flags['--after'] || 0, keys: keys ? (Array.isArray(keys) ? keys : keys.keys) : null })
+      const r = print(v, describeVerify(v))
+      if (v.bad.length || v.gaps.length) process.exitCode = 1
+      return r
+    }
+    case 'protect': {
+      // seam protect [list] | add <path> <who> <level> [--exclude] [--at n] [--note why] | remove <n> | set <file.json> | reset | check [<path>]
+      const sub = pos[0] || 'list'
+      const q = needQuilt()
+      if (sub === 'list') { const r = await client.protections(q); return print(r, describeProtections(r)) }
+      if (sub === 'check') { const r = await client.access(q, pos[1] || ''); return print(r, describeAccess(r)) }
+      if (sub === 'reset') { const r = await client.setProtections(q, null); return print(r, describeProtections(r)) }
+      if (sub === 'set') {
+        if (!pos[1]) throw new Error('seam protect set <file.json>: a list of { path, principal, level, exclude? }')
+        const rows = JSON.parse(fs.readFileSync(path.resolve(cwd, pos[1]), 'utf8'))
+        const r = await client.setProtections(q, Array.isArray(rows) ? rows : rows.rows)
+        return print(r, describeProtections(r))
+      }
+      const cur = (await client.protections(q)).rows.map(({ n, ...x }) => x)
+      if (sub === 'add') {
+        if (pos.length < 4) throw new Error("seam protect add <path> <who> <level> [--exclude] [--at n]: who is everyone, people, agents, role:read|write|admin, team:<name>, person:<id>, agent:<id>, token:<id> or (an org's quilt) org_role:member|admin|owner; path '' is the whole quilt")
+        const row = { path: pos[1] === "''" ? '' : pos[1], principal: pos[2], level: pos[3], exclude: !!flags['--exclude'], ...(flags['--note'] ? { note: flags['--note'] } : {}) }
+        const at = flags['--at'] ? Number(flags['--at']) : cur.length + 1
+        if (!Number.isInteger(at) || at < 1 || at > cur.length + 1) throw new Error(`--at is a position from 1 to ${cur.length + 1}`)
+        cur.splice(at - 1, 0, row)
+        const r = await client.setProtections(q, cur)
+        return print(r, describeProtections(r))
+      }
+      if (sub === 'remove') {
+        const n = Number(pos[1])
+        if (!Number.isInteger(n) || n < 1 || n > cur.length) throw new Error(`seam protect remove <n>: a row number from 1 to ${cur.length}`)
+        cur.splice(n - 1, 1)
+        const r = await client.setProtections(q, cur)
+        return print(r, describeProtections(r))
+      }
+      throw new Error('seam protect [list] | add <path> <who> <level> [--exclude] [--at n] | remove <n> | set <file.json> | reset | check [<path>]')
+    }
+    case 'team': {
+      // seam team [list] | set <name> <member>... | remove <name>
+      const sub = pos[0] || 'list'
+      if (sub === 'list') { const r = await client.teams(needQuilt()); return print(r, describeTeams(r)) }
+      if (sub === 'set') {
+        if (!pos[1] || pos.length < 3) throw new Error('seam team set <name> <member> [<member>...]')
+        const r = await client.setTeam(needQuilt(), pos[1], pos.slice(2))
+        return print(r, describeTeams(r))
+      }
+      if (sub === 'remove') {
+        if (!pos[1]) throw new Error('seam team remove <name>')
+        const r = await client.setTeam(needQuilt(), pos[1], [])
+        return print(r, describeTeams(r))
+      }
+      throw new Error('seam team [list] | set <name> <member>... | remove <name>')
     }
     case 'key': {
       // seam key [list [member]] | add [--name <n>] [--public-key <file>] | remove <key>
@@ -353,18 +772,49 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
     }
     case 'log': {
       const rev = pos[0] || (block?.square ? block.square_short : block?.line) || 'main'
-      const r = await client.log(needQuilt(), { rev, paths, limit: flags['-n'] || flags['--max-count'] || 20, follow: flags['--follow'] ? true : undefined, show_signature: flags['--show-signature'] ? true : undefined, search: typeof flags['-S'] === 'string' ? flags['-S'] : undefined })
-      return print(r, describeLog(r, { oneline: !!flags['--oneline'] }))
+      // Filters: --grep <text> (-E regex, -i any case), -G <regex>, -S <text>, --author, --on-behalf-of, --task, --since, --until.
+      const str = (k) => typeof flags[k] === 'string' ? flags[k] : undefined
+      const r = await client.log(needQuilt(), {
+        rev, paths, limit: flags['-n'] || flags['--max-count'] || 20, follow: flags['--follow'] ? true : undefined, show_signature: flags['--show-signature'] ? true : undefined, search: str('-S'),
+        message: str('--grep'), message_regex: str('--grep') && flags['-E'] ? 1 : undefined, message_ignore_case: str('--grep') && flags['-i'] ? 1 : undefined,
+        pickaxe: str('-G'), pickaxe_regex: str('-G') ? 1 : undefined, pickaxe_mode: str('-G') ? 'match' : undefined,
+        author: str('--author'), on_behalf_of: str('--on-behalf-of'), task: str('--task'), since: str('--since'), until: str('--until'),
+        group_by: str('--group-by'), graph: flags['--graph'] ? 1 : undefined, include_hidden: flags['--include-hidden'] ? 1 : undefined, cursor: str('--cursor')
+      })
+      return print(r, describeLog(r, { oneline: !!flags['--oneline'], graph: !!flags['--graph'] }))
     }
     case 'describe': {
       const r = await client.describe(needQuilt(), pos[0] || (block?.square ? block.square_short : block?.line) || 'main')
       return print(r, r.describe)
     }
+    case 'stack': {
+      // seam stack [rev]: the full-stack pointers at a revision (db_migration, db_branch, infra, …).
+      const r = await client.stack(needQuilt(), pos[0] || (block?.square ? block.square_short : block?.line) || 'main')
+      return print(r, describeStack(r))
+    }
     case 'merge-base': {
-      if (pos.length !== 2) throw new Error('seam merge-base <revision> <revision>')
+      if (pos.length !== 2) throw new Error('seam merge-base [--is-ancestor] <revision> <revision>')
+      if (flags['--is-ancestor']) {
+        // git merge-base --is-ancestor a b: whether a is in b's history.
+        const r = await client.ancestor(needQuilt(), pos[0], pos[1])
+        return print(r, describeAncestor(r, pos[0], pos[1]))
+      }
       const r = await client.mergeBase(needQuilt(), pos[0], pos[1])
       return print(r, describeMergeBase(r))
     }
+    case 'contains': {
+      // seam contains <rev>: the lines whose history has it (git branch --contains), and where it was cherry-picked or reverted.
+      if (pos.length !== 1) throw new Error('seam contains <revision>')
+      const r = await client.contains(needQuilt(), pos[0])
+      return print(r, describeContains(r))
+    }
+    case 'search': {
+      // seam search <query> [--at <rev>] [--all | --quilts a,b]: words, "phrases", /regex/, path:, lang:, symbol:, class:, -term, OR
+      if (!pos.length) throw new Error('seam search <query> [--at <rev>] [--all | --quilts a,b]   e.g. seam search "symbol:mergeSquare lang:js"')
+      const q = pos.join(' ')
+      const r = flags['--all'] || flags['--quilts'] ? await client.search({ q, rev: flags['--at'], quilts: flags['--quilts'] ? String(flags['--quilts']).split(',') : undefined, limit: flags['--max-count'] }) : await client.searchCode(needQuilt(), { q, rev: flags['--at'] || (block?.square ? block.square_short : undefined), limit: flags['--max-count'] })
+      return print(r, describeSearch(r))
+    }
     case 'grep': {
       // seam grep <pattern> [revision] [-- paths]: -i ignores case, -F takes the pattern as plain text, -l lists files.
       if (!pos[0]) throw new Error('seam grep <pattern> [revision] [-i] [-F] [-l] [--all] [-- paths]')
@@ -379,16 +829,16 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       return print(r, describeGrep(r, { filesOnly: !!flags['-l'] }))
     }
     case 'bisect': {
-      // seam bisect <bad> <good> --run "<check>": exit 0 good, 125 skip, else bad. Without --run, one step (--marks id:good,id:bad).
+      // seam bisect <bad> <good> --run "<check>" [-- paths]: exit 0 good, 125 skip, else bad. Without --run, one step (--marks id:good,id:bad). Paths narrow the commits tested.
       if (pos.length !== 2) throw new Error('seam bisect <bad> <good> --run "<check command>" (or --marks <commit>:good,<commit>:bad for one step)')
       const marks = Object.fromEntries(String(flags['--marks'] || '').split(',').filter(Boolean).map((x) => x.split(':')))
       if (typeof flags['--run'] === 'string') {
         const { bisectRun } = await import('./bisect-run.js')
-        const r = await bisectRun(client, { quilt: needQuilt(), bad: pos[0], good: pos[1], run: flags['--run'], marks, api, log: (s) => { if (!json) out(s) } })
+        const r = await bisectRun(client, { quilt: needQuilt(), bad: pos[0], good: pos[1], run: flags['--run'], marks, only: paths, api, log: (s) => { if (!json) out(s) } })
         return print(r, describeBisect(r))
       }
-      const r = await client.bisect(needQuilt(), { bad: pos[0], good: pos[1], marks })
-      return print(r, describeBisect(r) + (r.done ? '' : `\nThen: seam bisect ${pos[0]} ${pos[1]} --marks ${[...Object.entries(marks).map(([k, v]) => `${k}:${v}`), `${r.next.short}:<good|bad|skip>`].join(',')}`))
+      const r = await client.bisect(needQuilt(), { bad: pos[0], good: pos[1], marks, paths })
+      return print(r, describeBisect(r) + (r.done ? '' : `\nThen: seam bisect ${pos[0]} ${pos[1]} --marks ${[...Object.entries(marks).map(([k, v]) => `${k}:${v}`), `${r.next.short}:<good|bad|skip>`].join(',')}${paths.length ? ` -- ${paths.join(' ')}` : ''}`))
     }
     case 'show': {
       const rev = pos[0] || (block?.square ? block.square_short : 'main')
@@ -403,7 +853,16 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         return print(d, format === 'unified' ? (d.text || '') : d.changes.map((c) => `${c.status[0].toUpperCase()}\t${c.path}`).join('\n'))
       }
       const [from, to] = pos.length === 1 && pos[0].includes('..') ? pos[0].split('..') : pos.length === 1 ? [pos[0], block?.square ? block.square_short : 'main'] : pos
-      const r = await client.diff(needQuilt(), { from, to, paths, format })
+      // --stack: which full-stack pointers (db_migration, db_branch, …) changed, not the files.
+      if (flags['--stack']) { const r = await client.stackDiff(needQuilt(), from, to); return print(r, describeStackDiff(r)) }
+      // --renames off|exact|similar (default similar; --no-renames: off), -w / --ignore-space-at-eol, -U <n>; every page unless --cursor or -n.
+      const opts = { from, to, paths, format, renames: flags['--no-renames'] ? 'off' : flags['--renames'] || 'similar', ignore_whitespace: flags['-w'] || flags['--ignore-all-space'] ? 'all' : flags['--ignore-space-at-eol'] ? 'trailing' : undefined, context: flags['-U'] ?? flags['--unified'], limit: flags['-n'] || flags['--max-count'], cursor: flags['--cursor'] }
+      const r = await client.diff(needQuilt(), opts)
+      for (let page = 0; r.cursor && !opts.cursor && !opts.limit && page < 100; page++) {
+        const more = await client.diff(needQuilt(), { ...opts, cursor: r.cursor })
+        r.files.push(...more.files); r.add += more.add || 0; r.del += more.del || 0; r.renames = (r.renames || 0) + (more.renames || 0)
+        r.cursor = more.cursor
+      }
       return print(r, describeDiff(r, { format }))
     }
     case 'merge': {
@@ -421,8 +880,13 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         return print(r, text)
       }
       const sqId = pos[0] && pos[0].startsWith('sq:') ? pos[0] : needSquare()
-      const r = await client.merge(needQuilt(), into, { square: sqId, ...(found && sqId === block.square ? { expect_head: block.head } : {}), message, dry_run: !!flags['--dry-run'], on_conflict: flags['--on-conflict'], expect_tip: flags['--expect-tip'] })
+      const r = await client.merge(needQuilt(), into, { square: sqId, ...(found && sqId === block.square ? { expect_head: block.head } : {}), message, dry_run: !!flags['--dry-run'], on_conflict: flags['--on-conflict'], expect_tip: flags['--expect-tip'], ...(flags['--no-commit-live'] ? { commit_live: false } : {}) })
       let text = describeMerge(r)
+      // Merged from its own folder: the folder moves to the line's new tip, ready for the next change.
+      if (found && sqId === block.square && r.ok && r.merged?.commit && !flags['--dry-run']) {
+        const s = await toLineTip(client, found.dir, block, r.merged.line || into, r.merged.commit)
+        text += `\nThe folder is now on ${r.merged.line || into} (${s.written} file(s) updated); your next commit opens a new square.`
+      }
       // The refused merge left the square rebased onto the tip with its conflicts: bring the folder there.
       if (found && sqId === block.square && !r.ok && r.head && r.head !== block.head) {
         const s = await syncTo(client, found.dir, block, r.head, { square: r.square })
@@ -447,12 +911,21 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       if (!pos[0]) throw new Error('seam revert <patch:n | revision>')
       const r = await client.revert(needQuilt(), { rev: pos[0], line: flags['--line'] })
       let text = describeWrite(r, 'Reverted in a new square') + `\nMerge it with: seam merge ${r.square.short} --into ${r.square.line}`
-      if (flags['--dir']) { const dir = path.resolve(cwd, flags['--dir']); await checkout(client, { quilt: needQuilt(), square: r.square.id, dir, api }); text += `\nChecked out into ${dir}.` }
+      if (flags['--dir']) { const dir = path.resolve(cwd, flags['--dir']); await checkout(client, { quilt: needQuilt(), square: r.square.id, dir, api, codec: await codecFor(client, needQuilt()) }); text += `\nChecked out into ${dir}.` }
       return print(r, text)
     }
     case 'resolve': {
-      const choose = flags['--ours'] ? 'ours' : flags['--theirs'] ? 'theirs' : flags['--base'] ? 'base' : flags['--delete'] ? 'delete' : flags['--suggestion'] ? 'suggestion' : flags['--side'] != null ? Number(flags['--side']) : null
-      if (choose === null || !pos.length) throw new Error('seam resolve <path>... --ours | --theirs | --base | --suggestion | --side n | --delete [--no-remember] (or edit the file and commit it without the markers)')
+      const rule = flags['--rule']
+      if (rule !== undefined) {
+        if (!pos.length) throw new Error('seam resolve <path>... --rule additive|whitespace|words|union')
+        const rel = (p) => found ? path.relative(found.dir, path.resolve(cwd, p)).split(path.sep).join('/') : p
+        const r = await client.resolve(needQuilt(), needSquare(), { ...(found ? { expect_head: block.head } : {}), entries: pos.map((p) => ({ path: rel(p), rule })), ...(flags['--no-remember'] ? { remember: false } : {}) })
+        let text = describeWrite(r, 'Resolved')
+        if (found) { const s = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` }
+        return print(r, text)
+      }
+      const choose = flags['--ours'] ? 'ours' : flags['--theirs'] ? 'theirs' : flags['--base'] ? 'base' : flags['--delete'] ? 'delete' : flags['--suggestion'] ? 'suggestion' : flags['--keep-both'] ? 'keep_both' : flags['--side'] != null ? Number(flags['--side']) : null
+      if (choose === null || !pos.length) throw new Error('seam resolve <path>... --ours | --theirs | --base | --suggestion | --side n | --delete | --keep-both | --rule <step> [--no-remember] (or edit the file and commit it without the markers)')
       const rel = (p) => found ? path.relative(found.dir, path.resolve(cwd, p)).split(path.sep).join('/') : p
       const r = await client.resolve(needQuilt(), needSquare(), { ...(found ? { expect_head: block.head } : {}), entries: pos.map((p) => ({ path: rel(p), choose })), ...(flags['--no-remember'] ? { remember: false } : {}) })
       let text = describeWrite(r, 'Resolved')
@@ -464,9 +937,9 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       if (pos[0] === 'forget') {
         if (!pos[1]) throw new Error('Which one? seam resolutions forget <key>')
         const r = await client.forgetResolution(needQuilt(), pos[1])
-        return print(r, `Forgot ${r.forgotten.short} (${r.forgotten.path}): that conflict will be asked about again.`)
+        return print(r, `Forgot ${r.forgotten.short} (${r.forgotten.path}): that conflict will be asked about again${r.hunks ? ` (with the ${r.hunks} region${r.hunks === 1 ? '' : 's'} remembered with it)` : ''}.`)
       }
-      const rows = await client.resolutions(needQuilt(), pos[0])
+      const rows = await client.resolutions(needQuilt(), pos[0], { hunks: !!flags['--hunks'] })
       return print(rows, describeResolutions(rows))
     }
     case 'blame': {
@@ -475,29 +948,63 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       const at = arg.lastIndexOf('@')
       const [p, rev] = at > 0 ? [arg.slice(0, at), arg.slice(at + 1)] : [arg, pos[1] || (block?.square ? block.square_short : 'main')]
       const rel = found && at < 0 ? path.relative(found.dir, path.resolve(cwd, p)).split(path.sep).join('/') : p
-      const r = await client.blame(needQuilt(), rev, rel)
+      // -L a,b: a span; --ignore-rev <rev> (again for more; .seam-blame-ignore is read too); -M: moves keep their origin; --reverse <rev>
+      const ignore = typeof flags['--ignore-rev'] === 'string' ? flags['--ignore-rev'].split(',').map((x) => x.trim()).filter(Boolean) : []
+      const r = await client.blame(needQuilt(), rev, rel, { ...(flags['-L'] ? { range: String(flags['-L']) } : {}), ...(ignore.length ? { ignore } : {}), ...(flags['-M'] ? { moves: true } : {}), ...(flags['--reverse'] ? { reverse: String(flags['--reverse']) } : {}) })
       return print(r, describeBlame(r))
     }
     case 'cat': {
       const arg = pos[0] || ''
       const at = arg.lastIndexOf('@')
       const [p, rev] = at > 0 ? [arg.slice(0, at), arg.slice(at + 1)] : [arg, 'main']
-      const r = await client.cat(needQuilt(), rev, p, { format: flags['--format'] || 'diff' })
+      const ranged = flags['--offset'] != null || flags['--length'] != null
+      let r
+      try {
+        r = await client.cat(needQuilt(), rev, p, { format: flags['--format'] || conflictStyle(), ...(flags['--offset'] != null ? { offset: flags['--offset'] } : {}), ...(flags['--length'] != null ? { length: flags['--length'] } : {}) })
+      } catch (err) {
+        // A file too large for one JSON answer (10) streams to stdout as it comes.
+        if (err.code !== 'too_large' || json || ranged) throw err
+        const s = await client.catRaw(needQuilt(), rev, p)
+        for await (const piece of s.body) if (!process.stdout.write(piece)) await new Promise((resolve) => process.stdout.once('drain', resolve))
+        return
+      }
       if (json) return print(r, '')
-      process.stdout.write(Buffer.from(r.content, 'base64'))
+      process.stdout.write(await catBytes(client, needQuilt(), r, r.sealed ? await codecFor(client, needQuilt()) : null))
       return
     }
     case 'ls': {
       const r = await client.tree(needQuilt(), pos[0] || 'main', pos.slice(1).concat(paths))
       return print(r, r.entries.map((e) => `${e.mode}\t${e.blob ? e.blob.slice(0, 12) : e.term.slice(0, 12)}\t${e.path}`).join('\n'))
     }
+    case 'github': {
+      // GitHub through the Seam app: what it reaches, and importing (and following) a repository.
+      if (pos[0] === 'import') {
+        if (!pos[1] || !flags['--installation']) throw new Error('seam github import <owner/name> --installation <id> [--into <slug>] [--no-follow]')
+        const r = await client.importGithub({ installation_id: flags['--installation'], repo: pos[1], slug: flags['--into'] || undefined, follow: !flags['--no-follow'] })
+        return print(r, `Importing ${pos[1]} (import ${r.id})${r.follow ? ', following it: GitHub tells Seam of every push' : ''}. seam import status ${r.id}`)
+      }
+      const g = await client.github()
+      if (!g.configured) return print(g, 'GitHub is not set up on this Seam server.')
+      if (!g.installations.length) return print(g, `No GitHub installations yet: install the Seam app from ${g.app.install_url}`)
+      return print(g, g.installations.map((i) => `${i.login} (installation ${i.id})\n${i.repos.map((r) => `  ${r.full_name}${r.private ? ' (private)' : ''}`).join('\n') || '  no repositories'}`).join('\n'))
+    }
     case 'import': {
+      // --authors <file>: a JSON object of git author email → member id (14, "Authors to members").
+      const readAuthors = () => {
+        if (!flags['--authors'] || flags['--authors'] === true) return undefined
+        try { return JSON.parse(fs.readFileSync(path.resolve(cwd, flags['--authors']), 'utf8')) } catch (err) { throw new Error(`--authors ${flags['--authors']}: a JSON file of { "email": "member id" } (${err.message})`) }
+      }
       // From a git remote, on the server, and following it (14): status and poke name the import.
       if (pos[0] === 'cutover') {
         if (!pos[1]) throw new Error('seam import cutover <import-id> [--credential <name>]')
         const r = await client.cutover(pos[1], { credential: flags['--credential'] || undefined })
         return print(r, `Cut over: import ${r.import.id} is done for good, its lines take merges in Seam, and main exports to ${r.export.target} after each merge.\nseam export status --quilt ${r.import.id}`)
       }
+      if (pos[0] === 'authors') {
+        if (!pos[1] || !flags['--authors']) throw new Error('seam import authors <import-id> --authors <file>')
+        const r = await client.answerImportAuthors(pos[1], { authors: readAuthors() })
+        return print(r, `Import ${r.id} has its authors and runs now.\nseam import status ${r.id}`)
+      }
       if (pos[0] === 'status' || pos[0] === 'poke') {
         if (!pos[1]) throw new Error(`seam import ${pos[0]} <import-id>`)
         const r = pos[0] === 'status' ? await client.importStatus(pos[1]) : await client.pokeImport(pos[1])
@@ -505,28 +1012,75 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       }
       if (pos[0] === 'git' && pos[1] && (flags['--follow'] || flags['--remote'] || /^(https?|ssh|git):\/\/|^[\w.-]+@[\w.-]+:/.test(pos[1]))) {
         const slug = flags['--into'] || path.basename(String(pos[1]).replace(/\.git$/, '').replace(/\/+$/, '')).toLowerCase().replace(/[^a-z0-9-]/g, '-')
-        const r = await client.startImport({ url: pos[1], slug, follow: !!flags['--follow'], interval: flags['--interval'] ? Number(flags['--interval']) : undefined, credential: flags['--credential'] || undefined })
-        return print(r, `Importing ${pos[1]} into ${slug} on the server (import ${r.id}).${r.follow ? ` It follows main and release/* every ${r.interval_s} s; they are frozen until cut-over.\nPoke it from a git hook or cron job with: curl -X POST -H 'Authorization: Bearer ${r.poke_secret}' <server>/v1/imports/${r.id}/poke  (the secret is shown once)` : ''}\nseam import status ${r.id}`)
+        const r = await client.startImport({ url: pos[1], slug, authors: readAuthors(), ask_authors: !!flags['--ask-authors'], follow: !!flags['--follow'], interval: flags['--interval'] ? Number(flags['--interval']) : undefined, credential: flags['--credential'] || undefined })
+        return print(r, `Importing ${pos[1]} into ${slug} on the server (import ${r.id}).${r.ask_authors ? ' It waits for you to answer its authors first (seam import status, then seam import authors).' : ''}${r.follow ? ` It follows main and release/* every ${r.interval_s} s; they are frozen until cut-over.\nPoke it from a git hook or cron job with: curl -X POST -H 'Authorization: Bearer ${r.poke_secret}' <server>/v1/imports/${r.id}/poke  (the secret is shown once)` : ''}\nseam import status ${r.id}`)
       }
-      if (pos[0] !== 'git' || !pos[1]) throw new Error('seam import git <path> [--into <quilt-slug>] [--validate] | seam import git <remote-url> [--into <slug>] [--follow] [--interval <s>] [--credential <name>] | seam import status|poke <import-id>')
+      if (pos[0] !== 'git' || !pos[1]) throw new Error('seam import git <path> [--into <quilt-slug>] [--validate] [--authors <file>] | seam import git <remote-url> [--into <slug>] [--authors <file>] [--ask-authors] [--follow] [--interval <s>] [--credential <name>] | seam import authors <import-id> --authors <file> | seam import status|poke <import-id>')
       const { importGit } = await import('./import-git.js')
       const repo = path.resolve(cwd, pos[1])
       if (!fs.existsSync(path.join(repo, '.git')) && !fs.existsSync(path.join(repo, 'HEAD'))) throw new Error(`${repo} is not a git repository`)
-      const r = await importGit(client, { repo, slug: flags['--into'] || path.basename(repo).toLowerCase().replace(/[^a-z0-9-]/g, '-'), log: (s) => { if (!json) out(s) }, validate: !!flags['--validate'], batch: Number(flags['--batch']) || 100 })
+      const r = await importGit(client, { repo, authors: readAuthors(), slug: flags['--into'] || path.basename(repo).toLowerCase().replace(/[^a-z0-9-]/g, '-'), log: (s) => { if (!json) out(s) }, validate: !!flags['--validate'], batch: Number(flags['--batch']) || 100 })
       return print(r, describeImport(r))
     }
     case 'export': {
       // To a git remote, on the server, after each merge (14): seam export remote <url> | status.
       if (pos[0] === 'remote' && pos[1]) {
-        const r = await client.setExport(needQuilt(), { target: pos[1], lines: flags['--line'] ? String(flags['--line']).split(',') : undefined, releases: !!flags['--releases'], credential: flags['--credential'] || undefined, scratch: !!flags['--scratch'], enabled: !flags['--off'] })
-        return print(r, r.enabled ? `Exporting ${r.lines.join(', ')} to ${r.target} after each merge${r.releases ? ', with release tags' : ''}. seam export status` : `The export to ${r.target} is off.`)
+        const r = await client.setExport(needQuilt(), { target: pos[1], lines: flags['--line'] ? String(flags['--line']).split(',') : undefined, releases: !!flags['--releases'], credential: flags['--credential'] || undefined, scratch: !!flags['--scratch'], enabled: !flags['--off'], lfs: flags['--lfs-url'] ? { url: String(flags['--lfs-url']), ...(flags['--lfs-threshold'] != null ? { threshold_bytes: Number(flags['--lfs-threshold']) } : {}) } : undefined })
+        return print(r, r.enabled ? `Exporting ${r.lines.join(', ')} to ${r.target} after each merge${r.releases ? ', with release tags' : ''}${r.lfs ? `, files over ${r.lfs.threshold_bytes} bytes to LFS at ${r.lfs.url}` : ''}. seam export status` : `The export to ${r.target} is off.`)
       }
       if (pos[0] === 'status') {
         const r = await client.exportStatus(needQuilt())
         const st = r.status || {}
-        return print(r, [`Export to ${r.target} (${r.lines.join(', ')}${r.releases ? ', releases' : ''}${r.enabled ? '' : ', off'}): ${st.state || 'idle'}${st.error ? ` - ${st.error}` : ''}`, ...Object.entries(st.lines || {}).map(([l, x]) => `  ${l}: patch ${x.patch_no} -> ${String(x.sha || '').slice(0, 12)}`)].join('\n'))
+        return print(r, [`Export to ${r.target} (${r.lines.join(', ')}${r.releases ? ', releases' : ''}${r.enabled ? '' : ', off'}): ${st.state || 'idle'}${st.error ? ` - ${st.error}` : ''}`, ...Object.entries(st.lines || {}).map(([l, x]) => `  ${l}: patch ${x.patch_no} -> ${String(x.sha || '').slice(0, 12)}`), ...(st.signing_key ? [`  signed with ${st.signing_key}`] : [])].join('\n'))
+      }
+      // One commit as a .tar.gz (git archive): seam export tarball [rev] [--paths a,b] [--out file].
+      if (pos[0] === 'tarball') {
+        const r = await client.tarball(needQuilt(), pos[1] || 'main', { paths: flags['--paths'] ? String(flags['--paths']).split(',') : undefined })
+        const file = path.resolve(cwd, flags['--out'] || r.name)
+        fs.writeFileSync(file, r.bytes)
+        return print({ file, commit: r.commit, bytes: r.bytes.length }, `Wrote ${pos[1] || 'main'} (${String(r.commit || 'empty').slice(0, 12)}) to ${path.relative(cwd, file) || file}: ${r.bytes.length} bytes.`)
+      }
+      // The whole quilt as one .tar (14, exit path; admin): seam export archive [--out file].
+      if (pos[0] === 'archive') {
+        const r = await client.exitArchive(needQuilt())
+        const file = path.resolve(cwd, flags['--out'] || r.name)
+        fs.writeFileSync(file, r.bytes)
+        return print({ file, bytes: r.bytes.length }, `Wrote the whole quilt to ${path.relative(cwd, file) || file}: ${r.bytes.length} bytes. Check it any time with seam export check ${path.relative(cwd, file) || file}`)
+      }
+      // A commit's files out of an archive, offline: seam export extract <file> [rev] --to <dir>.
+      if (pos[0] === 'extract') {
+        if (!pos[1] || !flags['--to']) throw new Error('seam export extract <file> [rev] --to <dir>')
+        const { readArchive, snapshotIn } = await import('./exit-archive.js')
+        const a = await readArchive(fs.readFileSync(path.resolve(cwd, pos[1])))
+        const s = snapshotIn(a, pos[2] || 'main')
+        const dir = path.resolve(cwd, flags['--to'])
+        for (const f of s.files) {
+          const file = path.resolve(dir, f.path)
+          if (!file.startsWith(dir + path.sep)) throw new Error(`${f.path} would land outside ${flags['--to']}`)
+          fs.mkdirSync(path.dirname(file), { recursive: true })
+          if (f.mode === 'symlink') fs.symlinkSync(f.bytes.toString('utf8'), file)
+          else fs.writeFileSync(file, f.bytes, { mode: f.mode === 'exec' ? 0o755 : 0o644 })
+        }
+        return print({ commit: s.commit, files: s.files.length, dir }, `Took ${s.files.length} files of ${pos[2] || 'main'} (${s.commit.slice(0, 12)}) out of ${pos[1]} into ${path.relative(cwd, dir) || dir}.`)
+      }
+      // A line's git history rebuilt from an archive, offline: seam export git <dir> --from <archive>.
+      if (pos[0] === 'git' && pos[1] && flags['--from']) {
+        const { readArchive, archiveClient } = await import('./exit-archive.js')
+        const { exportGit } = await import('./export-git.js')
+        const a = await readArchive(fs.readFileSync(path.resolve(cwd, flags['--from'])))
+        const r = await exportGit(archiveClient(a), { q: a.manifest.quilt.id, dir: path.resolve(cwd, pos[1]), line: flags['--line'] || 'main', branch: flags['--branch'] || undefined, log: (s) => { if (!json) out(s) } })
+        return print(r, `Rebuilt ${r.exported} patches of ${flags['--line'] || 'main'} from ${flags['--from']} as ${r.branch} in ${pos[1]}: ${r.sha || 'empty'} (patch ${r.patch_no}).`)
+      }
+      // Reads an archive offline and checks it: seam export check <file>.
+      if (pos[0] === 'check') {
+        if (!pos[1]) throw new Error('seam export check <file>')
+        const { readArchive } = await import('./exit-archive.js')
+        const a = await readArchive(fs.readFileSync(path.resolve(cwd, pos[1])))
+        const lines = [...a.lines.values()].map((l) => `${l.name} at patch ${l.patch_count || 0}`)
+        const r = { quilt: a.manifest.quilt, rows: a.log.length, commits: a.commits.size, packs: a.packs.length, members: a.members.length, lines: [...a.lines.values()].map((l) => ({ name: l.name, tip: l.tip, patch_count: l.patch_count || 0 })) }
+        return print(r, `${pos[1]} is whole: quilt ${a.manifest.quilt.slug || a.manifest.quilt.id}, ${r.rows} log rows, ${r.commits} commits, ${r.packs} packs, ${r.members} members. Lines: ${lines.join(', ') || 'none'}.`)
       }
-      if (pos[0] !== 'git' || !pos[1]) throw new Error('seam export git <dir> [--line main] [--branch <name>]')
+      if (pos[0] !== 'git' || !pos[1]) throw new Error('seam export git <dir> [--line main] [--branch <name>] | seam export tarball [rev] [--paths a,b] [--out file] | seam export archive [--out file] | seam export check <file> | seam export extract <file> [rev] --to <dir>')
       const { exportGit } = await import('./export-git.js')
       const r = await exportGit(client, { q: needQuilt(), dir: path.resolve(cwd, pos[1]), line: flags['--line'] || 'main', branch: flags['--branch'] || undefined, log: (s) => { if (!json) out(s) } })
       return print(r, r.exported ? `Exported ${r.exported} patches to ${r.branch} in ${pos[1]}: ${r.branch} is ${r.sha} (patch ${r.patch_no}).` : `Nothing new: ${r.branch} is ${r.sha || 'empty'} (patch ${r.patch_no}).`)