@heyquilt/seam 0.143.0 → 0.145.0

package/bin/seam.js

@@ -21,9 +21,11 @@ Docs: https://seam.heyquilt.com/docs
   seam logout | seam whoami
   seam computers [list | signout <id or name>]   computers signed in to your account (seam login)
   seam handle [<new>]                your name in your repos' addresses (<handle>/<repo>); with <new>, change it
-  seam account delete --confirm <your email>   delete your Seam account (your patches stay)
+  seam account delete --confirm <your email>   delete your Seam account (your patches stay; repos you deleted are purged)
+  seam account log [-n <count>] [--before <id>]   what happened to your repos: deleted, restored, purged
   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 oauth allowed [list | revoke <grant id>]   the apps you allowed into your account, and ending one
   seam quilts [new <slug> | show <q>]  Your quilts (repositories)
   seam import git <path> [--into <slug>] [--authors <file>]
   seam github [import <owner/name> --installation <id> [--into <slug>]]   from GitHub, followed
@@ -98,6 +100,9 @@ Docs: https://seam.heyquilt.com/docs
   seam org log <org> [-n <count>] [--before <id>]   what happened in an org: members, roles, teams, quilts (owners and admins)
   seam org team <org> <name> [<member>...]   an org's team, named org_team:<name> in its quilts' protections
   seam quilts new <slug> --org <org> | quilts move --quilt <q> --org <org>   a quilt that belongs to an org
+  seam quilts rename <new-slug> --quilt <q> [--title <name>]   a new address (<owner>/<new-slug>); the old one stays an alias
+  seam quilts delete <q> --confirm <owner/name>   delete a repo (its owner, or an org's admin); restorable for 7 days, then purged
+  seam quilts deleted [--org <org>] | restore <slug> [--org <org>]   Recently deleted, and bringing one back as it was
   seam quilts agents-make-lines on|off   whether agents may make lines, tags and releases
   seam quilts public on|off           anyone may read the quilt, signed in or not
   seam quilts add <email|member> [--level read|write|admin]   add a member; an email with no account yet is invited
@@ -139,7 +144,7 @@ async function main () {
     const r = await go('PUT', '/v1/me/handle', { handle: argv[0] })
     return console.log(`Your handle is ${r.handle}: your repos are ${r.handle}/<repo> now, and their old addresses stop working.`)
   }
-  if (cmd === 'account') {
+  if (cmd === 'account' && argv[0] !== 'log') {
     const i = argv.indexOf('--confirm')
     if (argv[0] !== 'delete' || i < 0 || !argv[i + 1]) fail('seam account delete --confirm <your email>')
     const r = await signedIn()('DELETE', `/v1/me?confirm=${encodeURIComponent(argv[i + 1])}`)
@@ -185,7 +190,16 @@ async function oauthCommand (argv) {
     }
   }
   const [what, sub, ...rest] = argv
-  if (what !== 'client') fail('seam oauth client new <name> --redirect <uri> | list | revoke <client_id>')
+  // The apps you allowed (GET /v1/me/grants): what each may do; revoking one ends its tokens.
+  if (what === 'allowed') {
+    if (sub === 'revoke') { if (!rest[0]) fail('seam oauth allowed revoke <grant id>'); await go('DELETE', `/v1/me/grants/${encodeURIComponent(rest[0])}`); return console.log(`Revoked: the app's tokens from that approval have ended. It asks you again to come back.`) }
+    if (sub && sub !== 'list') fail(`seam oauth allowed: '${sub}' is not a command (list, revoke).`)
+    const { grants } = await go('GET', '/v1/me/grants')
+    if (!grants.length) return console.log('You have allowed no apps.')
+    for (const g of grants) console.log(`${g.id}  ${g.client.name}  ${g.scopes.map((x) => { const q = g.quilts.find((y) => x === `quilt:${y.id}:${y.level}`); return q ? `${q.slug || q.id}:${q.level}` : x }).join(' ')}`)
+    return
+  }
+  if (what !== 'client') fail('seam oauth client new <name> --redirect <uri> | list | revoke <client_id> | seam oauth allowed [list | revoke <grant 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]) }

package/lib/quilts/block.js

@@ -892,10 +892,22 @@ export async function pull (client, dir, block) {
       const s = await toLineTip(client, dir, block, sq.line, tip)
       return { left: { square: short, state: sq.state }, line: sq.line, at: tip, written: s.written, merged: s.merged, conflicted: s.conflicted }
     }
+    // The square moved on the server since this folder last looked (the site's Merge brought its
+    // line in, conflicts kept in its new head; or a commit from another folder): the folder takes
+    // that head first, markers and all, as seam checkout would. Uncommitted edits stay (syncTo).
+    const caught = (sq.head || null) !== (block.head || null) ? { from: block.head || null, ...await syncTo(client, dir, block, sq.head || sq.base, { square: sq }) } : null
     const r = await client.rebase(block.quilt, block.square, { expect_head: block.head })
-    if (r.noop) return { rebased: false, noop: true, square: r.square }
-    const s = await syncTo(client, dir, block, r.square.head || r.square.base, { square: r.square })
-    return { rebased: true, square: r.square, result: r, written: s.written, merged: s.merged, conflicted: s.conflicted }
+    if (r.noop && !caught) return { rebased: false, noop: true, square: r.square }
+    const s = r.noop ? { written: 0, merged: [], conflicted: [] } : await syncTo(client, dir, block, r.square.head || r.square.base, { square: r.square })
+    const both = (k) => [...new Set([...(caught?.[k] || []), ...s[k]])].sort(cmpPath)
+    const conflicted = both('conflicted')
+    // The conflicts the square itself holds (terms in its head), apart from the folder's own clashes.
+    const held = Object.entries(block.files).filter(([p, f]) => f.term && !conflicted.includes(p)).map(([p]) => p).sort(cmpPath)
+    return {
+      rebased: !r.noop, square: r.square, ...(r.noop ? {} : { result: r }),
+      ...(caught ? { caught_up: { from: caught.from, to: sq.head || sq.base } } : {}),
+      written: (caught?.written || 0) + s.written, merged: both('merged'), conflicted, held
+    }
   }
   if (!isLineCheckout(block)) throw new Error('This folder holds one revision, not a line: seam checkout <line or square> moves it.')
   const to = (await client.show(block.quilt, block.line, { format: 'none' })).commit.id

package/lib/quilts/cli.js

@@ -9,7 +9,7 @@ import { quiltClient } from './client.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, describeBoth } from './describe.js'
+import { describeRebuild, describeOpened, describeBoth, describePull, describeDeletedQuilt, describeDeletedQuilts, describePersonLog } from './describe.js'
 import { findBlock, checkout, status as blockStatus, commitFolder, amendFolder, syncTo, localDiff, saveBlock, pull, toLineTip, restore, reset, clean, localChanges, bytesOf, livePatch, resolvePulled } 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, describeOrgLog, describeOrgDomain, describeApp, describeApps, describeAppKey, describeInstall, describeInstalls, describeRequest, describeRequests, describeOrgTeams, describeCheckRuns, describeRerun, describeAncestor, describeContains, describePipeline, describeWatches, describeSearch, describePublicReads } from './describe.js'
 import { verifyQuilt, describeVerify } from './attest.js'
@@ -21,7 +21,7 @@ import { signWithLocalKey, localKey, makeLocalKey, signingKeyFile } from './sign
 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', 'stack', 'claim', 'unclaim', 'check', 'checks', 'resolutions', 'review', 'sign', 'key', 'token', 'block', 'runner', 'protect', 'team', 'verify', 'redact', 'metrics', 'seal', 'policy', 'org', 'app', 'watch', 'search', 'contains', 'daemon', 'clone', 'pull'])
+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', 'app', 'watch', 'search', 'contains', 'daemon', 'clone', 'pull', 'account'])
 
 /** `ci=agent:ci,lint=agent:a+agent:b` → { ci: ['agent:ci'], lint: ['agent:a', 'agent:b'] }; `none` clears them. */
 export function parseRunners (text) {
@@ -83,7 +83,7 @@ export function agentTokenExtras (flags) {
   return out
 }
 
-const VALUE_FLAGS = new Set(['--repos', '--name', '--org', '--description', '--homepage', '--callback', '--setup', '--webhook', '--events', '--perm', '--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', '--before'])
+const VALUE_FLAGS = new Set(['--repos', '--name', '--org', '--description', '--homepage', '--callback', '--setup', '--webhook', '--events', '--perm', '--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', '--before', '--confirm'])
 
 export function parse (argv) {
   const pos = []; const flags = {}; const paths = []
@@ -147,6 +147,30 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         const r = await client.setQuiltOwner(needQuilt(), flags['--org'])
         return print(r, `${r.quilt} now belongs to ${r.org}.`)
       }
+      if (pos[0] === 'rename') {
+        // seam quilts rename <new-slug> --quilt <q> [--title <name>]: its address is <owner>/<new-slug> after.
+        if (!pos[1] && !flags['--title']) throw new Error('seam quilts rename <new-slug> --quilt <q> [--title <name>]')
+        const r = await client.renameQuilt(needQuilt(), { ...(pos[1] ? { slug: pos[1] } : {}), ...(flags['--title'] ? { name: flags['--title'] } : {}) })
+        return print(r, r.slug === r.was ? `${r.slug} is now called ${r.name}.` : `${r.was} is now ${r.path || r.slug}${r.name !== r.slug ? ` (${r.name})` : ''}. Links by its id keep working; its old address doesn't. In a block folder of it, nothing changes: the block names it by id.`)
+      }
+      if (pos[0] === 'delete') {
+        // seam quilts delete <q> --confirm <owner/name> (11.13): hidden at once, restored for 7 days, purged after.
+        const q = pos[1] || quilt
+        if (!q || !flags['--confirm']) throw new Error('seam quilts delete <q> --confirm <owner/name>: type the repo\'s address to delete it')
+        const r = await client.deleteQuilt(q, flags['--confirm'])
+        return print(r, describeDeletedQuilt(r))
+      }
+      if (pos[0] === 'deleted') {
+        // seam quilts deleted [--org <org>]: Recently deleted, yours or an org's (its admins and owners).
+        const r = await client.deletedQuilts({ org: flags['--org'] })
+        return print(r, describeDeletedQuilts(r, { org: flags['--org'] }))
+      }
+      if (pos[0] === 'restore') {
+        // seam quilts restore <slug|id|owner/name> [--org <org>]: back as it was, within 7 days of the delete.
+        if (!pos[1]) throw new Error('seam quilts restore <slug, id or owner/name> [--org <org>]')
+        const r = await client.undeleteQuilt(pos[1], { org: flags['--org'] })
+        return print(r, `Restored ${r.path || r.quilt}: it is back as it was. The squares the delete closed stay closed; seam square reopen <sq> --quilt ${r.quilt} brings one back.`)
+      }
       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')
@@ -345,12 +369,9 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
     }
     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 was = { ...block }
       const r = await pull(client, found.dir, block)
-      const kept = describeBoth(r)
-      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)
+      return print(r, describePull(r, was))
     }
     case 'checkout': {
       const target = pos[0]
@@ -683,6 +704,12 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       const r = await client.editApp(pos[1], b)
       return print(r, describeApp(r))
     }
+    case 'account': {
+      // seam account log [-n <count>] [--before <id>]: what happened to your repos (11.13). seam account delete is the seam package's.
+      if (pos[0] !== 'log') throw new Error('seam account log [-n <count>] [--before <id>] | seam account delete --confirm <your email>')
+      const r = await client.personLog({ limit: flags['-n'], before: flags['--before'] })
+      return print(r, describePersonLog(r))
+    }
     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'
@@ -1097,8 +1124,13 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
     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'], 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.`)
+        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, main_as: flags['--main-as'] || undefined, push: flags['--push'] || undefined, exclude: flags['--exclude'] ? String(flags['--exclude']).split(',').map((x) => x.trim()).filter(Boolean) : undefined })
+        return print(r, r.enabled ? `Exporting ${r.lines.join(', ')} to ${r.target} ${r.push === 'tag' ? 'up to the newest tagged patch' : 'after each merge'}${r.main_as && r.main_as !== 'main' ? `, main as ${r.main_as}` : ''}${r.releases ? ', with release tags' : ''}${r.exclude?.length ? `, without ${r.exclude.join(', ')}` : ''}${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.`)
+      }
+      // Runs the export now (admins): after fixing a remote, or without waiting for the next retry.
+      if (pos[0] === 'push') {
+        const r = await client.exportPush(needQuilt())
+        return print(r, `Pushing to ${r.target} now. seam export status`)
       }
       if (pos[0] === 'status') {
         const r = await client.exportStatus(needQuilt())

package/lib/quilts/client.js

@@ -237,6 +237,7 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     search: (o = {}) => call('GET', `/v1/search${qs(o)}`),
     searchCode: (q, o = {}) => call('GET', `${Q(q)}/search${qs(o)}`),
     bisect: (q, b) => call('POST', `${Q(q)}/bisect`, b),
+    lineLasts: (q, line = 'main', paths = []) => call('GET', `${Q(q)}/lines/${encodeURIComponent(line)}/lasts${qs({ paths: paths.join(',') })}`),
     linePatches: (q, line = 'main', o = {}) => call('GET', `${Q(q)}/lines/${encodeURIComponent(line)}/patches${qs(o)}`),
     diff: (q, o = {}) => call('GET', `${Q(q)}/diff${qs(o)}`),
     resolutions: async (q, p, { hunks = false } = {}) => (await call('GET', `${Q(q)}/resolutions${qs({ path: p || undefined, hunks: hunks ? 1 : undefined })}`)).resolutions,
@@ -345,6 +346,12 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     setOrgTeam: (o, name, members) => call('PUT', `/v1/orgs/${enc(o)}/teams/${enc(name)}`, { members }),
     setOrgMember: (o, member, role) => String(member).includes('@') ? call('POST', `/v1/orgs/${enc(o)}/members`, { email: member, role }) : call('PUT', `/v1/orgs/${enc(o)}/members/${enc(member)}`, { role }),
     setQuiltOwner: (q, org) => call('PUT', `${Q(q)}/owner`, { org }),
+    renameQuilt: (q, body) => call('PATCH', Q(q), body),
+    // Deleting a repo (11.13): confirm is its address, <owner>/<slug>; restored for 7 days by id, slug or address.
+    deleteQuilt: (q, confirm) => call('DELETE', `${Q(q)}${qs({ confirm })}`),
+    deletedQuilts: ({ org } = {}) => call('GET', org ? `/v1/orgs/${enc(org)}/deleted-quilts` : '/v1/me/deleted-quilts'),
+    undeleteQuilt: (q, { org } = {}) => call('POST', `${org ? `/v1/orgs/${enc(org)}` : '/v1/me'}/deleted-quilts/${enc(q)}/restore`, {}),
+    personLog: ({ limit, before } = {}) => call('GET', `/v1/me/log${qs({ limit, before })}`),
     setAgentsMakeLines: (q, allow) => call('PUT', `${Q(q)}/agents-make-lines`, { allow }),
     setPublic: (q, value) => call('PUT', `${Q(q)}/public`, { public: value }),
     setSealed: (q, value) => call('PUT', `${Q(q)}/sealed`, { sealed: value }),
@@ -372,6 +379,7 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     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`),
+    exportPush: (q) => call('POST', `${Q(q)}/export/push`, {}),
     startImport: (b) => call('POST', '/v1/imports', b),
     github: () => call('GET', '/v1/github'),
     importGithub: (b) => call('POST', '/v1/github/import', b),

package/lib/quilts/describe.js

@@ -19,20 +19,22 @@ export function describeSquare (s) {
 }
 
 export function describeLog (r, { oneline = false, graph = false } = {}) {
-  const more = r.cursor ? `(more: seam log … --cursor ${r.cursor})` : r.more ? (oneline ? '…' : '(more: seam log -n <count>)') : null
+  // A search that ran out of time (stopped: 'time') or of commits to look at ('scan') goes on with its cursor.
+  const early = r.partial ? (r.stopped === 'time' ? '(stopped early: the search ran out of time) ' : '(partial) ') : ''
+  const more = r.cursor ? (r.partial ? `${early}(search further: seam log … --cursor ${r.cursor})` : `(more: seam log … --cursor ${r.cursor})`) : r.more ? (oneline ? '…' : '(more: seam log -n <count>)') : null
   if (r.groups) {
     // group_by: git shortlog -s, with lines added and removed.
     if (!r.groups.length) return 'No commits.'
     const w = Math.max(...r.groups.map((g) => String(g.commits).length))
-    return [...r.groups.map((g) => `${String(g.commits).padStart(w + 2)}  ${g.key == null ? '(none)' : g.name ? `${g.name} <${g.key}>` : g.key}  +${g.added} -${g.removed}`), ...(more ? [`${r.partial ? '(partial) ' : ''}${more}`] : [])].join('\n')
+    return [...r.groups.map((g) => `${String(g.commits).padStart(w + 2)}  ${g.key == null ? '(none)' : g.name ? `${g.name} <${g.key}>` : g.key}  +${g.added} -${g.removed}`), ...(more ? [more] : [])].join('\n')
   }
-  if (!r.commits.length) return more ? `No commits on this page.\n${more}` : r.existed === false ? 'No commits: this path was never here.' : 'No commits.'
+  if (!r.commits.length) return more ? `${r.partial ? 'None found yet.' : 'No commits on this page.'}\n${more}` : r.existed === false ? 'No commits: this path was never here.' : 'No commits.'
   const mark = (c) => graph ? (c.parents.length > 1 ? '*   ' : c.hidden ? 'x ' : '* ') : ''
   const merged = (c) => (c.parent_squares || []).map((s) => `${graph ? '|\\  ' : ''}merged ${s.square_id ? `square ${s.square_id.slice(0, 8)}${s.title ? ` "${s.title}"` : ''}` : s.commit.slice(0, 12)}`)
   const lines = r.commits.map((c) => oneline
     ? [`${mark(c)}${c.short} ${c.patch ? `[${c.patch.line}:${c.patch.patch_no}] ` : ''}${first(c.message)}${r.follow && c.path && c.path !== r.follow ? `  (${c.path})` : ''}${c.hidden ? `  (hidden: replaced by ${c.predecessor_of.slice(0, 12)})` : ''}${c.signature ? `  (signature: ${c.signature.status})` : ''}`, ...merged(c)].join('\n')
     : [`${mark(c)}commit ${c.id}${c.patch ? ` (${patchName(c.patch)})` : ''}${c.hidden ? ` (hidden: replaced by ${c.predecessor_of.slice(0, 12)})` : ''}`, ...(c.parents.length > 1 ? [`Merge: ${c.parents.map((p) => p.slice(0, 12)).join(' ')}`, ...merged(c)] : []), `Square: ${c.square}`, ...(r.follow && c.path && c.path !== r.follow ? [`Path:   ${c.path}`] : []), `Author: ${c.author.name} <${c.author.member_id}>${c.author.tool ? ` via ${c.author.tool}` : ''}${c.on_behalf_of ? ` for ${c.on_behalf_of}` : ''}`, ...(c.task_id ? [`Task:   ${c.task_id}`] : []), ...(c.signature ? [describeSignature(c.signature)] : []), `Date:   ${when(c.authored_at)}`, '', ...String(c.message || '').split('\n').map((l) => `    ${l}`), ''].join('\n'))
-  if (more) lines.push(`${r.partial ? '(partial) ' : ''}${more}`)
+  if (more) lines.push(more)
   if (r.last_present !== undefined) lines.push(`This path is gone: it was last here in patch ${r.last_present}.`)
   return lines.join('\n')
 }
@@ -111,9 +113,24 @@ export function describeBoth (r, { diff = 'seam diff', resolve = 'seam resolve <
   const out = []
   if (r.merged?.length) out.push(`Merged upstream's changes into your edits to ${r.merged.join(', ')}: compare with ${diff}.`)
   if (r.conflicted?.length) out.push(`Conflict in ${r.conflicted.join(', ')} (changed on both sides): settle each by editing out the conflict markers, or with ${resolve}, then commit.`)
+  if (r.held?.length) out.push(`The square holds a conflict in ${r.held.join(', ')}: settle each by editing out the conflict markers, or with ${resolve}, then commit.`)
   return out.map((l) => '\n' + l).join('')
 }
 
+/**
+ * seam pull's answer (block.js pull), the same for the CLI and seam mcp. `block` is the folder's
+ * record before the pull; `diff` and `resolve` as describeBoth.
+ */
+export function describePull (r, block, names) {
+  const kept = describeBoth(r, names)
+  if (r.noop) return 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 `${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
+  const caught = r.caught_up ? `Brought ${r.square.short}'s new head in (${String(r.caught_up.to).slice(0, 12)}): the square moved on the server since this folder last looked.` : ''
+  if (r.rebased) return (caught ? caught + '\n' : '') + describeWrite(r.result, 'Rebased') + `\n${r.written} file(s) updated in the folder.` + kept
+  if (caught) return `${caught} ${r.written} file(s) updated; it sits on ${r.square.line}'s tip.` + kept
+  return `Pulled ${r.line} (now ${r.at.slice(0, 12)}): ${r.written} file(s) updated.` + kept
+}
+
 export function describeStatus (st) {
   const lines = []
   if (st.square) lines.push(describeSquareStatus(st.square, { prefix: 'On square ' }))
@@ -121,7 +138,7 @@ export function describeStatus (st) {
   else lines.push(`A read-only checkout of ${st.at ? st.at.slice(0, 12) : 'an empty line'}`)
   lines.push(`Block: ${st.paths.map((p) => p || '/').join(', ')} at ${st.at ? st.at.slice(0, 12) : '(empty)'}`)
   if (st.square_closed) lines.push(`This square is ${st.square_closed}: seam pull moves the folder to ${st.square.line}'s tip.`)
-  if (st.stale) lines.push('The square moved on since this folder last looked: run seam checkout ' + st.square.short + ' after committing.')
+  if (st.stale) lines.push('The square moved on since this folder last looked: seam pull brings its new head in (your uncommitted edits stay).')
   if (st.conflicted.length) lines.push(`Conflicted (edit and commit without the markers, or seam resolve --ours|--theirs): ${st.conflicted.join(', ')}`)
   if (!st.changes.length) lines.push('Nothing changed since the last commit.')
   else lines.push('Changes not yet committed:', ...st.changes.map((c) => `  ${c.status.padEnd(9)} ${c.path}`))
@@ -572,6 +589,31 @@ export const describeInstalls = (r) => r.installations.length ? r.installations.
 
 export const describeApps = (r) => r.apps.length ? r.apps.map((a) => describeApp(a)).join('\n\n') : 'No apps.'
 
+// The rows deleting a repo writes in its owner's log (11.13), the org's and a person's alike.
+const QUILT_LOG = {
+  quilt_deleted: (d) => `deleted the repo ${d.slug}${d.closed ? ` (closed ${d.closed} agent square${d.closed === 1 ? '' : 's'})` : ''}`,
+  quilt_restored: (d) => `restored the repo ${d.slug}`,
+  quilt_purged: (d) => `purged the repo ${d.slug}${d.reason === 'account_deleted' ? ' (the account was deleted)' : ', 7 days after it was deleted'}`
+}
+
+/** A deleted repo (11.13): when it is purged, and how to bring it back. */
+export function describeDeletedQuilt (r) {
+  const org = String(r.owner || '').startsWith('org:') && r.path ? r.path.split('/')[0] : null
+  return `Deleted ${r.path || r.quilt}: nobody reaches it now, and its address stays ${org ? `${org}'s` : 'yours'}. Restore it until ${when(r.purge_at)} with seam quilts restore ${r.quilt}${org ? ` --org ${org}` : ''}; after that it is purged.${r.closed_squares ? ` ${r.closed_squares} square${r.closed_squares === 1 ? '' : 's'} agents held closed.` : ''}`
+}
+
+/** Recently deleted: yours or an org's, each with when it is purged. */
+export function describeDeletedQuilts (r, { org } = {}) {
+  if (!r.quilts.length) return `No deleted repos${org ? ` in ${org}` : ''}: a deleted repo stays here 7 days.`
+  return r.quilts.map((q) => `${(q.path || q.slug).padEnd(24)}  deleted ${when(q.deleted_at)} by ${q.deleted_by}, purged ${when(q.purge_at)}  (seam quilts restore ${q.slug}${org ? ` --org ${org}` : ''})`).join('\n')
+}
+
+/** A person's log (11.13): what happened to their repos, newest first. */
+export function describePersonLog (r) {
+  if (!r.log.length) return 'Your log is empty.'
+  return [...r.log.map((x) => `${x.id.padStart(6)}  ${new Date(x.at).toISOString().slice(0, 16).replace('T', ' ')}  ${x.actor}  ${(QUILT_LOG[x.kind] || ((d) => `${x.kind} ${JSON.stringify(d)}`))(x.data || {})}`), ...(r.next ? [`More: seam account log --before ${r.next}`] : [])].join('\n')
+}
+
 export function describeOrgLog (r) {
   const what = (x) => {
     const d = x.data || {}
@@ -581,6 +623,7 @@ export function describeOrgLog (r) {
     if (x.kind.startsWith('app_')) return `${{ app_created: 'made', app_changed: 'changed', app_removed: 'removed', app_manager_added: `made ${d.member} a manager of`, app_manager_removed: `took ${d.member} off the managers of`, app_key_added: `made a key ${d.key_id} for`, app_key_removed: `removed the key ${d.key_id} of`, app_moved_in: `moved in from ${d.from}` }[x.kind] || x.kind}${x.kind.startsWith('app_key') || x.kind.startsWith('app_manager') || x.kind === 'app_moved_in' ? '' : ' the app'} ${d.handle} ${d.handle}${d.fields?.length ? ` (${d.fields.join(', ')})` : ''}`
     if (x.kind === 'app_installed' || x.kind === 'app_uninstalled' || x.kind.startsWith('install_')) return `${{ app_installed: 'installed', app_uninstalled: 'removed', install_requested: 'asked for', install_request_approved: 'approved the request for', install_request_declined: 'declined the request for', install_repos_changed: 'changed the repos of', install_paused: 'paused', install_permissions_accepted: 'accepted new permissions for', install_resumed: 'resumed' }[x.kind] || x.kind} the app ${d.handle}${['app_installed', 'install_repos_changed', 'install_requested'].includes(x.kind) ? ` (${d.repos ? d.repos.join(', ') : 'all repos'})` : ''}`
     if (x.kind.startsWith('domain_')) return `${{ domain_added: 'added', domain_verified: 'verified', domain_lost: 'lost (its record went away)', domain_removed: 'removed' }[x.kind] || x.kind} the domain ${d.domain}`
+    if (x.kind.startsWith('quilt_') && QUILT_LOG[x.kind]) return QUILT_LOG[x.kind](d)
     if (x.kind === 'quilt_in') return `moved the quilt ${d.slug} in (from ${d.from})`
     if (x.kind === 'quilt_out') return `moved the quilt ${d.slug} out (to ${d.to})`
     return `${x.kind} ${JSON.stringify(d)}`

package/lib/quilts/export-git.js

@@ -61,9 +61,10 @@ async function fetchBlobs (client, q, ids) {
  * missing). Returns { exported, patch_no, sha, branch }. With `sign` (export-sign.js exportKey), every
  * commit carries an SSH signature with that key. With `lfs` ({ threshold, upload(bytes) → pointer
  * text }, export-lfs.js), a file over the threshold or named by a `filter=lfs` line of the root
- * `.gitattributes` is written as an LFS pointer and its bytes uploaded.
+ * `.gitattributes` is written as an LFS pointer and its bytes uploaded. With `exclude` (a function
+ * of a path), the paths it names are left out of every exported tree (14, `exclude`).
  */
-export async function exportGit (client, { q, dir, line = 'main', branch, page = 200, sign = null, lfs = null, log = () => {} }) {
+export async function exportGit (client, { q, dir, line = 'main', branch, page = 200, sign = null, lfs = null, exclude = null, log = () => {} }) {
   branch = branch || line
   const gitDir = openRepo(dir)
   const stateFile = path.join(gitDir, 'quilt-export.json')
@@ -89,7 +90,7 @@ export async function exportGit (client, { q, dir, line = 'main', branch, page =
     if (version !== null && version !== r.version) throw new Error(`export format ${r.version} differs from the ${version} this branch was exported with: export to a new branch`)
     version = r.version; quiltId = r.quilt
     if (!r.patches.length) break
-    const blobs = await fetchBlobs(client, q, r.patches.flatMap((p) => p.changes.filter((c) => c.op === 'put').map((c) => c.blob)))
+    const blobs = await fetchBlobs(client, q, r.patches.flatMap((p) => p.changes.filter((c) => c.op === 'put' && !(exclude && exclude(c.path))).map((c) => c.blob)))
     const marksFile = path.join(gitDir, 'quilt-export.marks')
     const fi = fastImport(dir, marksFile)
     const send = async (s) => { const w = fi.write(s); if (w) await w }
@@ -116,6 +117,7 @@ export async function exportGit (client, { q, dir, line = 'main', branch, page =
         if (attrs) lfsMatch = attrs.op === 'delete' ? null : lfsPatterns(blobs.get(attrs.blob)?.toString('utf8'))
       }
       for (const c of p.changes) {
+        if (exclude && exclude(c.path)) continue
         const bytes = lfs && c.op === 'put' && (!c.mode || c.mode === 'file' || c.mode === 'exec') && c.path !== '.gitattributes' ? blobs.get(c.blob) : null
         if (bytes && (bytes.length > lfs.threshold || lfsMatch?.ignores(c.path))) {
           const pointer = await lfs.upload(bytes)

package/lib/quilts/tools.js

@@ -16,10 +16,10 @@ import { eventLine, describeLog, describeShow, describeDiff, describeBlame, desc
 import { signWithLocalKey, localKey, makeLocalKey, signingKeyFile } from './signing.js'
 import { startDaemon, askDaemon } from './daemon.js'
 import { rebuild as rebuildBlock, conflictStyle } from './block.js'
-import { describeRebuild, describeOpened, describeBoth } from './describe.js'
+import { describeRebuild, describeOpened, describeBoth, describePull, describeDeletedQuilt, describeDeletedQuilts, describePersonLog } from './describe.js'
 import { status as blockStatus, commitFolder, amendFolder, syncTo, pull, toLineTip, checkout, restore, reset, clean, localChanges, bytesOf, livePatch, resolvePulled } 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_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_github', 'seam_github_import', 'seam_import_status', 'seam_import_authors', 'seam_import_poke', 'seam_import_cutover', 'seam_export_remote', 'seam_export_status', 'seam_restore', 'seam_reset', 'seam_clean', 'seam_live', 'seam_live_join', 'seam_live_set', 'seam_bisect', 'seam_grep', 'seam_search', 'seam_describe', 'seam_merge_base', 'seam_stack', 'seam_migrations_dir', '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_protections', 'seam_protections_set', 'seam_team_set', 'seam_verify', 'seam_redact', 'seam_redactions', 'seam_seal', 'seam_secret_scanning', 'seam_public', 'seam_sealed', 'seam_policy', 'seam_line_policy_versions', 'seam_orgs', 'seam_org_log', 'seam_org_domain', 'seam_apps', 'seam_app', 'seam_app_key', 'seam_app_manager', 'seam_app_install', 'seam_app_request', 'seam_org_member', 'seam_org_team', 'seam_agent_token_new', 'seam_agent_token_list', 'seam_agent_token_revoke', 'seam_agents_make_lines', 'seam_checks', 'seam_check_rerun', 'seam_reparent', 'seam_archive', 'seam_unarchive', 'seam_hide', 'seam_unhide', 'seam_square_edit', 'seam_share', 'seam_unshare', 'seam_export_tarball', 'seam_claim_request', 'seam_claim_withdraw', 'seam_claim_handoff', 'seam_claim_finish', 'seam_blocks', 'seam_block_open', 'seam_block_touch', 'seam_block_close', 'seam_ancestor', 'seam_contains', 'seam_pipeline', 'seam_watch', 'seam_unwatch', 'seam_absorb', 'seam_interdiff', 'seam_apply_suggestion', 'seam_infra_paths', 'seam_owner_idle_hours', 'seam_public_reads', 'seam_export_archive', 'seam_metrics', 'seam_daemon', 'seam_block_rebuild', 'seam_clone', 'seam_pull', 'seam_member_add']
+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_github', 'seam_github_import', 'seam_import_status', 'seam_import_authors', 'seam_import_poke', 'seam_import_cutover', 'seam_export_remote', 'seam_export_status', 'seam_export_push', 'seam_restore', 'seam_reset', 'seam_clean', 'seam_live', 'seam_live_join', 'seam_live_set', 'seam_bisect', 'seam_grep', 'seam_search', 'seam_describe', 'seam_merge_base', 'seam_stack', 'seam_migrations_dir', '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_protections', 'seam_protections_set', 'seam_team_set', 'seam_verify', 'seam_redact', 'seam_redactions', 'seam_seal', 'seam_secret_scanning', 'seam_public', 'seam_sealed', 'seam_policy', 'seam_line_policy_versions', 'seam_orgs', 'seam_org_log', 'seam_org_domain', 'seam_apps', 'seam_app', 'seam_app_key', 'seam_app_manager', 'seam_app_install', 'seam_app_request', 'seam_org_member', 'seam_org_team', 'seam_agent_token_new', 'seam_agent_token_list', 'seam_agent_token_revoke', 'seam_agents_make_lines', 'seam_checks', 'seam_check_rerun', 'seam_reparent', 'seam_archive', 'seam_unarchive', 'seam_hide', 'seam_unhide', 'seam_square_edit', 'seam_share', 'seam_unshare', 'seam_export_tarball', 'seam_claim_request', 'seam_claim_withdraw', 'seam_claim_handoff', 'seam_claim_finish', 'seam_blocks', 'seam_block_open', 'seam_block_touch', 'seam_block_close', 'seam_ancestor', 'seam_contains', 'seam_pipeline', 'seam_watch', 'seam_unwatch', 'seam_absorb', 'seam_interdiff', 'seam_apply_suggestion', 'seam_infra_paths', 'seam_owner_idle_hours', 'seam_public_reads', 'seam_export_archive', 'seam_metrics', 'seam_daemon', 'seam_block_rebuild', 'seam_clone', 'seam_pull', 'seam_member_add', 'seam_quilt_delete', 'seam_quilts_deleted', 'seam_quilt_restore', 'seam_account_log']
 
 /** 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. ' +
@@ -71,6 +71,7 @@ export const SEAM_DESCRIPTIONS = {
   seam_export_archive: 'Writes the whole quilt as one .tar (admin) to a file on this computer: every log segment, every pack and the members, with a manifest of sizes and BLAKE3s; out (default <quilt>-<row>.seam.tar). seam export check <file> checks it offline. Over HTTP: POST /v1/quilts/:q/exit/archive.',
   seam_export_tarball: 'Writes one commit as a .tar.gz (what git archive makes) to a file on this computer: rev (default main), paths to take only part, out (default <quilt>-<commit>.tar.gz in this folder). The same commit always gives the same bytes. Over HTTP: GET /v1/quilts/:q/tarball/:rev?paths=.',
   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_export_push: 'Runs the export to a git remote now (admins), without waiting for the next merge or retry.',
   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, awaiting_authors, following, done, failed), its lines with their git tips, its last error, and while it waits the authors with the proposed member of each.',
   seam_import_authors: 'Answers an import waiting in awaiting_authors (admins): a map of git author email → member id of the quilt; the import then runs. An email left out becomes a stub member. Refuses an id that is not a member (unknown_author).',
@@ -84,7 +85,7 @@ export const SEAM_DESCRIPTIONS = {
   seam_block_touch: 'The heartbeat of an open block: keeps it open (blocks untouched for seven days are closed) and moves a live block to the square\'s current head; add and remove change its folders.',
   seam_clone: 'Checks out a line of a quilt (main by default) into a new folder on this computer, ready to work: the first commit there opens a square by itself. The folder is named after the quilt unless dir is given.',
   seam_member_add: 'Adds a member to the quilt or changes their level (an admin): email (a person; one with no Seam account yet is invited, and is in the quilt from their first sign-in) or member_id (person:… or agent:…), level read, write or admin (default write; remove takes them out).',
-  seam_pull: 'In a block folder: brings the line\'s new patches in (uncommitted edits stay; a file changed on both sides is merged, or given conflict markers to settle before it is committed); on a square, rebases it onto its line\'s tip; on a square merged from elsewhere, moves the folder to the line\'s tip.',
+  seam_pull: 'In a block folder: brings the line\'s new patches in (uncommitted edits stay; a file changed on both sides is merged, or given conflict markers to settle before it is committed); on a square, brings in its new head if it moved on the server (a merge on the site, conflicts included), then rebases it onto its line\'s tip; on a square merged from elsewhere, moves the folder to the line\'s tip.',
   seam_block_rebuild: 'In a block folder: finishes a move of the folder (rebase, checkout of its square) that stopped part way, from the journal in .seam; edits made meanwhile are kept as yours. On a whole folder it writes nothing.',
   seam_block_close: 'Closes a block (its row on the server). The square, its work and any files on disk are untouched.',
   seam_token_list: 'The quilt\'s tokens (keys for one quilt, for CI and scripts): id, name, read or write, and whether revoked. Admins only.',
@@ -96,6 +97,10 @@ export const SEAM_DESCRIPTIONS = {
   seam_redact: 'Redacts content from the quilt for good (a person who is an admin): the blob\'s bytes leave every pack, every read gets a tombstone, and the same bytes are refused if added again. History and ids stay. Name blob, or path (and rev). Cannot be undone: confirm must be true.',
   seam_seal: 'A sealed quilt\'s key (the server never sees its contents): status (key version, who holds it), or grant member: wrap the key this computer holds for that member\'s computers.',
   seam_secret_scanning: 'Reads, or (a person who is an admin) sets, secret scanning on the quilt: refuse (a commit that looks like it holds a secret is refused with path, line and finding id), warn, or off.',
+  seam_quilt_delete: 'Deletes a repo (a person: its owner, or an owner or admin of the org that owns it; never an agent on its own). confirm is the repo\'s address as <owner>/<name>, typed by the person who asked. It is hidden at once (it answers as a missing repo; its tokens, webhooks and app installs stop; agents\' open squares in it close) and can be restored for 7 days with seam_quilt_restore; then it is purged. Export it first if anything in it is wanted (seam export archive, or the export to git).',
+  seam_quilts_deleted: 'Lists Recently deleted repos: yours, or an org\'s (org: its slug; its admins and owners), each with when it was deleted, by whom, and when it is purged.',
+  seam_quilt_restore: 'Restores a repo deleted in the last 7 days, as it was (its address, members, settings, tokens and people\'s squares; the squares the delete closed stay closed, seam_reopen brings one back). quilt: its slug, id or address; org: when an org owned it.',
+  seam_account_log: 'What happened to your repos, newest first: deleted, restored, purged; who did it and when (an org\'s are in seam_org_log). before: a row id, for the page after.',
   seam_public: 'Makes the quilt readable by anyone, signed in or not (public: true), or private again (a person who is an admin). The quilt\'s protections can still keep paths out of public view.',
   seam_policy: 'A square\'s change classes (whitespace, comment-only, docs, test-only, dependency, ci-config, schema, logic, per file) and what its line\'s rules by path and class need before it merges: approvals from whom, checks, and which are met.',
   seam_line_policy_versions: 'A line\'s policy versions (every change to what it needs is one), or, for a person with admin: approve or reject a pending version someone else proposed, or confirm your own with this computer\'s signing key when you are the only admin. Agents read them only.',
@@ -140,7 +145,7 @@ export const SEAM_DESCRIPTIONS = {
   seam_absorb: 'Puts your square\'s uncommitted live work into the commit of the square that last changed each file (amending it and rewriting the commits above it), so a fix to commit 2 of 5 needs no manual rebase. Files no commit of the square changed stay live.',
   seam_fold: 'Folds a square (square) into another square you hold (into): its work becomes one commit there and the square closes. Live work it shared (seam_live_set) is committed on it first and goes along (commit_live: false refuses with live_work instead). Overlapping changes become conflict markers in the target.',
   seam_split: 'Splits your square: by paths (groups: [[paths], ...]) or by claim (one group per claim on the square that covers a changed path; the claim and its holder go with it). Each group moves to a new square (same base) as one commit; the largest group, and paths no group names, stay in this square. stacked: true chains the new squares on this one in order instead of opening them side by side.',
-  seam_log: 'History, newest first: rev (default main, or your square, or a..b), paths to limit it, limit (default 20). follow: true with one path follows the file through its renames; search: "<text>" keeps only commits that changed how many times the text appears (git log -S); match: "<regex>" keeps commits whose added or removed lines match (git log -G). message (with message_regex, ignore_case) filters on the commit message (git log --grep); author (member id or part of a name), on_behalf_of, task, since and until (an ISO date, or 2h, 3d, 1w) filter on who, what for and when. group_by (author, on_behalf_of, task, tool) gives counts with lines added and removed instead of commits; graph: true names the square each merge brought in; include_hidden: true shows a square\'s commits replaced by an amend. When there is more, pass the answer\'s cursor for the next page. Each patch on main is one line\'s merge. With one path on a line, existed says whether it was ever there and, if it is gone now, last_present is the last patch it was there in.',
+  seam_log: 'History, newest first: rev (default main, or your square, or a..b), paths to limit it, limit (default 20). follow: true with one path follows the file through its renames; search: "<text>" keeps only commits that changed how many times the text appears (git log -S); match: "<regex>" keeps commits whose added or removed lines match (git log -G). message (with message_regex, ignore_case) filters on the commit message (git log --grep); author (member id or part of a name), on_behalf_of, task, since and until (an ISO date, or 2h, 3d, 1w) filter on who, what for and when. group_by (author, on_behalf_of, task, tool) gives counts with lines added and removed instead of commits; graph: true names the square each merge brought in; include_hidden: true shows a square\'s commits replaced by an amend. When there is more, pass the answer\'s cursor for the next page. A search (search, match, a regex message) looks for about a second: past that it answers what it found so far, says it stopped early, and gives a cursor to search further. Each patch on main is one line\'s merge. With one path on a line, existed says whether it was ever there and, if it is gone now, last_present is the last patch it was there in.',
   seam_describe: 'Names a revision (rev, default main) by the nearest tag behind it: v1.0 on the tag itself, v1.0-3-<commit> three commits past it, the commit alone when no tag is behind it.',
   seam_merge_base: 'Where two revisions (a, b: lines, squares, patches, commits) last shared history: the commit a merge of one into the other starts from.',
   seam_stack: 'The full-stack pointers at a revision (a line, patch:n, sq:…, a commit): each key with its value, where it was set (a patch number or c:<commit>) and how (set by a commit, or derived: db_migration is the newest .sql file under supabase/migrations). Read it to know which schema and database the code at a patch runs against.',
@@ -200,10 +205,11 @@ export const SEAM_INPUTS = {
   seam_github: {},
   seam_github_import: { repo: z.string().max(201).describe('owner/name, as seam_github lists it'), installation: z.string().max(20).describe('The installation id seam_github shows for it'), into: z.string().max(63).optional().describe('The new quilt\'s slug (default the repo\'s name)'), follow: z.boolean().optional().describe('Keep following it (default true)') },
   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)'), authors: z.record(z.string(), z.string()).optional().describe('Git author email → member id of the quilt'), ask_authors: z.boolean().optional().describe('Wait in awaiting_authors with the authors and a proposed map until seam_import_authors answers') },
-  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'), lfs: z.object({ url: z.string().max(2000).describe('The LFS endpoint (…/info/lfs)'), threshold_bytes: z.number().int().min(0).optional().describe('Files over this many bytes go to LFS (default 50 MiB)') }).optional().describe('Git LFS on the remote: big files and filter=lfs paths go as LFS pointers. Set before the first export') },
+  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'), lfs: z.object({ url: z.string().max(2000).describe('The LFS endpoint (…/info/lfs)'), threshold_bytes: z.number().int().min(0).optional().describe('Files over this many bytes go to LFS (default 50 MiB)') }).optional().describe('Git LFS on the remote: big files and filter=lfs paths go as LFS pointers. Set before the first export'), main_as: z.string().max(100).optional().describe('The branch name main has on the remote (default main), such as master or trunk'), push: z.enum(['patch', 'tag']).optional().describe('patch (default): after every merged patch; tag: only up to the newest patch a tag or release points at'), exclude: z.array(z.string().max(500)).max(100).optional().describe('Paths left out of the exported tree: a folder ending in /, a file or a glob. Set before the first export') },
   seam_export_archive: { quilt: z.string().max(100).optional().describe('The quilt'), out: z.string().max(1000).optional() },
   seam_export_tarball: { quilt: z.string().max(100).optional().describe('The quilt'), rev: z.string().max(200).optional(), paths: z.array(z.string().max(1000)).max(100).optional(), out: z.string().max(1000).optional() },
   seam_export_status: { quilt: z.string().max(100).optional().describe('The quilt') },
+  seam_export_push: { 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_authors: { id: z.string().max(100).describe('The import id'), authors: z.record(z.string(), z.string()).describe('Git author email → member id of the quilt') },
@@ -247,6 +253,10 @@ export const SEAM_INPUTS = {
   seam_line_policy_versions: { quilt: QUILT, line: z.string().max(120), action: z.enum(['list', 'approve', 'reject', 'confirm']).optional(), version: z.number().int().min(1).optional() },
   seam_policy: { quilt: QUILT, square: z.string().max(100).optional(), line: z.string().max(120).optional() },
   seam_public: { quilt: QUILT, public: z.boolean() },
+  seam_quilt_delete: { quilt: QUILT, confirm: z.string().max(200).describe('The repo\'s address, <owner>/<name>, exactly as the person typed it') },
+  seam_quilts_deleted: { org: z.string().max(100).optional().describe('An org you run: its deleted repos') },
+  seam_quilt_restore: { quilt: z.string().max(200).describe('The deleted repo: its slug, id or <owner>/<name>'), org: z.string().max(100).optional().describe('The org that owned it') },
+  seam_account_log: { limit: z.number().int().min(1).max(500).optional(), before: z.string().regex(/^\d{1,19}$/).optional() },
   seam_sealed: { quilt: QUILT, sealed: z.boolean() },
   seam_secret_scanning: { quilt: QUILT, mode: z.enum(['refuse', 'warn', 'off']).optional() },
   seam_seal: { quilt: QUILT, action: z.enum(['status', 'grant']).optional(), member: z.string().max(200).optional().describe('For grant: the member id to give the key to') },
@@ -530,7 +540,8 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
       }
       case 'seam_github_import': { const r = await client.importGithub({ installation_id: args.installation, repo: args.repo, slug: args.into, follow: args.follow !== false }); return `Importing ${args.repo} into ${r.id ? (args.into || args.repo.split('/')[1]) : '?'} (import ${r.id})${r.follow ? ', following it' : ''}.` }
       case 'seam_import_remote': { const r = await client.startImport({ url: args.url, slug: args.into, follow: !!args.follow, interval: args.interval, credential: args.credential, authors: args.authors, ask_authors: !!args.ask_authors }); return `Importing ${args.url} into ${args.into} (import ${r.id})${r.ask_authors ? ', waiting for its authors first (seam_import_status, then seam_import_authors)' : ''}${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, lfs: args.lfs }); return r.enabled ? `Exporting ${r.lines.join(', ')} to ${r.target} after each merge.` : `The export to ${r.target} is off.` }
+      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, lfs: args.lfs, main_as: args.main_as, push: args.push, exclude: args.exclude }); return r.enabled ? `Exporting ${r.lines.join(', ')} to ${r.target} ${r.push === 'tag' ? 'up to the newest tagged patch' : 'after each merge'}.` : `The export to ${r.target} is off.` }
+      case 'seam_export_push': { const r = await client.exportPush(needQuilt()); return `Pushing to ${r.target} now; seam_export_status shows how it went.` }
       case 'seam_export_archive': {
         if (hosted) return `This server cannot write files to your computer. Fetch the archive over HTTP with your token: POST /v1/quilts/${encodeURIComponent(needQuilt())}/exit/archive`
         const r = await client.exitArchive(needQuilt())
@@ -548,7 +559,7 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
         writeFileSync(file, r.bytes)
         return `Wrote ${args.rev || 'main'} (${String(r.commit || 'empty').slice(0, 12)}) to ${file}: ${r.bytes.length} bytes.`
       }
-      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_export_status': { const r = await client.exportStatus(needQuilt()); return JSON.stringify({ target: r.target, lines: r.lines, main_as: r.main_as, push: r.push, exclude: r.exclude, 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_authors': { const r = await client.answerImportAuthors(args.id, { authors: args.authors }); return `Import ${r.id} has its authors and runs now.` }
@@ -591,12 +602,9 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
       }
       case 'seam_pull': {
         if (!found) throw new Error('seam_pull works on a block folder: run seam mcp in a folder made by seam clone or seam checkout.')
+        const was = { ...block }
         const r = await pull(client, found.dir, block)
-        const kept = describeBoth(r, { diff: 'seam_diff', resolve: 'seam_resolve (choose ours or theirs)' })
-        if (r.noop) return 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 `${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 describeWrite(r.result, 'Rebased') + `\n${r.written} file(s) updated in the folder.` + kept
-        return `Pulled ${r.line} (now ${r.at.slice(0, 12)}): ${r.written} file(s) updated.` + kept
+        return describePull(r, was, { diff: 'seam_diff', resolve: 'seam_resolve (choose ours or theirs)' })
       }
       case 'seam_block_rebuild': {
         if (!found) throw new Error('seam_block_rebuild works on a block folder: run seam mcp in a folder made by seam checkout.')
@@ -638,6 +646,10 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
         return describePolicyVersions(r)
       }
       case 'seam_orgs': return args.org ? describeOrg(await client.org(args.org)) : describeOrgs(await client.orgs())
+      case 'seam_quilt_delete': return describeDeletedQuilt(await client.deleteQuilt(needQuilt(), args.confirm))
+      case 'seam_quilts_deleted': return describeDeletedQuilts(await client.deletedQuilts({ org: args.org }), { org: args.org })
+      case 'seam_quilt_restore': { const r = await client.undeleteQuilt(args.quilt, { org: args.org }); return `Restored ${r.path || r.quilt}: it is back as it was. The squares the delete closed stay closed; seam_reopen brings one back.` }
+      case 'seam_account_log': return describePersonLog(await client.personLog({ limit: args.limit, before: args.before }))
       case 'seam_org_log': return describeOrgLog(await client.orgLog(args.org, { limit: args.limit, before: args.before }))
       case 'seam_apps': return describeApps(await client.apps({ verified: !!args.verified }))
       case 'seam_app': {

package/package.json

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