@heyquilt/seam 0.17.0 → 0.26.0

package/bin/seam.js

@@ -5,7 +5,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { spawn } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
-import { readAccount, login, logout, resume } from '../lib/account.js'
+import { readAccount, login, logout, resume, call } from '../lib/account.js'
 
 const here = path.dirname(fileURLToPath(import.meta.url))
 // In the repo the client is read straight from the server's src/quilts (never a stale build);
@@ -17,10 +17,15 @@ const { version } = JSON.parse(fs.readFileSync(path.join(here, '../package.json'
 const HELP = `seam ${version}: Seam, source control for people and their agents
 Docs: https://seam.heyquilt.com/docs
 
-  seam login [--no-browser]          Sign in with your heyquilt.com account
+  seam login [--no-browser]          Sign in with your Seam account (seam.heyquilt.com)
   seam logout | seam whoami
+  seam agent new <name> | list | key <name> | revoke <name> | relink [agent:<id>]   your agents and their keys
+  seam oauth client new <name> --redirect <uri> | list | revoke <client_id>   apps that ask people for access (OAuth 2, PKCE)
   seam quilts [new <slug> | show <q>]  Your quilts (repositories)
   seam import git <path> [--into <slug>]
+  seam import git <remote-url> --into <slug> [--follow] [--interval <s>] [--credential <name>]
+  seam import status <id> | seam import poke <id> | seam import cutover <id>   an import that follows git
+  seam export remote <url> --quilt <q> [--line main,release/*] [--releases] [--credential <name>] | seam export status
   seam square open "<title>" --quilt <q> [--dir <folder>]
   seam checkout <sq:id | revision> --quilt <q> [--dir <folder>] [-- paths]
   seam status | diff | commit -m "<message>"   in a block folder
@@ -35,8 +40,10 @@ Docs: https://seam.heyquilt.com/docs
   seam commit --amend [-m "<message>"]   change your square's last commit
   seam square open "<title>" --on sq:<id>   a square stacked on another
   seam claim <path|glob> [--note why] | unclaim <id>   files your square is working on
-  seam review approve|request-changes|comment|dismiss <sq>   seam line require <line> [--approvals n] [--checks a,b]
-  seam check <name> green|red [--square sq | --patch n]   report a check (a red one on a patch reverts it)
+  seam review approve|request-changes|comment|dismiss <sq>   seam line require <line> [--approvals n] [--checks a,b] [--runners ci=<member>]
+  seam check <name> green|red [--square sq | --patch n] [--run-key k]   report a check (a red one on a patch reverts it)
+  seam checks [--state queued] [--name ci] [--tier pre_merge|post_merge]   check runs Seam asked runners for
+  seam runner --check ci --run "npm test" [--quilt <q>] [--once]   run the checks Seam asks you for, on this machine
   seam resolutions [forget <key>]    conflicts settled before, settled the same way again
   seam bisect <bad> <good> --run "<check>"   seam grep <pattern> [rev] [--all]   seam describe [rev]   seam merge-base <a> <b>
   seam log --follow <path> | log -S <text>
@@ -44,6 +51,7 @@ Docs: https://seam.heyquilt.com/docs
   seam events [--webhook <url>]      What happened to your squares
   seam export git <dir>              Back to git
   seam mcp                           The same commands as MCP tools, for your AI tool
+  seam serve                         Run a Seam server (SEAM_AUTH_URL: its own accounts; SEAM_IDENTITY_URL: a sign-in service)
 
 Agents: set SEAM_TOKEN to the agent's key instead of signing in.`
 
@@ -63,7 +71,14 @@ async function main () {
   }
   if (cmd === 'logout') { const a = await logout(); return console.log(a ? `Signed out of ${a.account.email}.` : 'Not signed in.') }
   if (cmd === 'whoami') { const a = readAccount(); if (!a) { process.exitCode = 1; return console.log('Not signed in.') } return console.log(`${a.account.name} (${a.account.email})`) }
+  if (cmd === 'agent') return agentCommand(argv[0], argv[1])
+  if (cmd === 'oauth') return oauthCommand(argv)
   if (cmd === 'mcp') return mcp()
+  // The server is not in the package (it ships the client): it runs from Seam's source or its image.
+  if (cmd === 'serve') {
+    if (QUILTS === '../lib/quilts') fail('seam serve runs from Seam\'s source: node src/quilts/server.js in the repository, or the Dockerfile.seam image (docs/seam-service.md).')
+    return (await quilts('server.js')).serveFromEnv(process.env)
+  }
   const { SEAM_VERBS, runSeamCommand } = await quilts('cli.js')
   if (!SEAM_VERBS.has(cmd)) fail(`seam: '${cmd}' is not a seam command. See seam help.`)
   try {
@@ -79,6 +94,71 @@ async function main () {
   }
 }
 
+// `seam oauth client …`: OAuth apps the account registers (public clients: PKCE, no secret).
+async function oauthCommand (argv) {
+  const a = readAccount()
+  if (!a) fail('Not signed in: run seam login.')
+  const go = async (method, route, body) => {
+    try { return await call(method, route, body, a.token) } catch (err) {
+      if (err.status !== 401) throw err
+      const back = await resume().catch(() => null)
+      if (!back) fail('Your sign-in has ended. Run seam login.')
+      return call(method, route, body, back.token)
+    }
+  }
+  const [what, sub, ...rest] = argv
+  if (what !== 'client') fail('seam oauth client new <name> --redirect <uri> | list | revoke <client_id>')
+  if (sub === 'new') {
+    const redirects = []; const words = []
+    for (let i = 0; i < rest.length; i++) { if (rest[i] === '--redirect') redirects.push(rest[++i]); else words.push(rest[i]) }
+    if (!words.length || !redirects.length) fail('seam oauth client new <name> --redirect <uri> [--redirect <uri>]')
+    const c = await go('POST', '/v1/oauth/clients', { name: words.join(' '), redirect_uris: redirects })
+    return console.log(`${c.name}\n\n  client_id=${c.client_id}\n\nA public client: no secret, the app uses PKCE (S256). Send people to https://seam.heyquilt.com/oauth/authorize; trade the code at POST /oauth/token on Seam's API.`)
+  }
+  if (sub === 'revoke') { if (!rest[0]) fail('seam oauth client revoke <client_id>'); const c = await go('DELETE', `/v1/oauth/clients/${encodeURIComponent(rest[0])}`); return console.log(`Revoked ${c.name}: every token it was given has ended.`) }
+  if (!sub || sub === 'list') {
+    const { clients } = await go('GET', '/v1/oauth/clients')
+    if (!clients.length) return console.log('No apps yet: seam oauth client new <name> --redirect <uri>.')
+    for (const c of clients) console.log(`${c.client_id}  ${c.name}  ${c.redirect_uris.join(' ')}${c.revoked_at ? '  (revoked)' : ''}`)
+    return
+  }
+  fail(`seam oauth client: '${sub}' is not a command (new, list, revoke).`)
+}
+
+// `seam agent …`: an account's agents, each with its own key (SEAM_TOKEN for that agent).
+async function agentCommand (sub, name) {
+  const a = readAccount()
+  if (!a) fail('Not signed in: run seam login.')
+  const go = async (method, route, body) => {
+    try { return await call(method, route, body, a.token) } catch (err) {
+      if (err.status !== 401) throw err
+      const back = await resume().catch(() => null)
+      if (!back) fail('Your sign-in has ended. Run seam login.')
+      return call(method, route, body, back.token)
+    }
+  }
+  const showKey = (r) => console.log(`${r.name} (${r.member_id})\n\n  SEAM_TOKEN=${r.key}\n\nThis key is shown once. Give it to the agent as SEAM_TOKEN; seam agent key ${r.name} makes a new one and ends this one.`)
+  if (sub === 'new') { if (!name) fail('seam agent new <name>'); return showKey(await go('POST', '/v1/agents', { name })) }
+  if (sub === 'key') { if (!name) fail('seam agent key <name>'); return showKey(await go('POST', `/v1/agents/${encodeURIComponent(name)}/key`)) }
+  if (sub === 'revoke') { if (!name) fail('seam agent revoke <name>'); const r = await go('DELETE', `/v1/agents/${encodeURIComponent(name)}`); return console.log(`Revoked ${r.name}: its key no longer works. Its patches stay its own.`) }
+  if (sub === 'relink') {
+    if (!name) {
+      const { relink } = await go('GET', '/v1/agents')
+      if (!relink.length) return console.log('No old agents to re-link.')
+      for (const x of relink) console.log(`${x.member_id}  ${x.name || ''}  (seam agent relink ${x.member_id})`)
+      return
+    }
+    return showKey(await go('POST', '/v1/agents', { claim: name }))
+  }
+  if (!sub || sub === 'list') {
+    const { agents } = await go('GET', '/v1/agents')
+    if (!agents.length) return console.log('No agents yet: seam agent new <name>.')
+    for (const x of agents) console.log(`${x.name}  ${x.member_id}${x.revoked_at ? '  (revoked)' : ''}`)
+    return
+  }
+  fail(`seam agent: '${sub}' is not an agent command (new, list, key, revoke, relink).`)
+}
+
 // `seam mcp`: the source-control tools for an AI tool, over stdio, as the signed-in person (or SEAM_TOKEN).
 async function mcp () {
   const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js')

package/lib/account.js

@@ -1,22 +1,23 @@
-// seam's own sign-in, kept apart from the Quilt app's: an Ed25519 key for this computer in
-// ~/.seam/identity.json and the account token in ~/.seam/account.json (both private, 0600). It
-// signs in to the same heyquilt.com account through the API's device links: `seam login` shows a
-// page to approve, and later a lapsed token is renewed with the key, no browser.
+// seam's own sign-in to a Seam account: an Ed25519 key for this computer in ~/.seam/identity.json
+// and the computer's Seam key in ~/.seam/account.json (both private, 0600), through Seam's own
+// device flow: `seam login` shows a page on seam.heyquilt.com to approve, and later a lapsed key
+// is renewed with the computer's key, no browser.
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import crypto from 'node:crypto'
 
-export const API_URL = 'https://api.heyquilt.com'
+export const API_URL = 'https://api.seam.heyquilt.com'
+// Sign-in is on Seam's own server, like everything else.
 export const apiUrl = () => String(process.env.SEAM_API_URL || API_URL).replace(/\/+$/, '')
 export const seamHome = () => process.env.SEAM_HOME || path.join(os.homedir(), '.seam')
 const accountFile = () => path.join(seamHome(), 'account.json')
 const identityFile = () => path.join(seamHome(), 'identity.json')
 const signedOutFile = () => path.join(seamHome(), 'signed-out')
 
-// The API's signing contexts for linking a computer and signing it back in (src/identity.js).
-const DEVICE_LINK_CONTEXT = 'quilt-device-link-v1'
-const DEVICE_RESUME_CONTEXT = 'quilt-device-resume-v1'
+// Seam's signing contexts for linking a computer and signing it back in (src/quilts/keys.js).
+const DEVICE_LINK_CONTEXT = 'seam-device-link-v1'
+const DEVICE_RESUME_CONTEXT = 'seam-device-resume-v1'
 
 function writePrivate (file, data) {
   fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 })
@@ -57,15 +58,15 @@ function saveAccount (token, profile) {
   return data
 }
 
-async function call (method, route, body, token, extra = {}) {
+export async function call (method, route, body, token, extra = {}) {
   let res
   try {
     res = await fetch(apiUrl() + route, { method, headers: { 'content-type': 'application/json', ...(token ? { authorization: `Bearer ${token}` } : {}) }, body: body ? JSON.stringify(body) : undefined, ...extra })
   } catch (err) {
-    throw new Error(`Couldn't reach Quilt (${err.cause?.code || err.message}).`)
+    throw new Error(`Couldn't reach Seam (${err.cause?.code || err.message}).`)
   }
   const data = await res.json().catch(() => null)
-  if (!res.ok) throw Object.assign(new Error(data?.error || `Quilt answered ${res.status}.`), { status: res.status })
+  if (!res.ok) throw Object.assign(new Error(data?.error || `Seam answered ${res.status}.`), { status: res.status })
   return data || {}
 }
 

package/lib/quilts/cli.js

@@ -6,16 +6,43 @@ 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, describeRestore, describeReset, describeClean, describeLive, describeClaims, describeResolutions, describeLiveSet, describeMergeBase, describeGrep, describeBisect, describeCheck, describeReviews, describeReviewed, describeSquareCheck, describePolicy, describeKeys, describeTokens, describeNewToken } from './describe.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 { signWithLocalKey, localKey, makeLocalKey, signingKeyFile } from './signing.js'
 
-export const API_URL = 'https://api.heyquilt.com'
+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', 'resolutions', 'review', 'sign', 'key', 'token'])
+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'])
 
-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'])
+/** `ci=agent:ci,lint=agent:a+agent:b` → { ci: ['agent:ci'], lint: ['agent:a', 'agent:b'] }; `none` clears them. */
+export function parseRunners (text) {
+  if (text === 'none') return null
+  const out = {}
+  for (const part of text.split(',').map((x) => x.trim()).filter(Boolean)) {
+    const i = part.indexOf('=')
+    if (i < 1) throw new Error(`--runners: <check>=<member>[+<member>], e.g. ci=agent:ci (got ${part})`)
+    out[part.slice(0, i)] = part.slice(i + 1).split('+').map((m) => m.trim()).filter(Boolean)
+  }
+  return out
+}
+
+/** `e2e=post_merge,ci=pre_merge+post_merge` → { e2e: ['post_merge'], ci: ['pre_merge', 'post_merge'] }; `none` clears them. */
+export function parseTiers (text) {
+  if (text === 'none') return null
+  const out = {}
+  for (const part of text.split(',').map((x) => x.trim()).filter(Boolean)) {
+    const i = part.indexOf('=')
+    if (i < 1) throw new Error(`--tiers: <check>=<tier>[+<tier>], e.g. e2e=post_merge (got ${part})`)
+    out[part.slice(0, i)] = part.slice(i + 1).split('+').map((m) => m.trim()).filter(Boolean)
+  }
+  return out
+}
+
+/** `test/**,**\/*.test.js` → a list; `none` clears it. */
+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'])
 
 export function parse (argv) {
   const pos = []; const flags = {}; const paths = []
@@ -81,11 +108,18 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       if (sub === 'require') {
         if (!pos[1]) throw new Error('Which line? seam line require <line> [<approvals>] [--checks ci,lint]')
         const checks = flags['--checks'] === undefined ? undefined : String(flags['--checks']).split(',').map((c) => c.trim()).filter(Boolean)
-        if (pos[2] === undefined && checks === undefined) { 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 ci=agent:ci,lint=agent:ci+agent:lint: who runs each check (their verdicts count; anyone else's is advisory)
+        const runners = flags['--runners'] === undefined ? undefined : parseRunners(String(flags['--runners']))
+        // --tiers e2e=post_merge: where each check runs; --tests / --ci-config: globs for the affected set
+        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 } : {}) }
+        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]')
+      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/**]')
     }
     case 'tag':
     case 'release': {
@@ -126,6 +160,12 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       // seam square handoff [sq] --to <member> [--note text] | abandon [sq] | reopen [sq]
       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.`) }
+      // 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 === '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]
       if (sub === 'fold') {
@@ -164,6 +204,16 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       const r = await checkout(client, { quilt: needQuilt(), ...(isSquare ? { square: target } : { rev: target }), paths, dir, api })
       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()
+      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 })
+      return print({ runs: done }, done.length ? `Ran ${done.length} check run(s).` : 'Nothing queued.')
+    }
     case 'status': {
       if (!found) throw new Error('Not in a block folder (no .seam/block.json here or above).')
       const st = await blockStatus(client, found.dir, block)
@@ -190,15 +240,26 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
     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 === '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>]')
+        const r = await client.rerunCheck(needQuilt(), { check: status, ...(flags['--square'] ? { square: flags['--square'] } : { line: flags['--line'] || 'main' }), ...(flags['--commit'] ? { commit: flags['--commit'] } : {}) })
+        return print(r, describeRerun(r))
+      }
       if (!name || !['red', 'green', 'flaky'].includes(status)) throw new Error('seam check <name> red|green|flaky [--line <line>] [--patch <n>]')
       if (flags['--square']) {
         // seam check <name> green|red --square <sq>: a result for a square's latest commit (a line may require it before a merge)
-        const r = await client.reportSquareCheck(needQuilt(), flags['--square'], { check: name, status })
+        const r = await client.reportSquareCheck(needQuilt(), flags['--square'], { check: name, status, ...(flags['--run-key'] ? { run_key: flags['--run-key'] } : {}) })
         return print(r, describeSquareCheck(r))
       }
-      const r = await client.reportCheck(needQuilt(), flags['--line'] || 'main', { check: name, status, ...(flags['--patch'] != null ? { patch: Number(flags['--patch']) } : {}) })
+      const r = await client.reportCheck(needQuilt(), flags['--line'] || 'main', { check: name, status, ...(flags['--patch'] != null ? { patch: Number(flags['--patch']) } : {}), ...(flags['--run-key'] ? { run_key: flags['--run-key'] } : {}) })
       return print(r, describeCheck(r))
     }
+    case 'checks': {
+      // seam checks [--state queued] [--name ci] [--tier pre_merge|post_merge] [--line main] [--square sq]: the quilt's check runs
+      const r = await client.checkRuns(needQuilt(), { state: flags['--state'], name: flags['--name'], tier: flags['--tier'], line: flags['--line'], square: flags['--square'] })
+      return print(r, describeCheckRuns(r))
+    }
     case 'unclaim': {
       // seam unclaim <pattern|claim id>...
       if (!pos.length) throw new Error('Which claim? seam unclaim <pattern>')
@@ -431,7 +492,23 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       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 'import': {
-      if (pos[0] !== 'git' || !pos[1]) throw new Error('seam import git <path> [--into <quilt-slug>] [--validate]')
+      // 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] === '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])
+        return print(r, pos[0] === 'poke' ? `Poked: import ${r.id} fetches the remote now.` : describeImportRecord(r))
+      }
+      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}`)
+      }
+      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>')
       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`)
@@ -439,6 +516,16 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       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.`)
+      }
+      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'))
+      }
       if (pos[0] !== 'git' || !pos[1]) throw new Error('seam export git <dir> [--line main] [--branch <name>]')
       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) } })

package/lib/quilts/client.js

@@ -48,6 +48,7 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     amend: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/amend`, b),
     handoff: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/handoff`, b),
     abandon: (q, s, b = {}) => call('POST', `${Q(q)}/squares/${enc(s)}/abandon`, b),
+    squareMerged: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/merged`, b),
     reopen: (q, s) => call('POST', `${Q(q)}/squares/${enc(s)}/reopen`, {}),
     mergeSquare: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/merge`, b),
     fold: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/fold`, b),
@@ -91,6 +92,8 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     reviews: (q, sq) => call('GET', `${Q(q)}/squares/${enc(sq)}/reviews`),
     review: (q, sq, b) => call('POST', `${Q(q)}/squares/${enc(sq)}/reviews`, b),
     reportSquareCheck: (q, sq, b) => call('POST', `${Q(q)}/squares/${enc(sq)}/checks`, b),
+    rerunCheck: (q, { check, square, line, commit }) => call('POST', square ? `${Q(q)}/squares/${enc(square)}/checks/${enc(check)}/rerun` : `${Q(q)}/lines/${enc(line || 'main')}/checks/${enc(check)}/rerun`, commit ? { commit } : {}),
+    checkRuns: (q, o = {}) => call('GET', `${Q(q)}/checks${qs(o)}`),
     linePolicy: (q, line) => call('GET', `${Q(q)}/lines/${enc(line)}/policy`),
     setLinePolicy: (q, line, b) => call('PUT', `${Q(q)}/lines/${enc(line)}/policy`, b),
     claims: async (q, square) => (await call('GET', `${Q(q)}/claims${square ? `?square=${enc(square)}` : ''}`)).claims,
@@ -106,6 +109,12 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     uploadPack: (q, bytes) => call('POST', `${Q(q)}/packs`, bytes, { raw: true }),
     importCommits: (q, items, lines = []) => call('POST', `${Q(q)}/import/commits`, { items, ...(lines.length ? { lines } : {}) }),
     importKnown: (q, shas) => call('POST', `${Q(q)}/import/known`, { shas }),
+    setExport: (q, b) => call('PUT', `${Q(q)}/export`, b),
+    exportStatus: (q) => call('GET', `${Q(q)}/export`),
+    startImport: (b) => call('POST', '/v1/imports', b),
+    importStatus: (id) => call('GET', `/v1/imports/${enc(id)}`),
+    cutover: (id, b = {}) => call('POST', `/v1/imports/${enc(id)}/cutover`, b),
+    pokeImport: (id) => call('POST', `/v1/imports/${enc(id)}/poke`),
 
     /**
      * Uploads objects the server does not have yet ([{ kind, id, bytes }]), in packs of at most

package/lib/quilts/describe.js

@@ -117,6 +117,8 @@ export function describeEvents (r) {
     const p = e.payload || {}
     if (e.kind === 'patch.merged') return `#${e.event_seq} patch.merged: patch ${e.patch_no} by ${e.by.member_id} "${first(p.message || '')}" changed ${e.paths.join(', ')} in your square ${e.square_short}${p.would_conflict ? `; would conflict in ${p.would_conflict_paths.join(', ')}` : '; merges cleanly'}`
     if (e.kind === 'conflict.added') return `#${e.event_seq} conflict.added: ${p.path} (${p.kind}) in ${e.square_short}${p.caused_by && p.caused_by.patch_no ? `, against patch ${p.caused_by.patch_no}` : ''}; settle it and merge again`
+    if (e.kind === 'check.cancelled') return `#${e.event_seq} check.cancelled: stop ${p.check} (${p.tier}) on ${p.commit.slice(0, 12)}, run_key ${p.run_key}: ${p.superseded_by} replaces it`
+    if (e.kind === 'check.requested') return `#${e.event_seq} check.requested: run ${p.check} (${p.tier}) on ${p.commit.slice(0, 12)}${e.square_short ? ` in ${e.square_short}` : ` at ${e.line}:${p.patch_no}`}; report with run_key ${p.run_key}`
     if (e.kind === 'square.handoff') return `#${e.event_seq} square.handoff: ${e.square_short} from ${p.from} to ${p.to}${p.note ? `: ${p.note}` : ''}`
     return `#${e.event_seq} ${e.kind}`
   }
@@ -195,6 +197,7 @@ export function describeClaims (claims) {
 
 export function describeCheck (r) {
   const lines = [`${r.line}: merge window ${r.window} an hour${r.red.length ? ` (red: ${r.red.join(', ')})` : ''}.`]
+  if (r.advisory) lines.push('Your verdict is advisory: you are not one of the check\'s runners, so it changes nothing.')
   const v = r.revert
   if (v && v.reverted) lines.push(`Reverted patch ${r.line}:${v.patch_no} as patch ${r.line}:${v.revert_patch_no}.${v.fix_square ? ` The change is again in square ${v.fix_square.short}, held by ${v.fix_square.holder}: fix it there, commit, merge.` : ''}`)
   else if (v) lines.push(`Did not revert patch ${r.line}:${v.patch_no}: ${(v.refused && (v.refused.detail || v.refused.code)) || 'refused'}.${v.square ? ` The revert waits in square ${v.square.short}.` : ''}`)
@@ -238,11 +241,32 @@ export function describePolicy (p) {
   const parts = []
   if (p.approvals) parts.push(`${p.approvals} approval${p.approvals === 1 ? '' : 's'} of a square's latest commit from someone other than its holder`)
   if (p.checks?.length) parts.push(`check${p.checks.length === 1 ? '' : 's'} ${p.checks.join(', ')} green on it`)
-  return parts.length ? `${p.line} needs ${parts.join(' and ')} to take a merge.` : `${p.line} takes merges without approvals or checks.`
+  const run = Object.entries(p.runners || {}).map(([c, ms]) => `${c} by ${ms.join(', ')}`)
+  const runs = run.length ? ` Runners: ${run.join('; ')} (asked to run their checks; anyone else's verdict is advisory).` : ''
+  const tiers = Object.entries(p.tiers || {}).map(([c, ts]) => `${c} ${ts.length ? ts.join(' and ') : 'never'}`)
+  const tg = (tiers.length ? ` Tiers: ${tiers.join('; ')}.` : '') +
+    (p.tests?.length ? ` Tests: ${p.tests.join(', ')} (a pre-merge run names the ones a change reaches).` : '') +
+    (p.ci_config?.length ? ` CI config: ${p.ci_config.join(', ')} (a change there runs everything).` : '')
+  return (parts.length ? `${p.line} needs ${parts.join(' and ')} to take a merge.` : `${p.line} takes merges without approvals or checks.`) + runs + tg
+}
+
+/** A run's affected set in a few words. */
+const affectedWords = (a) => !a ? '' : a.confidence === 'all' ? '  runs all' : `  runs ${a.tests.length} test${a.tests.length === 1 ? '' : 's'}`
+
+/** Check runs, newest first: one per line. */
+export function describeCheckRuns (r) {
+  if (!r.runs.length) return 'No check runs.'
+  return r.runs.map((x) => `${x.name}  ${x.tier}  ${x.state}${x.verdict ? ` ${x.verdict}` : ''}${x.advisory ? ' (advisory)' : ''}${affectedWords(x.affected)}  ${x.commit.slice(0, 12)}${x.square ? ` ${x.square}` : ` ${x.line}${x.patch_no != null ? `:${x.patch_no}` : ''}`}  run_key ${x.run_key}${x.by ? `  by ${x.by}` : ''}`).join('\n')
+}
+
+/** A check asked to run again. */
+export function describeRerun (r) {
+  return `Asked ${r.check}'s runners to run it again (${r.tier}) on ${r.commit.slice(0, 12)}${r.square ? ` in ${r.square}` : ` at the tip of ${r.line}`}: run_key ${r.run_key}. An open run of it there is cancelled (check.cancelled).`
 }
 
 /** A check reported on a square. */
 export function describeSquareCheck (r) {
+  if (r.advisory) return `${r.check} is ${r.status} on ${r.square} (${r.head.slice(0, 12)}), advisory: you are not one of its runners (${(r.runners || []).join(', ')}), so it gates nothing.`
   const req = r.checks.filter((c) => c.required)
   const left = req.filter((c) => c.status !== 'green').map((c) => `${c.name} ${c.status}`)
   return `${r.check} is ${r.status} on ${r.square} (${r.head.slice(0, 12)}).${req.length ? (left.length ? ` Its line still needs: ${left.join(', ')}.` : ' Every check its line requires is green.') : ''}`
@@ -264,3 +288,9 @@ export function describeTokens (r) {
 }
 
 export const describeNewToken = (t) => `Made token ${t.name} (${t.level} on ${t.quilt}, id ${t.id}). Its secret, shown only this once:\n\n  ${t.token}\n\nSet it as SEAM_TOKEN (or send it as Authorization: Bearer <token>).`
+
+/** An import record (14) in a few lines. */
+export function describeImportRecord (r) {
+  const lines = (r.lines || []).map((l) => `  ${l.line}: ${l.patches} patches, git ${l.tip_sha ? l.tip_sha.slice(0, 12) : '(none)'}`)
+  return [`Import ${r.id} of ${r.source?.url}: ${r.state}${r.follow ? `, following every ${r.interval_s} s` : ''}${r.error ? ` (${r.error})` : ''}`, ...lines].join('\n')
+}

package/lib/quilts/import-git.js

@@ -115,9 +115,10 @@ function gitTags (repo) {
  * where only the commits it does not have yet are added. Returns { quilt, slug, commits,
  * patches, lines, tags, report, validated? }.
  */
-export async function importGit (client, { repo, slug, batch = 100, log = () => {}, validate = false, limit = 0, onlyHead = false, fresh = false }) {
+export async function importGit (client, { repo, slug, batch = 100, log = () => {}, validate = false, limit = 0, onlyHead = false, fresh = false, follow = false }) {
   const head = git(repo, ['rev-parse', 'HEAD']).toString().trim()
-  const refs = onlyHead ? [{ name: 'main', sha: head, git: 'HEAD' }] : branches(repo, head)
+  // follow: only main and release/* (14: the lines an import follows).
+  const refs = onlyHead ? [{ name: 'main', sha: head, git: 'HEAD' }] : branches(repo, head).filter((r) => !follow || r.name === 'main' || r.name.startsWith('release/'))
   const all = git(repo, ['rev-list', ...new Set(refs.map((r) => r.sha))]).toString().split('\n').filter(Boolean)
   const cat = catFile(repo)
   const report = []
@@ -150,6 +151,7 @@ export async function importGit (client, { repo, slug, batch = 100, log = () =>
     let pending = []
     let commits = 0; let patches = 0
     const lines = []
+    const rewritten = [] // git branches whose line no longer follows them (a rewritten ref)
 
     const flush = async () => {
       if (!items.length && !newLines.length) return
@@ -211,6 +213,7 @@ export async function importGit (client, { repo, slug, batch = 100, log = () =>
         lineTips.set(ref.name, base)
       } else if ((lineTips.get(ref.name) || null) !== base) {
         // The line moved on in the quilt (merges since the import), or git rewrote the branch.
+        rewritten.push(ref.name)
         if (chain.length) report.push({ kind: 'branch', ref: ref.git, note: `line ${ref.name} no longer follows git's branch; its ${chain.length} new commits were left out` })
         return
       }
@@ -282,7 +285,7 @@ export async function importGit (client, { repo, slug, batch = 100, log = () =>
         validated++
       }
     }
-    return { quilt: quilt.id, slug: quilt.slug, again, commits, patches, lines, tags: tagged, report, ...(validate ? { validated } : {}), tip: lineTips.get('main') }
+    return { quilt: quilt.id, slug: quilt.slug, again, commits, patches, lines, tags: tagged, report, rewritten, ...(validate ? { validated } : {}), tip: lineTips.get('main') }
   } finally {
     cat.close()
   }

package/lib/quilts/runner.js

@@ -0,0 +1,95 @@
+// seam runner (plans/quilt-source-control/13 "Checks"): a ready-made check runner anyone starts on
+// their own machine. It polls the runs Seam asked its member to run (GET /checks?state=queued),
+// checks each run's commit out into a fresh block folder, runs the command there, and reports the
+// verdict (exit 0 green, anything else red) on the run's run_key with a link to the log. A run
+// Seam cancels (check.cancelled: a newer head superseded it) is stopped and not reported.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { checkout } from './block.js'
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+const safe = (key) => key.replace(/[^\w.-]+/g, '_').slice(0, 180)
+
+/** The log link a verdict carries: --log-url with {run_key} and {file}, else the log file's own address. */
+export function logLink (template, runKey, file) {
+  if (!template) return 'file://' + file
+  return template.replaceAll('{run_key}', encodeURIComponent(runKey)).replaceAll('{file}', encodeURIComponent(path.basename(file)))
+}
+
+/** The environment a run's command gets: what to run and, when Seam knows, which tests the change reaches. */
+export function runEnv (run, base = process.env) {
+  const a = run.affected || { confidence: 'all' }
+  return {
+    ...base,
+    SEAM_CHECK: run.name, SEAM_TIER: run.tier, SEAM_COMMIT: run.commit, SEAM_RUN_KEY: run.run_key,
+    SEAM_LINE: run.line || '', SEAM_SQUARE: run.square || '',
+    SEAM_AFFECTED_CONFIDENCE: a.confidence, SEAM_AFFECTED_TESTS: a.confidence === 'all' ? '' : (a.tests || []).join('\n')
+  }
+}
+
+/**
+ * Runs checks for one quilt. { client, quilt, checks: ['ci'], run: 'npm test', dir (where block
+ * folders and logs go), api, once (handle what is queued now, then return), intervalMs, logUrl,
+ * say(line) }. Returns the runs it finished: [{ run_key, status | 'cancelled', url }].
+ */
+export async function runChecks ({ client, quilt, checks, run: command, dir = path.join(os.tmpdir(), 'seam-runner'), api, once = false, intervalMs = 5000, logUrl, say = () => {}, keep = false }) {
+  if (!checks?.length) throw new Error('seam runner needs --check <name>[,<name>]')
+  if (!command) throw new Error('seam runner needs --run "<command>"')
+  const logs = path.join(dir, 'logs')
+  fs.mkdirSync(logs, { recursive: true })
+  const done = []
+  const seen = new Set()
+  for (;;) {
+    const queued = []
+    for (const name of checks) queued.push(...(await client.checkRuns(quilt, { state: 'queued', name })).runs)
+    const todo = queued.filter((r) => !seen.has(r.run_key)).sort((a, b) => a.at - b.at)
+    for (const r of todo) {
+      seen.add(r.run_key)
+      done.push(await runOne(r))
+    }
+    if (once) return done
+    await sleep(intervalMs)
+  }
+
+  async function runOne (r) {
+    const work = fs.mkdtempSync(path.join(dir, 'run-'))
+    const file = path.join(logs, safe(r.run_key) + '.log')
+    const url = logLink(logUrl, r.run_key, file)
+    say(`${r.name} (${r.tier}) on ${r.commit.slice(0, 12)}${r.square ? ` in ${r.square}` : ` at ${r.line}`}: running`)
+    const out = fs.openSync(file, 'w')
+    let status
+    try {
+      fs.writeSync(out, `seam runner: ${r.name} ${r.tier} ${r.commit} run_key ${r.run_key}\n$ ${command}\n`)
+      await checkout(client, { quilt, rev: r.commit, dir: work, api })
+      const child = spawn(command, { cwd: work, shell: true, env: runEnv(r), stdio: ['ignore', out, out], detached: process.platform !== 'win32' })
+      const exited = new Promise((resolve) => child.on('close', (code) => resolve(code)))
+      let cancelled = false
+      for (;;) {
+        const code = await Promise.race([exited, sleep(Math.min(intervalMs, 2000)).then(() => undefined)])
+        if (code !== undefined) { status = code === 0 ? 'green' : 'red'; break }
+        const gone = (await client.checkRuns(quilt, { state: 'cancelled', name: r.name, limit: 50 })).runs.some((x) => x.run_key === r.run_key)
+        if (gone && !cancelled) {
+          cancelled = true
+          try { process.kill(process.platform !== 'win32' ? -child.pid : child.pid, 'SIGTERM') } catch { child.kill('SIGTERM') }
+        }
+        if (cancelled) { await exited; status = 'cancelled'; break }
+      }
+    } catch (err) {
+      fs.writeSync(out, `\nseam runner: ${err.message}\n`)
+      status = 'red'
+    } finally {
+      fs.writeSync(out, `\nseam runner: ${status}\n`)
+      fs.closeSync(out)
+      if (!keep) fs.rmSync(work, { recursive: true, force: true })
+    }
+    if (status !== 'cancelled') {
+      const body = { check: r.name, status, run_key: r.run_key, url }
+      if (r.tier === 'pre_merge' && r.square) await client.reportSquareCheck(quilt, r.square, { ...body, head: r.commit })
+      else await client.reportCheck(quilt, r.line, body)
+    }
+    say(`${r.name} on ${r.commit.slice(0, 12)}: ${status} (log ${url})`)
+    return { run_key: r.run_key, status, url }
+  }
+}

package/lib/quilts/tools.js

@@ -8,11 +8,11 @@
 // quilt and square, and seam_commit takes the files' new contents.
 import path from 'node:path'
 import { z } from 'zod'
-import { describeLog, describeShow, describeDiff, describeBlame, describeStatus, describeMerge, describeWrite, describeSquare, describeSquareStatus, describeEvents, describeTag, describeRelease, describeImport, describeRestore, describeReset, describeClean, describeLive, describeClaims, describeResolutions, describeLiveSet, describeMergeBase, describeGrep, describeBisect, describeCheck, describeReviews, describeReviewed, describeSquareCheck, describePolicy, describeKeys, describeTokens, describeNewToken } from './describe.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 { signWithLocalKey, localKey, makeLocalKey, signingKeyFile } from './signing.js'
 import { status as blockStatus, commitFolder, amendFolder, syncTo, restore, reset, clean, localChanges } from './block.js'
 
-export const SEAM_TOOLS = ['seam_quilts', 'seam_open_square', 'seam_squares', 'seam_log', 'seam_show', 'seam_diff', 'seam_blame', 'seam_cat', 'seam_ls', 'seam_commit', 'seam_merge', 'seam_rebase', 'seam_revert', 'seam_cherry_pick', 'seam_resolve', 'seam_square_status', 'seam_square_handoff', 'seam_abandon', 'seam_reopen', 'seam_fold', 'seam_split', 'seam_events', 'seam_events_webhook', 'seam_line_list', 'seam_line_new', 'seam_line_freeze', 'seam_line_unfreeze', 'seam_line_require', 'seam_reviews', 'seam_review', 'seam_tag_list', 'seam_tag', 'seam_release_list', 'seam_release', 'seam_import_git', 'seam_restore', 'seam_reset', 'seam_clean', 'seam_live', 'seam_live_set', 'seam_bisect', 'seam_grep', 'seam_search', 'seam_describe', 'seam_merge_base', 'seam_claims', 'seam_claim', 'seam_unclaim', 'seam_check', 'seam_resolutions', 'seam_forget_resolution', 'seam_sign', 'seam_keys', 'seam_key_add', 'seam_key_remove', 'seam_token_list', 'seam_token_new', 'seam_token_revoke']
+export const SEAM_TOOLS = ['seam_quilts', 'seam_open_square', 'seam_squares', 'seam_log', 'seam_show', 'seam_diff', 'seam_blame', 'seam_cat', 'seam_ls', 'seam_commit', 'seam_merge', 'seam_rebase', 'seam_revert', 'seam_cherry_pick', 'seam_resolve', 'seam_square_status', 'seam_square_handoff', 'seam_abandon', 'seam_square_merged', 'seam_reopen', 'seam_fold', 'seam_split', 'seam_events', 'seam_events_webhook', 'seam_line_list', 'seam_line_new', 'seam_line_freeze', 'seam_line_unfreeze', 'seam_line_require', 'seam_reviews', 'seam_review', 'seam_tag_list', 'seam_tag', 'seam_release_list', 'seam_release', 'seam_import_git', 'seam_import_remote', 'seam_import_status', 'seam_import_poke', 'seam_import_cutover', 'seam_export_remote', 'seam_export_status', 'seam_restore', 'seam_reset', 'seam_clean', 'seam_live', 'seam_live_set', 'seam_bisect', 'seam_grep', 'seam_search', 'seam_describe', 'seam_merge_base', 'seam_claims', 'seam_claim', 'seam_unclaim', 'seam_check', 'seam_resolutions', 'seam_forget_resolution', 'seam_sign', 'seam_keys', 'seam_key_add', 'seam_key_remove', 'seam_token_list', 'seam_token_new', 'seam_token_revoke', 'seam_checks', 'seam_check_rerun']
 
 /** What every agent is told about source control, in each MCP's instructions. */
 export const SEAM_GUIDE = 'Quilt source control (quilts): a quilt is a repository on the Quilt server; you work in a square (your own branch and working copy), commit save points in it, and merge it into main, where it becomes a patch. ' +
@@ -32,6 +32,8 @@ export const SEAM_DESCRIPTIONS = {
   seam_review: 'Reviews a square: kind approve, request_changes (say what in body), comment (body; path and line put it on a line of a file at the square\'s head) or dismiss (takes back your verdict). Nobody approves a square they or the person they work for opened or hold. An approval counts for the square\'s latest commit only.',
   seam_claims: 'The claims that hold now: which square is working on which paths, who, and why (square: only that square\'s).',
   seam_claim: 'Claims paths (patterns: files, folders or globs like src/api/**) for your square, so writes to them from other squares on its line are refused until your square merges or you let go. note says what for. Claim before a larger change across several files.',
+  seam_check_rerun: 'Asks a check\'s runners to run it again: with square, on that square\'s latest commit (pre_merge); with line, on the line\'s tip (post_merge); or on commit. A run of it still open there is cancelled (check.cancelled to its runners). Returns the new run_key.',
+  seam_checks: 'The quilt\'s check runs, newest first (filter by state, name, tier, line, square). A runner polls state "queued" for the checks its line\'s policy names it for (or gets check.requested events), runs each on its commit and reports with seam_check and the run\'s run_key.',
   seam_check: 'Reports a post-merge check on a line (status red, green or flaky; a red check halves the line\'s merge window, green restores it). With patch (the patch number it failed at, found for example with seam_bisect) a red check reverts that patch on the line by itself and opens a square holding the change again for its holder to fix. With square instead, the result (green or red) is for that square\'s latest commit, which its line may require green before a merge.',
   seam_unclaim: 'Lets go of claims on your square (patterns: the patterns or claim ids).',
   seam_live_set: 'Shares your square\'s uncommitted work so others can read it as sq:<id>:live before you commit: in a block folder the folder\'s changed files; elsewhere files: [{ path, content }] and delete: [paths]. Each call replaces what was shared; none clears it. It is not a commit: seam_commit keeps work.',
@@ -44,6 +46,12 @@ export const SEAM_DESCRIPTIONS = {
   seam_line_freeze: 'Freezes a line (admins): merges into it are refused with line_frozen until seam_line_unfreeze.',
   seam_line_unfreeze: 'Unfreezes a line (admins): it takes merges again.',
   seam_tag_list: 'The quilt\'s tags: name, commit, the patch it is, and whether it is a release.',
+  seam_import_remote: 'Imports a git remote (https:// or ssh) into a new quilt on the server. With follow, it keeps taking new commits on main and release/* every interval (and on seam_import_poke) and freezes those lines until cut-over, because git stays the authority. Returns the import id and its poke secret (shown once).',
+  seam_export_remote: 'Exports lines of a quilt to a git remote (admins) after each merge on them, as fast-forwards that are never forced; releases: true pushes release tags too. While an import follows git, only to a scratch remote (scratch: true).',
+  seam_export_status: 'The export to a git remote: its target, lines, state (idle, ok, retrying, refused), each line\'s last exported patch and sha, and the last error.',
+  seam_import_cutover: 'Ends a following import for good (admins): a last pass, a check that the remote\'s tips equal the imported ones, then main and release/* take merges in Seam and main exports to the source after each merge. Refuses with remote_moved if git moved.',
+  seam_import_status: 'An import from a git remote: its state (reading, following, done, failed), its lines with their git tips, and its last error.',
+  seam_import_poke: 'Makes a following import fetch its git remote now instead of at its next interval.',
   seam_import_git: 'Imports a git repository on this computer into a quilt: HEAD\'s branch as main, every other branch as a line of its name, every tag, submodules as gitlink entries. Run it again into the same quilt to add only the new commits.',
   seam_sign: 'Signs a commit you made (rev, default your square\'s head) with your Ed25519 key, so seam_log with show_signature shows it as yours. With no signature, signs with this computer\'s key (seam_key_add makes one); a hosted agent signs the text "seam-commit <commit id>\\n" itself and passes key and signature (base64).',
   seam_keys: 'Your signing keys (or member\'s): their ids, names, and when each was added or removed.',
@@ -59,9 +67,10 @@ export const SEAM_DESCRIPTIONS = {
   seam_squares: 'The open squares of a quilt, with holder, head, how far behind main each is and its conflicted paths. all: true for merged and abandoned ones too.',
   seam_square_status: 'One square as the server sees it (head, behind_by, conflicted paths), the patches merged under it that changed its files, and which files would conflict if merged now; in a block folder also the files changed since the last commit.',
   seam_square_handoff: 'Hands your square to another member (to), with a note on what is done and what is left. You stop being able to commit to it.',
+  seam_square_merged: 'Closes an open square whose work a person put into git by hand while an import follows git, when the follower could not match it (the diff was edited on the way). Admins; git_sha is the imported git commit that holds the work.',
   seam_abandon: 'Abandons a square whose work is not wanted. Its commits stay readable and seam_reopen brings it back.',
   seam_reopen: 'Reopens an abandoned square; you become its holder.',
-  seam_events: 'What happened to your work since you last looked: patch.merged (a patch changed files your open square changed, and whether your merge would now conflict), conflict.added (a conflict was kept in your square), square.handoff. Pass after (the cursor from the last answer) to get only new ones.',
+  seam_events: 'What happened to your work since you last looked: patch.merged (a patch changed files your open square changed, and whether your merge would now conflict), conflict.added (a conflict was kept in your square), square.handoff, check.requested (you run a check a line names you for: run it on the commit and report with seam_check and its run_key). Pass after (the cursor from the last answer) to get only new ones.',
   seam_events_webhook: 'Has the quilt server POST your events to a URL (signed with HMAC-SHA256 over <timestamp>.<body>, retried 3 times), so you are woken instead of polling: url, events (default all), secret (made for you if left out). url: "off" removes it.',
   seam_fold: 'Folds a square (square) into another square you hold (into): its work becomes one commit there and the square closes. Overlapping changes become conflict markers in the target.',
   seam_split: 'Splits your square by paths: groups: [[paths], ...], each group moves to a new square (same base) as one commit; the largest group, and paths no group names, stay in this square.',
@@ -88,12 +97,12 @@ export const SEAM_DESCRIPTIONS = {
 
 export const SEAM_INPUTS = {
   seam_live: { quilt: QUILT, square: SQUARE },
-  seam_line_require: { quilt: QUILT, line: z.string().max(120), approvals: z.number().int().min(0).max(20).optional(), checks: z.array(z.string().max(100)).max(20).optional().describe('Check names that must be green on a square\'s latest commit, e.g. ["ci"]; [] for none') },
+  seam_line_require: { quilt: QUILT, line: z.string().max(120), approvals: z.number().int().min(0).max(20).optional(), checks: z.array(z.string().max(100)).max(20).optional().describe('Check names that must be green on a square\'s latest commit, e.g. ["ci"]; [] for none'), runners: z.record(z.string().max(100), z.array(z.string().max(200)).max(20)).optional().describe('Who runs each check, e.g. {"ci": ["agent:ci"]}: they are asked to run it (check.requested) and only their verdicts count'), tiers: z.record(z.string().max(100), z.array(z.enum(['pre_merge', 'post_merge'])).max(2)).optional().describe('Where each check runs, e.g. {"e2e": ["post_merge"]}; default: a required check runs pre_merge on the square, a check with runners runs post_merge on the line'), tests: z.array(z.string().max(300)).max(50).optional().describe('Globs of the line\'s test files, e.g. ["test/**"]: a pre-merge check.requested names the tests a change reaches (affected)'), ci_config: z.array(z.string().max(300)).max(50).optional().describe('Globs of ci config: a change there makes affected confidence "all"') },
   seam_reviews: { quilt: QUILT, square: SQUARE },
   seam_review: { quilt: QUILT, square: SQUARE, kind: z.enum(['approve', 'request_changes', 'comment', 'dismiss']), body: z.string().max(20000).optional(), path: z.string().max(1000).optional().describe('A file, for a comment on it'), line: z.number().int().min(1).optional().describe('A line of that file at the square\'s head') },
   seam_claims: { quilt: QUILT, square: SQUARE },
   seam_claim: { quilt: QUILT, square: SQUARE, patterns: z.array(z.string().max(500)).min(1).max(50).describe('Files, folders or globs, e.g. src/api/** or README.md'), note: z.string().max(300).optional().describe('What you are doing with them') },
-  seam_check: { quilt: QUILT, check: z.string().max(200).describe('The check\'s name, e.g. ci'), status: z.enum(['red', 'green', 'flaky']), square: z.string().max(100).optional().describe('A square (sq:…): the result is for its latest commit, which a line may require green before a merge'), line: z.string().max(110).optional().describe('Default main'), patch: z.number().int().min(1).optional().describe('The patch number the check failed at: reverts it') },
+  seam_check: { quilt: QUILT, check: z.string().max(200).describe('The check\'s name, e.g. ci'), status: z.enum(['red', 'green', 'flaky']), run_key: z.string().max(600).optional().describe('The run_key of the check.requested event or run being answered'), url: z.string().max(2000).optional().describe('A link to the run\'s log (http(s) or file://), kept on the run'), square: z.string().max(100).optional().describe('A square (sq:…): the result is for its latest commit, which a line may require green before a merge'), line: z.string().max(110).optional().describe('Default main'), patch: z.number().int().min(1).optional().describe('The patch number the check failed at: reverts it') },
   seam_unclaim: { quilt: QUILT, square: SQUARE, patterns: z.array(z.string().max(500)).min(1).max(50).describe('The claimed patterns (or claim ids)') },
   seam_live_set: { quilt: QUILT, square: SQUARE, files: z.array(z.object({ path: z.string().max(1000), content: z.string(), base64: z.boolean().optional(), mode: z.enum(['file', 'exec']).optional() })).max(2000).optional(), delete: z.array(z.string().max(1000)).max(2000).optional() },
   seam_restore: { paths: z.array(z.string().max(1000)).min(1).max(200).describe('Files or folders, relative to the block folder ("." for all)') },
@@ -105,6 +114,12 @@ export const SEAM_INPUTS = {
   seam_line_freeze: { quilt: QUILT, line: z.string().max(110) },
   seam_line_unfreeze: { quilt: QUILT, line: z.string().max(110) },
   seam_tag_list: { quilt: QUILT },
+  seam_import_remote: { url: z.string().max(2000).describe('The git remote: https://, ssh:// or user@host:path'), into: z.string().max(63).describe('The new quilt\'s slug'), follow: z.boolean().optional().describe('Keep following main and release/* until cut-over'), interval: z.number().int().min(60).optional().describe('Seconds between follow passes (default 600)'), credential: z.string().max(100).optional().describe('The name of the server secret that reads the remote (user:token or a token)') },
+  seam_export_remote: { quilt: z.string().max(100).optional().describe('The quilt'), target: z.string().max(2000).describe('The git remote'), lines: z.array(z.string().max(100)).max(20).optional().describe('Lines to export (default ["main"]); release/* for every release line'), releases: z.boolean().optional().describe('Push release tags too'), credential: z.string().max(100).optional().describe('The name of the server secret that may push'), scratch: z.boolean().optional().describe('A scratch remote nothing pins a sha from'), enabled: z.boolean().optional().describe('false turns the export off') },
+  seam_export_status: { quilt: z.string().max(100).optional().describe('The quilt') },
+  seam_import_cutover: { id: z.string().max(100).describe('The import id'), credential: z.string().max(100).optional().describe('The server secret that may push to the source (default the import\'s)') },
+  seam_import_status: { id: z.string().max(100).describe('The import id') },
+  seam_import_poke: { id: z.string().max(100).describe('The import id') },
   seam_import_git: { path: z.string().max(1000).describe('The git repository\'s folder'), into: z.string().max(63).optional().describe('The quilt\'s slug (default the folder\'s name); a quilt an import made takes only the new commits'), validate: z.boolean().optional().describe('Compare every patch written with git\'s tree') },
   seam_sign: { quilt: QUILT, rev: REV, key: z.string().max(40).optional().describe('Your key id (ed25519:…), with signature'), signature: z.string().max(200).optional().describe('Base64 Ed25519 signature of "seam-commit <commit id>\\n"') },
   seam_keys: { member: z.string().max(200).optional().describe('Whose keys (default yours)') },
@@ -140,9 +155,12 @@ export const SEAM_INPUTS = {
   },
   seam_square_handoff: { quilt: QUILT, square: SQUARE, to: z.string().max(200).describe('The member to hand it to'), note: z.string().max(2000).optional() },
   seam_abandon: { quilt: QUILT, square: SQUARE },
+  seam_square_merged: { quilt: QUILT, square: SQUARE, git_sha: z.string().max(64).describe('The git commit (full sha) that holds the square\'s work') },
   seam_reopen: { quilt: QUILT, square: SQUARE },
-  seam_events: { quilt: QUILT, after: z.number().int().min(0).optional(), kinds: z.array(z.enum(['patch.merged', 'conflict.added', 'square.handoff'])).optional() },
-  seam_events_webhook: { quilt: QUILT, url: z.string().max(2000), events: z.array(z.enum(['patch.merged', 'conflict.added', 'square.handoff'])).optional(), secret: z.string().min(16).max(200).optional() },
+  seam_check_rerun: { quilt: QUILT, check: z.string().max(200).describe('The check\'s name, e.g. ci'), square: z.string().max(100).optional().describe('A square (sq:…): re-run on its latest commit'), line: z.string().max(110).optional().describe('A line: re-run on its tip (default main when no square)'), commit: z.string().max(80).optional().describe('A commit instead of the head or tip') },
+  seam_checks: { quilt: QUILT, state: z.enum(['queued', 'running', 'done', 'cancelled']).optional(), name: z.string().max(100).optional(), tier: z.enum(['pre_merge', 'post_merge']).optional(), line: z.string().max(120).optional(), square: z.string().max(100).optional() },
+  seam_events: { quilt: QUILT, after: z.number().int().min(0).optional(), kinds: z.array(z.enum(['patch.merged', 'conflict.added', 'square.handoff', 'check.requested'])).optional() },
+  seam_events_webhook: { quilt: QUILT, url: z.string().max(2000), events: z.array(z.enum(['patch.merged', 'conflict.added', 'square.handoff', 'check.requested'])).optional(), secret: z.string().min(16).max(200).optional() },
   seam_fold: { quilt: QUILT, square: SQUARE, into: z.string().max(100).describe('The square (sq:…) that takes the work'), message: z.string().max(65536).optional() },
   seam_split: { quilt: QUILT, square: SQUARE, groups: z.array(z.array(z.string().max(1000)).min(1).max(2000)).min(1).max(20).describe('Paths (files or directories) per new square'), titles: z.array(z.string().max(200)).max(20).optional() },
   seam_merge: { quilt: QUILT, square: SQUARE, from: z.string().max(200).optional().describe('Merge this square (sq:…) or revision into your square instead of merging your square into a line'), into: z.string().max(100).optional().describe('The line, default main'), message: z.string().max(65536).optional(), dry_run: z.boolean().optional(), on_conflict: z.enum(['rebase', 'leave']).optional() },
@@ -169,8 +187,9 @@ export async function runSeamTool (name, args, { client, found = null }) {
   try {
     switch (name) {
       case 'seam_line_require': {
-        if (args.approvals === undefined && args.checks === undefined) return describePolicy(await client.linePolicy(needQuilt(), args.line))
-        return describePolicy(await client.setLinePolicy(needQuilt(), args.line, { ...(args.approvals !== undefined ? { approvals: args.approvals } : {}), ...(args.checks ? { checks: args.checks } : {}) }))
+        const extra = Object.fromEntries(['tiers', 'tests', 'ci_config'].filter((k) => args[k] !== undefined).map((k) => [k, args[k]]))
+        if (args.approvals === undefined && args.checks === undefined && args.runners === undefined && !Object.keys(extra).length) return describePolicy(await client.linePolicy(needQuilt(), args.line))
+        return describePolicy(await client.setLinePolicy(needQuilt(), args.line, { ...(args.approvals !== undefined ? { approvals: args.approvals } : {}), ...(args.checks ? { checks: args.checks } : {}), ...(args.runners ? { runners: args.runners } : {}), ...extra }))
       }
       case 'seam_reviews': return describeReviews(await client.reviews(needQuilt(), needSquare()))
       case 'seam_review': return describeReviewed(await client.review(needQuilt(), needSquare(), { kind: args.kind, body: args.body || '', ...(args.path ? { path: args.path } : {}), ...(args.line ? { line: args.line } : {}) }))
@@ -180,8 +199,10 @@ export async function runSeamTool (name, args, { client, found = null }) {
         for (const p of args.patterns) made.push(await client.claim(needQuilt(), needSquare(), { pattern: p, note: args.note }))
         return 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 seam_unclaim.`).join('\n')
       }
-      case 'seam_check': if (args.square) return describeSquareCheck(await client.reportSquareCheck(needQuilt(), args.square, { check: args.check, status: args.status }))
-        return describeCheck(await client.reportCheck(needQuilt(), args.line || 'main', { check: args.check, status: args.status, ...(args.patch ? { patch: args.patch } : {}) }))
+      case 'seam_check': if (args.square) return describeSquareCheck(await client.reportSquareCheck(needQuilt(), args.square, { check: args.check, status: args.status, ...(args.run_key ? { run_key: args.run_key } : {}), ...(args.url ? { url: args.url } : {}) }))
+        return describeCheck(await client.reportCheck(needQuilt(), args.line || 'main', { check: args.check, status: args.status, ...(args.patch ? { patch: args.patch } : {}), ...(args.run_key ? { run_key: args.run_key } : {}), ...(args.url ? { url: args.url } : {}) }))
+      case 'seam_check_rerun': return describeRerun(await client.rerunCheck(needQuilt(), { check: args.check, ...(args.square ? { square: args.square } : { line: args.line || 'main' }), ...(args.commit ? { commit: args.commit } : {}) }))
+      case 'seam_checks': return describeCheckRuns(await client.checkRuns(needQuilt(), { state: args.state, name: args.name, tier: args.tier, line: args.line, square: args.square }))
       case 'seam_unclaim': {
         const out = []
         for (const p of args.patterns) out.push(await client.unclaim(needQuilt(), needSquare(), p))
@@ -260,6 +281,7 @@ export async function runSeamTool (name, args, { client, found = null }) {
         return signed(await client.commit(quilt, sq.id, { expect_head: sq.head, message: args.message, changes }), 'Committed')
       }
       case 'seam_square_handoff': { const sq = await client.handoff(needQuilt(), needSquare(), { to: args.to, note: args.note }); return `Handed ${sq.short} to ${sq.holder}.` }
+      case 'seam_square_merged': { const sq = await client.squareMerged(needQuilt(), needSquare(), { git_sha: args.git_sha }); return `${sq.short} is merged by hand: its work is patch ${sq.merged.patch_no} on ${sq.merged.line} (git ${sq.merged.git_sha.slice(0, 12)}).` }
       case 'seam_abandon': { const sq = await client.abandon(needQuilt(), needSquare(), inFolder ? { expect_head: block.head } : {}); return `Abandoned ${sq.short}; seam_reopen brings it back.` }
       case 'seam_reopen': { const sq = await client.reopen(needQuilt(), needSquare()); return `Reopened ${describeSquare(sq)}.` }
       case 'seam_events': return describeEvents(await client.events(needQuilt(), { after: args.after, kinds: args.kinds }))
@@ -288,6 +310,12 @@ export async function runSeamTool (name, args, { client, found = null }) {
       case 'seam_line_unfreeze': { const l = await client.unfreezeLine(needQuilt(), args.line); return `${l.name} takes merges again.` }
       case 'seam_tag_list': { const ts = await client.tags(needQuilt()); return ts.length ? ts.map(describeTag).join('\n') : 'No tags yet.' }
       case 'seam_release_list': { const rs = await client.releases(needQuilt()); return rs.length ? rs.map(describeRelease).join('\n') : 'No releases yet.' }
+      case 'seam_import_remote': { const r = await client.startImport({ url: args.url, slug: args.into, follow: !!args.follow, interval: args.interval, credential: args.credential }); return `Importing ${args.url} into ${args.into} (import ${r.id})${r.follow ? `, following every ${r.interval_s} s; poke secret ${r.poke_secret} (shown once)` : ''}.` }
+      case 'seam_export_remote': { const r = await client.setExport(needQuilt(), { target: args.target, lines: args.lines, releases: args.releases, credential: args.credential, scratch: args.scratch, enabled: args.enabled !== false }); return r.enabled ? `Exporting ${r.lines.join(', ')} to ${r.target} after each merge.` : `The export to ${r.target} is off.` }
+      case 'seam_export_status': { const r = await client.exportStatus(needQuilt()); return JSON.stringify({ target: r.target, lines: r.lines, releases: r.releases, enabled: r.enabled, status: r.status }, null, 2) }
+      case 'seam_import_cutover': { const r = await client.cutover(args.id, { credential: args.credential }); return `Cut over: import ${r.import.id} is done; main exports to ${r.export.target} after each merge.` }
+      case 'seam_import_status': return describeImportRecord(await client.importStatus(args.id))
+      case 'seam_import_poke': { const r = await client.pokeImport(args.id); return `Poked: import ${r.id} fetches the remote now.` }
       case 'seam_import_git': {
         const { importGit } = await import('./import-git.js')
         const { default: nodePath } = await import('node:path')

package/package.json

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