@heyquilt/seam 0.144.0 → 0.146.0

package/bin/seam.js

@@ -21,7 +21,8 @@ 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
@@ -100,13 +101,15 @@ Docs: https://seam.heyquilt.com/docs
   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
   seam quilts new <slug> --sealed     a quilt the server never reads: its key lives on members' computers
   seam quilts sealed on|off --quilt <q>   switch a quilt that holds no files yet to sealed or back
   seam seal [status] | key | grant <member> | rotate [--without <member>]   a sealed quilt's key
-  seam events [--follow|--webhook <url>]  What happened to your squares
+  seam events [--follow|--webhook <url>|list]  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 mcp --as-agent [--merge]      The same, with the AI tool as an agent of yours, on a token of its own
@@ -141,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])}`)

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, describeWebhooks } 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 = []
@@ -153,6 +153,24 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
         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')
@@ -250,9 +268,10 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       return print(x, `Released ${x.name} at ${where(x)}. Read it as tag:${x.name}.`)
     }
     case 'events': {
-      // seam events [--after n] [--kinds a,b] [--wait seconds | --follow] | --webhook <url> [--add | --remove] [--secret s] [--kinds a,b] | --webhook off
+      // seam events [--after n] [--kinds a,b] [--wait seconds | --follow] | --webhook <url> [--add | --remove] [--secret s] [--kinds a,b] | --webhook off | --webhook list
       const kinds = flags['--kinds'] ? String(flags['--kinds']).split(',') : undefined
       if (flags['--webhook']) {
+        if (flags['--webhook'] === 'list') { const r = await client.webhooks(needQuilt()); return print(r, describeWebhooks(r)) }
         const off = flags['--webhook'] === 'off'
         if (!off && flags['--remove']) { const r = await client.subscribe(needQuilt(), { url: flags['--webhook'], remove: true }); return print(r, `Webhook to ${r.url} removed.${r.hooks.length ? ` Still posting to ${r.hooks.map((h) => h.url).join(', ')}.` : ''}`) }
         const r = await client.subscribe(needQuilt(), off ? { url: null } : { url: flags['--webhook'], secret: flags['--secret'], events: kinds, ...(flags['--add'] ? { add: true } : {}) })
@@ -351,12 +370,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]
@@ -689,6 +705,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'

package/lib/quilts/client.js

@@ -207,6 +207,7 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     revert: (q, b) => call('POST', `${Q(q)}/revert`, b),
     events: (q, o = {}) => call('GET', `${Q(q)}/events${qs(o)}`),
     subscribe: (q, b) => call('POST', `${Q(q)}/webhook`, b),
+    webhooks: (q) => call('GET', `${Q(q)}/webhook`),
     show: (q, rev, o = {}) => call('GET', `${Q(q)}/show/${enc(rev)}${qs(o)}`),
     exportPatches: (q, o = {}) => call('GET', `${Q(q)}/export/git${qs(o)}`),
     log: (q, o = {}) => call('GET', `${Q(q)}/log${qs(o)}`),
@@ -237,6 +238,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,
@@ -346,6 +348,11 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     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 }),

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}`))
@@ -176,6 +193,13 @@ export function describeMerge (r) {
 }
 
 /** Events as one line each (12's inbox line: kind, who, square, paths, patch, would_conflict). */
+/** Your webhooks in a quilt (GET /webhook): each url with the events it hears; never a secret. */
+export function describeWebhooks (r) {
+  const hooks = r.hooks || []
+  if (!hooks.length) return 'No webhooks of yours in this quilt.'
+  return hooks.map((h) => `${h.url}  (${h.events.length > 4 ? `${h.events.length} kinds of event` : h.events.join(', ')})`).join('\n')
+}
+
 export function describeEvents (r) {
   if (!r.events.length) return `No new events (cursor ${r.after}).`
   return [...r.events.map(eventLine), `(next: after=${r.after})`].join('\n')
@@ -572,6 +596,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 +630,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/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, describeWebhooks } 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_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']
+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. ' +
@@ -85,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.',
@@ -97,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.',
@@ -137,11 +141,11 @@ export const SEAM_DESCRIPTIONS = {
   seam_share: 'Adds a writer to a square you hold, for pairing: up to three people besides you, each able to write to the quilt. An agent with its own account gets its own square instead.',
   seam_unshare: 'Takes a writer off a square you hold, or takes you off one you were shared on.',
   seam_events: 'What happened to your work since you last looked: patch.merged (a patch changed files your open square changed, and whether your merge would now conflict), conflict.added (a conflict was kept in your square), square.handoff, square.restacked (your stacked square was moved onto its parent\'s new head or the line, with how many conflicts it now holds), check.requested (you run a check a line names you for: run it on the commit and report with seam_check and its run_key). Pass after (the cursor from the last answer) to get only new ones. Pass wait (seconds, up to 30) to wait for the next one instead of answering at once.',
-  seam_events_webhook: 'Has the quilt server POST your events to a URL (signed with HMAC-SHA256 over <timestamp>.<body>, retried 3 times), so you are woken instead of polling: url, events (default all), secret (made for you if left out). url: "off" removes them all. add: true keeps your other webhooks (up to 5); remove: true removes the one at url.',
+  seam_events_webhook: 'Has the quilt server POST your events to a URL (signed with HMAC-SHA256 over <timestamp>.<body>, retried 3 times), so you are woken instead of polling: url, events (default all), secret (made for you if left out). url: "off" removes them all; url: "list" lists yours (url and events, never the secret). add: true keeps your other webhooks (up to 5); remove: true removes the one at url.',
   seam_absorb: 'Puts your square\'s uncommitted live work into the commit of the square that last changed each file (amending it and rewriting the commits above it), so a fix to commit 2 of 5 needs no manual rebase. Files no commit of the square changed stay live.',
   seam_fold: 'Folds a square (square) into another square you hold (into): its work becomes one commit there and the square closes. 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.',
@@ -249,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') },
@@ -494,6 +502,7 @@ export async function runSeamTool (name, args, { client, found = null, hosted =
       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, ...(args.wait ? { wait: args.wait } : {}) }))
       case 'seam_events_webhook': {
+        if (args.url === 'list') return describeWebhooks(await client.webhooks(needQuilt()))
         if (args.url === 'off') { await client.subscribe(needQuilt(), { url: null }); return 'Webhooks removed.' }
         if (args.remove) { const r = await client.subscribe(needQuilt(), { url: args.url, remove: true }); return `Webhook to ${r.url} removed.${r.hooks.length ? ` Still posting to ${r.hooks.map((h) => h.url).join(', ')}.` : ''}` }
         const r = await client.subscribe(needQuilt(), { url: args.url, events: args.events, secret: args.secret, ...(args.add ? { add: true } : {}) })
@@ -594,12 +603,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.')
@@ -641,6 +647,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.144.0",
+  "version": "0.146.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",