@heyquilt/seam 0.1.1 → 0.17.0

package/lib/quilts/signing.js

@@ -0,0 +1,149 @@
+// Signed commits: a person or an agent adds an Ed25519 public key to their account, signs a commit
+// with the private key (which never leaves their computer), and anyone reading the log can check
+// the signature (seam log --show-signature). A commit's id is the hash of its whole record (tree,
+// parents, author, message, quilt), so signing the id signs all of it.
+//
+// What is signed is the text `seam-commit <id>\n`. Only the commit's author, or the person it was
+// made for (on_behalf_of), may sign it, with one of their own keys. A key is removed, never
+// deleted: signatures made with it then read as "removed_key", so a stolen key stops vouching.
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { QuiltError } from './errors.js'
+
+export const MAX_KEYS = 20
+const SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex') // Ed25519 SubjectPublicKeyInfo header
+
+/** The bytes a signature covers. */
+export const signedText = (commitId) => `seam-commit ${commitId}\n`
+
+/** A public key (SPKI PEM, or base64 of the 32 raw bytes) as base64 of its raw bytes, or null. */
+export function rawPublicKey (input) {
+  const s = String(input || '').trim()
+  if (!s) return null
+  try {
+    if (s.includes('BEGIN')) {
+      const k = crypto.createPublicKey(s)
+      if (k.asymmetricKeyType !== 'ed25519') return null
+      return k.export({ format: 'der', type: 'spki' }).subarray(SPKI_PREFIX.length).toString('base64')
+    }
+    const b = Buffer.from(s, 'base64')
+    return b.length === 32 ? b.toString('base64') : null
+  } catch { return null }
+}
+
+const keyObject = (raw) => crypto.createPublicKey({ key: Buffer.concat([SPKI_PREFIX, Buffer.from(raw, 'base64')]), format: 'der', type: 'spki' })
+
+/** A key's id: `ed25519:` and the first 16 hex of the sha256 of its raw bytes. */
+export const keyId = (raw) => 'ed25519:' + crypto.createHash('sha256').update(Buffer.from(raw, 'base64')).digest('hex').slice(0, 16)
+
+export function verifySignature (raw, commitId, signature) {
+  try { return crypto.verify(null, Buffer.from(signedText(commitId)), keyObject(raw), Buffer.from(String(signature), 'base64')) } catch { return false }
+}
+
+// ---- the client side: the private key on this computer ----
+
+/** Where this computer's signing key lives: SEAM_SIGNING_KEY, else ~/.seam/signing-key.pem. */
+export const signingKeyFile = () => process.env.SEAM_SIGNING_KEY || path.join(process.env.SEAM_HOME || path.join(os.homedir(), '.seam'), 'signing-key.pem')
+
+/** Makes a new key pair on this computer (refused when one is there). Returns the public half. */
+export function makeLocalKey (file = signingKeyFile()) {
+  if (fs.existsSync(file)) throw new Error(`There is already a signing key at ${file}.`)
+  const { privateKey, publicKey } = crypto.generateKeyPairSync('ed25519')
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.writeFileSync(file, privateKey.export({ format: 'pem', type: 'pkcs8' }), { mode: 0o600 })
+  return publicKey.export({ format: 'pem', type: 'spki' })
+}
+
+/** This computer's key: { sign(commitId), public_key, key } or null when there is none. */
+export function localKey (file = signingKeyFile()) {
+  if (!fs.existsSync(file)) return null
+  const priv = crypto.createPrivateKey(fs.readFileSync(file))
+  const pub = crypto.createPublicKey(priv).export({ format: 'pem', type: 'spki' })
+  const raw = rawPublicKey(pub)
+  return { public_key: pub, key: keyId(raw), sign: (commitId) => crypto.sign(null, Buffer.from(signedText(commitId)), priv).toString('base64') }
+}
+
+/** Signs a commit with this computer's key and sends the signature. */
+export async function signWithLocalKey (client, quilt, rev) {
+  const k = localKey()
+  if (!k) throw new Error('No signing key on this computer: run seam key add first.')
+  const id = (await client.describe(quilt, rev || 'main')).commit
+  if (!id) throw new Error(`No commit at ${rev || 'main'}.`)
+  return client.sign(quilt, id, { key: k.key, signature: k.sign(id) })
+}
+
+// ---- the server side ----
+
+export function signingOps (svc) {
+  const { store, now, quiltFor, resolve, getCommit, fromStore } = svc.internals
+
+  const keyView = (r) => ({ key: r.id, name: r.name || '', public_key: r.public_key, added_at: r.added_at, ...(r.removed_at ? { removed_at: r.removed_at } : {}) })
+
+  /** POST /signing-keys { public_key, name? }: adds one of your keys. */
+  async function addKey (me, _ref, { public_key: pk, name = '' } = {}) {
+    const raw = rawPublicKey(pk)
+    if (!raw) throw new QuiltError(400, 'bad_request', 'public_key: an Ed25519 public key (PEM, or base64 of its 32 bytes)')
+    if (String(name).length > 100) throw new QuiltError(400, 'bad_request', 'a key name is up to 100 characters')
+    const mine = await store.signingKeys(me.member_id)
+    if (mine.filter((k) => !k.removed_at).length >= MAX_KEYS) throw new QuiltError(409, 'too_many_keys', `up to ${MAX_KEYS} keys each`)
+    try {
+      return keyView(await store.addSigningKey({ id: keyId(raw), member: me.member_id, public_key: raw, name: String(name), added_at: now() }))
+    } catch (err) { throw fromStore(err) }
+  }
+
+  /** GET /signing-keys: your keys (or a member's, with ?member=). */
+  async function keys (me, _ref, { member } = {}) {
+    return { member: member || me.member_id, keys: (await store.signingKeys(member || me.member_id)).map(keyView) }
+  }
+
+  /** DELETE /signing-keys/:key: removes one of your keys; its signatures stop counting. */
+  async function removeKey (me, _ref, key) {
+    const row = await store.signingKey(String(key))
+    if (!row || row.member !== me.member_id) throw new QuiltError(404, 'not_found', `you have no key ${key}`)
+    if (row.removed_at) return keyView(row)
+    try { return keyView(await store.removeSigningKey({ id: row.id, member: me.member_id, at: now() })) } catch (err) { throw fromStore(err) }
+  }
+
+  /** POST /commits/:rev/signatures { key, signature }: signs a commit you made (or that was made for you). */
+  async function sign (me, ref, rev, { key, signature } = {}) {
+    const q = await quiltFor(me, ref, 'write')
+    const id = await resolve(q.id, String(rev || ''))
+    if (!id) throw new QuiltError(404, 'not_found', `no commit at ${rev}`)
+    const c = await getCommit(q.id, id)
+    const by = c.author?.member_id
+    if (me.member_id !== by && me.member_id !== c.on_behalf_of) throw new QuiltError(403, 'not_author', 'only the commit\'s author, or whom it was made for, signs it')
+    const row = key ? await store.signingKey(String(key)) : null
+    if (!row || row.member !== me.member_id || row.removed_at) throw new QuiltError(400, 'bad_key', `${key || 'key'} is not one of your keys (seam key add)`)
+    if (!verifySignature(row.public_key, id, signature)) throw new QuiltError(422, 'bad_signature', `the signature does not match ${id.slice(0, 12)} and ${row.id}`)
+    try {
+      await store.addSignature({ quilt_id: q.id, commit: id, key: row.id, signer: me.member_id, signature: String(signature), at: now() })
+    } catch (err) { throw fromStore(err) }
+    return { commit: id, short: id.slice(0, 12), signature: { status: 'good', key: row.id, signer: me.member_id } }
+  }
+
+  /** Each commit's signature, checked now: good, bad, removed_key, or none. */
+  async function signaturesFor (q, commits) {
+    const rows = await store.signaturesOf(q, commits.map((c) => c.id))
+    const keyRows = new Map()
+    const out = new Map()
+    for (const r of rows) {
+      if (!keyRows.has(r.key)) keyRows.set(r.key, await store.signingKey(r.key))
+      const k = keyRows.get(r.key)
+      const status = !k || !verifySignature(k.public_key, r.commit, r.signature) ? 'bad' : k.removed_at ? 'removed_key' : 'good'
+      const prev = out.get(r.commit)
+      if (!prev || (status === 'good' && prev.status !== 'good')) out.set(r.commit, { status, key: r.key, signer: r.signer, at: r.at })
+    }
+    return out
+  }
+
+  /** Adds `signature` to each commit of a log answer. */
+  async function withSignatures (me, ref, answer) {
+    const q = await quiltFor(me, ref, 'read')
+    const sigs = await signaturesFor(q.id, answer.commits || [])
+    return { ...answer, commits: (answer.commits || []).map((c) => ({ ...c, signature: sigs.get(c.id) || { status: 'none' } })) }
+  }
+
+  return { addKey, signingKeys: keys, removeKey, sign, withSignatures }
+}

package/lib/quilts/tools.js

@@ -6,16 +6,18 @@
 // Locally, in a folder made by `seam checkout`, the quilt and square come from the folder and
 // seam_commit seals the folder's changes; anywhere else (and always for hosted agents) name the
 // quilt and square, and seam_commit takes the files' new contents.
+import path from 'node:path'
 import { z } from 'zod'
-import { describeLog, describeShow, describeDiff, describeBlame, describeStatus, describeMerge, describeWrite, describeSquare, describeSquareStatus, describeEvents } from './describe.js'
-import { status as blockStatus, commitFolder, syncTo } from './block.js'
+import { describeLog, describeShow, describeDiff, describeBlame, describeStatus, describeMerge, describeWrite, describeSquare, describeSquareStatus, describeEvents, describeTag, describeRelease, describeImport, describeRestore, describeReset, describeClean, describeLive, describeClaims, describeResolutions, describeLiveSet, describeMergeBase, describeGrep, describeBisect, describeCheck, describeReviews, describeReviewed, describeSquareCheck, describePolicy, describeKeys, describeTokens, describeNewToken } from './describe.js'
+import { signWithLocalKey, localKey, makeLocalKey, signingKeyFile } from './signing.js'
+import { status as blockStatus, commitFolder, amendFolder, syncTo, restore, reset, clean, localChanges } from './block.js'
 
-export const SEAM_TOOLS = ['seam_quilts', 'seam_open_square', 'seam_squares', 'seam_log', 'seam_show', 'seam_diff', 'seam_blame', 'seam_cat', 'seam_ls', 'seam_commit', 'seam_merge', 'seam_rebase', 'seam_revert', 'seam_cherry_pick', 'seam_resolve', 'seam_square_status', 'seam_square_handoff', 'seam_abandon', 'seam_reopen', 'seam_fold', 'seam_split', 'seam_events', 'seam_events_webhook']
+export const SEAM_TOOLS = ['seam_quilts', 'seam_open_square', 'seam_squares', 'seam_log', 'seam_show', 'seam_diff', 'seam_blame', 'seam_cat', 'seam_ls', 'seam_commit', 'seam_merge', 'seam_rebase', 'seam_revert', 'seam_cherry_pick', 'seam_resolve', 'seam_square_status', 'seam_square_handoff', 'seam_abandon', 'seam_reopen', 'seam_fold', 'seam_split', 'seam_events', 'seam_events_webhook', 'seam_line_list', 'seam_line_new', 'seam_line_freeze', 'seam_line_unfreeze', 'seam_line_require', 'seam_reviews', 'seam_review', 'seam_tag_list', 'seam_tag', 'seam_release_list', 'seam_release', 'seam_import_git', 'seam_restore', 'seam_reset', 'seam_clean', 'seam_live', 'seam_live_set', 'seam_bisect', 'seam_grep', 'seam_search', 'seam_describe', 'seam_merge_base', 'seam_claims', 'seam_claim', 'seam_unclaim', 'seam_check', 'seam_resolutions', 'seam_forget_resolution', 'seam_sign', 'seam_keys', 'seam_key_add', 'seam_key_remove', 'seam_token_list', 'seam_token_new', 'seam_token_revoke']
 
 /** 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. ' +
   'Open a square with seam_open_square, commit with seam_commit, merge with seam_merge (into: "main"). A merge never stops half way: a real conflict is refused, kept in your square as conflict markers, and you settle it (edit the file and commit it without the markers, or seam_resolve) and merge again. ' +
-  'Read history with seam_log, seam_show, seam_diff, seam_blame and seam_cat; revisions are main, main~3, patch:12, sq:<id>, a commit id or git:<sha>. ' +
+  'Read history with seam_log, seam_show, seam_diff, seam_blame, seam_cat and seam_grep (seam_bisect finds the commit that broke something); revisions are main, main~3, patch:12, sq:<id>, a commit id or git:<sha>. ' +
   'In a folder checked out from a square (it holds .seam/block.json), edit the files with your own tools and check them with seam_square_status.'
 
 const QUILT = z.string().max(100).optional().describe('The quilt (its slug or id); in a folder made by seam checkout, that folder\'s quilt')
@@ -24,8 +26,36 @@ const REV = z.string().max(200).optional()
 const PATHS = z.array(z.string().max(1000)).max(200).optional().describe('Only these paths (files or directories)')
 
 export const SEAM_DESCRIPTIONS = {
+  seam_live: 'A square\'s uncommitted work its holder shared (sq:<id>:live): each changed file, added, modified or deleted against the square\'s head. Read the files with seam_cat or seam_diff (rev sq:<id>:live).',
+  seam_line_require: 'Reads, or (a person who is an admin) sets, what a line needs before a square merges into it: approvals of the square\'s latest commit (0: none) and checks that must be green on it (check names, reported with seam_check and square). Leave both out to read it.',
+  seam_reviews: 'A square\'s reviews (comments, approvals, requests for changes) and where it stands: approvals it has against what its line needs, and whether it is ready to merge.',
+  seam_review: 'Reviews a square: kind approve, request_changes (say what in body), comment (body; path and line put it on a line of a file at the square\'s head) or dismiss (takes back your verdict). Nobody approves a square they or the person they work for opened or hold. An approval counts for the square\'s latest commit only.',
+  seam_claims: 'The claims that hold now: which square is working on which paths, who, and why (square: only that square\'s).',
+  seam_claim: 'Claims paths (patterns: files, folders or globs like src/api/**) for your square, so writes to them from other squares on its line are refused until your square merges or you let go. note says what for. Claim before a larger change across several files.',
+  seam_check: 'Reports a post-merge check on a line (status red, green or flaky; a red check halves the line\'s merge window, green restores it). With patch (the patch number it failed at, found for example with seam_bisect) a red check reverts that patch on the line by itself and opens a square holding the change again for its holder to fix. With square instead, the result (green or red) is for that square\'s latest commit, which its line may require green before a merge.',
+  seam_unclaim: 'Lets go of claims on your square (patterns: the patterns or claim ids).',
+  seam_live_set: 'Shares your square\'s uncommitted work so others can read it as sq:<id>:live before you commit: in a block folder the folder\'s changed files; elsewhere files: [{ path, content }] and delete: [paths]. Each call replaces what was shared; none clears it. It is not a commit: seam_commit keeps work.',
+  seam_restore: 'In a block folder: puts the named files (paths; "." for all) back as they were at the folder\'s last commit, throwing away their uncommitted edits and deletions. Files nobody committed stay (seam_clean removes them).',
+  seam_reset: 'In a block folder: makes the folder\'s files those of a revision (rev). With no rev, throws away every uncommitted edit. The folder stays on its square: what differs from it shows as uncommitted changes, so seam_commit makes the square match rev (to undo its last commit: rev sq:<id>~1).',
+  seam_clean: 'In a block folder: removes the files nobody committed and no .gitignore names (under paths, default all). dry_run: true lists them without removing.',
   seam_quilts: 'Lists the quilts (repositories) you can reach, or makes a new one (new: its slug).',
-  seam_open_square: 'Opens a square: your own unit of work, branched from the tip of main (or line). Returns its id (sq:…). Agents open squares, never lines.',
+  seam_line_list: 'The quilt\'s lines: main and release/<name> lines, each with its patch count, tip and whether it is frozen.',
+  seam_line_new: 'Makes a line release/<name> starting at a revision (from, default main): a release line takes merges of its own. Open squares on it with seam_open_square (line) and merge with seam_merge (into).',
+  seam_line_freeze: 'Freezes a line (admins): merges into it are refused with line_frozen until seam_line_unfreeze.',
+  seam_line_unfreeze: 'Unfreezes a line (admins): it takes merges again.',
+  seam_tag_list: 'The quilt\'s tags: name, commit, the patch it is, and whether it is a release.',
+  seam_import_git: 'Imports a git repository on this computer into a quilt: HEAD\'s branch as main, every other branch as a line of its name, every tag, submodules as gitlink entries. Run it again into the same quilt to add only the new commits.',
+  seam_sign: 'Signs a commit you made (rev, default your square\'s head) with your Ed25519 key, so seam_log with show_signature shows it as yours. With no signature, signs with this computer\'s key (seam_key_add makes one); a hosted agent signs the text "seam-commit <commit id>\\n" itself and passes key and signature (base64).',
+  seam_keys: 'Your signing keys (or member\'s): their ids, names, and when each was added or removed.',
+  seam_key_add: 'Adds an Ed25519 signing key to your account. With no public_key, makes one on this computer (kept in ~/.seam/signing-key.pem) or adds the one already there.',
+  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.',
+  seam_token_new: 'Makes a quilt token: a key that reaches only this quilt, at level read (default) or write, for a CI job or a script. The secret (sqt_…) is in this answer only; it is used as SEAM_TOKEN or Authorization: Bearer. Admins only.',
+  seam_token_revoke: 'Revokes a quilt token (by id, or by name): it stops working at once. Admins only.',
+  seam_key_remove: 'Removes one of your signing keys (key: ed25519:…). Commits it signed then show "removed_key" instead of "good".',
+  seam_tag: 'Tags a revision (rev: patch:12, a commit, a line, sq:…; default main) with a name that never moves. Read it back as the revision tag:<name>.',
+  seam_release_list: 'The quilt\'s releases, newest first, each with its notes.',
+  seam_release: 'Makes a release: a tag (name) on a revision (rev, default main) with release notes (notes).',
+  seam_open_square: 'Opens a square: your own unit of work, branched from the tip of main (or line). Returns its id (sq:…). Agents open squares, never lines. on: another open square (sq:…) to stack on: yours starts from its head, merges after it, and is rebased onto the line by itself when it merges.',
   seam_squares: 'The open squares of a quilt, with holder, head, how far behind main each is and its conflicted paths. all: true for merged and abandoned ones too.',
   seam_square_status: 'One square as the server sees it (head, behind_by, conflicted paths), the patches merged under it that changed its files, and which files would conflict if merged now; in a block folder also the files changed since the last commit.',
   seam_square_handoff: 'Hands your square to another member (to), with a note on what is done and what is left. You stop being able to commit to it.',
@@ -35,36 +65,78 @@ export const SEAM_DESCRIPTIONS = {
   seam_events_webhook: 'Has the quilt server POST your events to a URL (signed with HMAC-SHA256 over <timestamp>.<body>, retried 3 times), so you are woken instead of polling: url, events (default all), secret (made for you if left out). url: "off" removes it.',
   seam_fold: 'Folds a square (square) into another square you hold (into): its work becomes one commit there and the square closes. Overlapping changes become conflict markers in the target.',
   seam_split: 'Splits your square by paths: groups: [[paths], ...], each group moves to a new square (same base) as one commit; the largest group, and paths no group names, stay in this square.',
-  seam_log: 'History, newest first: rev (default main, or your square), paths to limit it, limit (default 20). Each patch on main is one line\'s merge.',
+  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). Each patch on main is one line\'s merge.',
+  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_search: 'Code search: the lines matching a pattern in every quilt you can read (or the ones in quilts), at a revision (rev, default main; quilts without it are skipped), under paths. fixed: true for plain text; ignore_case, files_only, limit (default 200, across all quilts).',
+  seam_grep: 'The lines matching a pattern (a JavaScript regular expression; fixed: true for plain text) in the files at a revision (rev, default main or your square; sq:<id>:live too), under paths. ignore_case, files_only, limit (default 200).',
+  seam_bisect: 'Finds the commit that broke something between good (a revision without the problem) and bad (default main), along first parents (on a line: its patches). Without run, one step: pass marks { <commit>: "good" | "bad" | "skip" } for those tested so far and it names the next to test, or the first bad one. With run (a shell command) it checks out each commit into a fresh folder on this computer and runs it there: exit 0 good, 125 skip, other bad.',
   seam_show: 'One commit or patch: who, when, why, which square, and its diff. rev: patch:12, main~1, sq:…, a commit id, git:<sha>. format: unified (default), stat or names.',
   seam_diff: 'The difference between two revisions (from, to); with only to, against its parent (for a square: against where it branched). format: unified, stat or names.',
   seam_blame: 'Each line of a file at a revision, with the commit and patch that last changed it and who made it. Computed by the server.',
   seam_cat: 'A file\'s content at any revision (path, rev). To change a file, read it from your own square (rev sq:<id>), not from main: main moves while you work, and a commit built from a different version of main than your square started from can undo work that merged in between. A conflicted file comes back with its conflict markers: format diff (default: one side in full after +++++++, each other side as a diff from its base after %%%%%%%), snapshot (every side in full) or git (<<<<<<< ======= >>>>>>>, two sides only).',
   seam_ls: 'The files at a revision, under paths (directories).',
-  seam_commit: 'Seals your square\'s changes as a commit (a save point). In a block folder: the folder\'s changed files (paths: only these). Elsewhere: files: [{ path, content }] (text; base64: true for bytes) and delete: [paths]. message says why. Committing a conflicted file without its markers settles the conflict.',
+  seam_commit: 'Seals your square\'s changes as a commit (a save point). In a block folder: the folder\'s changed files (paths: only these). Elsewhere: files: [{ path, content }] (text; base64: true for bytes) and delete: [paths]. message says why. Committing a conflicted file without its markers settles the conflict. amend: true changes the square\'s last commit instead (its changes plus these, a new message if given), as git commit --amend does. sign: true signs the new commit with this computer\'s key.',
   seam_merge: 'Merges your square into a line (into: "main") or, with from, merges another square or revision into your square (a two-parent commit; conflicts stay in your square as markers). Into a line: the server rebases it onto the tip as one commit and moves main, retrying lost races itself. The result is a patch. A real conflict is refused: the square is rebased with the conflict kept in it (your folder gets the markers); settle it and merge again. dry_run: true says what would happen.',
   seam_rebase: 'Moves your square onto the tip of its line (or onto a revision). Conflicts become conflict markers in the square, never a stop.',
   seam_revert: 'Undoes a patch (or commit): a new square from the tip whose one commit inverts it. Merge that square with seam_merge.',
   seam_cherry_pick: 'Applies one commit\'s change (from) to your square as a new commit.',
-  seam_resolve: 'Settles conflicted files in your square by choosing a side: entries [{ path, choose: ours | theirs | base | suggestion | delete }]; suggestion takes the word-level merge a conflict offers (its suggestion, shown when the merge is refused). (Or edit the file and commit it without the markers.)'
+  seam_resolve: 'Settles conflicted files in your square by choosing a side: entries [{ path, choose: ours | theirs | base | suggestion | delete }]; suggestion takes the word-level merge a conflict offers (its suggestion, shown when the merge is refused). (Or edit the file and commit it without the markers.) The answer is remembered: the same conflict met again in a rebase or merge is settled the same way, unless remember: false.',
+  seam_resolutions: 'The remembered resolutions: conflicts settled once that seam settles the same way when they come back (path: only that file\'s).',
+  seam_forget_resolution: 'Forgets a remembered resolution (key: its key or first 8+ characters), so that conflict is asked about again next time.'
 }
 
 export const SEAM_INPUTS = {
+  seam_live: { quilt: QUILT, square: SQUARE },
+  seam_line_require: { quilt: QUILT, line: z.string().max(120), approvals: z.number().int().min(0).max(20).optional(), checks: z.array(z.string().max(100)).max(20).optional().describe('Check names that must be green on a square\'s latest commit, e.g. ["ci"]; [] for none') },
+  seam_reviews: { quilt: QUILT, square: SQUARE },
+  seam_review: { quilt: QUILT, square: SQUARE, kind: z.enum(['approve', 'request_changes', 'comment', 'dismiss']), body: z.string().max(20000).optional(), path: z.string().max(1000).optional().describe('A file, for a comment on it'), line: z.number().int().min(1).optional().describe('A line of that file at the square\'s head') },
+  seam_claims: { quilt: QUILT, square: SQUARE },
+  seam_claim: { quilt: QUILT, square: SQUARE, patterns: z.array(z.string().max(500)).min(1).max(50).describe('Files, folders or globs, e.g. src/api/** or README.md'), note: z.string().max(300).optional().describe('What you are doing with them') },
+  seam_check: { quilt: QUILT, check: z.string().max(200).describe('The check\'s name, e.g. ci'), status: z.enum(['red', 'green', 'flaky']), square: z.string().max(100).optional().describe('A square (sq:…): the result is for its latest commit, which a line may require green before a merge'), line: z.string().max(110).optional().describe('Default main'), patch: z.number().int().min(1).optional().describe('The patch number the check failed at: reverts it') },
+  seam_unclaim: { quilt: QUILT, square: SQUARE, patterns: z.array(z.string().max(500)).min(1).max(50).describe('The claimed patterns (or claim ids)') },
+  seam_live_set: { quilt: QUILT, square: SQUARE, files: z.array(z.object({ path: z.string().max(1000), content: z.string(), base64: z.boolean().optional(), mode: z.enum(['file', 'exec']).optional() })).max(2000).optional(), delete: z.array(z.string().max(1000)).max(2000).optional() },
+  seam_restore: { paths: z.array(z.string().max(1000)).min(1).max(200).describe('Files or folders, relative to the block folder ("." for all)') },
+  seam_reset: { rev: z.string().max(200).optional().describe('The revision: sq:<id>~1, patch:12, tag:v1.0, a commit; default the folder\'s last commit') },
+  seam_clean: { paths: PATHS, dry_run: z.boolean().optional() },
   seam_quilts: { new: z.string().max(63).optional().describe('Make a quilt with this slug') },
-  seam_open_square: { quilt: QUILT, title: z.string().max(200).describe('What the work is'), line: z.string().max(100).optional(), task_id: z.string().max(64).optional() },
+  seam_line_list: { quilt: QUILT },
+  seam_line_new: { quilt: QUILT, name: z.string().max(110).describe('release/<name> (or just <name>)'), from: z.string().max(200).optional().describe('The revision it starts at: main, patch:12, a commit, sq:…; default main') },
+  seam_line_freeze: { quilt: QUILT, line: z.string().max(110) },
+  seam_line_unfreeze: { quilt: QUILT, line: z.string().max(110) },
+  seam_tag_list: { quilt: QUILT },
+  seam_import_git: { path: z.string().max(1000).describe('The git repository\'s folder'), into: z.string().max(63).optional().describe('The quilt\'s slug (default the folder\'s name); a quilt an import made takes only the new commits'), validate: z.boolean().optional().describe('Compare every patch written with git\'s tree') },
+  seam_sign: { quilt: QUILT, rev: REV, key: z.string().max(40).optional().describe('Your key id (ed25519:…), with signature'), signature: z.string().max(200).optional().describe('Base64 Ed25519 signature of "seam-commit <commit id>\\n"') },
+  seam_keys: { member: z.string().max(200).optional().describe('Whose keys (default yours)') },
+  seam_key_add: { public_key: z.string().max(2000).optional().describe('Ed25519 public key (PEM, or base64 of its 32 bytes); none: this computer\'s'), name: z.string().max(100).optional() },
+  seam_token_list: { quilt: QUILT },
+  seam_token_new: { quilt: QUILT, name: z.string().max(100).describe('What it is for, e.g. ci'), level: z.enum(['read', 'write']).optional() },
+  seam_token_revoke: { quilt: QUILT, token: z.string().max(100).describe('The token\'s id or name') },
+  seam_key_remove: { key: z.string().max(40).describe('The key id, ed25519:…') },
+  seam_tag: { quilt: QUILT, name: z.string().max(100).describe('The tag, e.g. v1.0'), rev: z.string().max(200).optional().describe('What it names: patch:12, a commit, a line, sq:…; default main') },
+  seam_release_list: { quilt: QUILT },
+  seam_release: { quilt: QUILT, name: z.string().max(100).describe('The release\'s tag, e.g. v1.0'), rev: z.string().max(200).optional().describe('default main'), notes: z.string().max(20000).describe('Release notes') },
+  seam_open_square: { quilt: QUILT, title: z.string().max(200).describe('What the work is'), line: z.string().max(100).optional(), task_id: z.string().max(64).optional(), on: z.string().max(64).optional().describe('A square to stack on (sq:…)') },
   seam_squares: { quilt: QUILT, all: z.boolean().optional(), mine: z.boolean().optional() },
   seam_square_status: { quilt: QUILT, square: SQUARE },
-  seam_log: { quilt: QUILT, rev: REV, paths: PATHS, limit: z.number().int().min(1).max(500).optional() },
+  seam_log: { quilt: QUILT, rev: REV, paths: PATHS, limit: z.number().int().min(1).max(500).optional(), follow: z.boolean().optional().describe('Follow one file (paths: [it]) through its renames'), search: z.string().max(500).optional().describe('Only commits that changed how many times this text appears'), show_signature: z.boolean().optional().describe('Check and show each commit\'s signature') },
+  seam_describe: { quilt: QUILT, rev: REV },
+  seam_merge_base: { quilt: QUILT, a: z.string().max(200), b: z.string().max(200) },
+  seam_search: { pattern: z.string().max(500), quilts: z.array(z.string().max(200)).max(100).optional(), rev: REV, paths: PATHS, ignore_case: z.boolean().optional(), fixed: z.boolean().optional(), files_only: z.boolean().optional(), limit: z.number().int().min(1).max(2000).optional() },
+  seam_grep: { quilt: QUILT, pattern: z.string().max(500), rev: REV, paths: PATHS, ignore_case: z.boolean().optional(), fixed: z.boolean().optional(), files_only: z.boolean().optional(), limit: z.number().int().min(1).max(2000).optional() },
+  seam_bisect: { quilt: QUILT, good: z.string().max(200).describe('A revision without the problem'), bad: z.string().max(200).optional().describe('A revision with it; default main'), marks: z.record(z.string().max(100), z.enum(['good', 'bad', 'skip'])).optional().describe('Commits tested so far'), run: z.string().max(4000).optional().describe('A check command, run in each checked-out commit: exit 0 good, 125 skip, other bad') },
   seam_show: { quilt: QUILT, rev: REV, format: z.enum(['unified', 'stat', 'names']).optional(), paths: PATHS },
   seam_diff: { quilt: QUILT, from: REV, to: REV, format: z.enum(['unified', 'stat', 'names']).optional(), paths: PATHS },
   seam_blame: { quilt: QUILT, path: z.string().max(1000), rev: REV },
   seam_cat: { quilt: QUILT, path: z.string().max(1000), rev: REV, format: z.enum(['diff', 'snapshot', 'git']).optional().describe('How a conflicted file is written (default diff)') },
   seam_ls: { quilt: QUILT, rev: REV, paths: PATHS },
   seam_commit: {
-    quilt: QUILT, square: SQUARE, message: z.string().max(65536).describe('Why'),
+    quilt: QUILT, square: SQUARE, message: z.string().max(65536).optional().describe('Why (with amend, a new message; left out, the old one stays)'),
+    amend: z.boolean().optional().describe('Change the square\'s last commit instead of adding one: its changes plus these, under the same parents'),
     files: z.array(z.object({ path: z.string().max(1000), content: z.string(), base64: z.boolean().optional(), mode: z.enum(['file', 'exec']).optional() })).max(2000).optional(),
     delete: z.array(z.string().max(1000)).max(2000).optional(),
-    paths: PATHS
+    paths: PATHS,
+    sign: z.boolean().optional().describe('Sign the new commit with this computer\'s key (seam_key_add)')
   },
   seam_square_handoff: { quilt: QUILT, square: SQUARE, to: z.string().max(200).describe('The member to hand it to'), note: z.string().max(2000).optional() },
   seam_abandon: { quilt: QUILT, square: SQUARE },
@@ -77,7 +149,9 @@ export const SEAM_INPUTS = {
   seam_rebase: { quilt: QUILT, square: SQUARE, onto: REV },
   seam_revert: { quilt: QUILT, rev: z.string().max(200).describe('patch:12, a commit id, …'), line: z.string().max(100).optional() },
   seam_cherry_pick: { quilt: QUILT, square: SQUARE, from: z.string().max(200) },
-  seam_resolve: { quilt: QUILT, square: SQUARE, entries: z.array(z.object({ path: z.string().max(1000), choose: z.union([z.enum(['ours', 'theirs', 'base', 'suggestion', 'delete', 'keep_edit', 'keep_delete']), z.number().int().min(0).max(8)]) })).min(1).max(500) }
+  seam_resolve: { quilt: QUILT, square: SQUARE, entries: z.array(z.object({ path: z.string().max(1000), choose: z.union([z.enum(['ours', 'theirs', 'base', 'suggestion', 'delete', 'keep_edit', 'keep_delete']), z.number().int().min(0).max(8)]) })).min(1).max(500), remember: z.boolean().optional().describe('Remember the answer for the same conflict next time (default true)') },
+  seam_resolutions: { quilt: QUILT, path: z.string().max(1000).optional() },
+  seam_forget_resolution: { quilt: QUILT, key: z.string().min(8).max(64) }
 }
 
 /**
@@ -94,13 +168,47 @@ export async function runSeamTool (name, args, { client, found = null }) {
   const sync = async (head, sq) => { if (inFolder && head && head !== block.head) { const s = await syncTo(client, found.dir, block, head, { square: sq }); return `\nThe folder now holds the square's files (${s.written} updated).` } return '' }
   try {
     switch (name) {
+      case 'seam_line_require': {
+        if (args.approvals === undefined && args.checks === undefined) return describePolicy(await client.linePolicy(needQuilt(), args.line))
+        return describePolicy(await client.setLinePolicy(needQuilt(), args.line, { ...(args.approvals !== undefined ? { approvals: args.approvals } : {}), ...(args.checks ? { checks: args.checks } : {}) }))
+      }
+      case 'seam_reviews': return describeReviews(await client.reviews(needQuilt(), needSquare()))
+      case 'seam_review': return describeReviewed(await client.review(needQuilt(), needSquare(), { kind: args.kind, body: args.body || '', ...(args.path ? { path: args.path } : {}), ...(args.line ? { line: args.line } : {}) }))
+      case 'seam_claims': return describeClaims(await client.claims(needQuilt(), square))
+      case 'seam_claim': {
+        const made = []
+        for (const p of args.patterns) made.push(await client.claim(needQuilt(), needSquare(), { pattern: p, note: args.note }))
+        return made.map((c) => `Claimed ${c.pattern} for ${c.square}: writes to it from other squares on ${c.line} are refused until the square merges or seam_unclaim.`).join('\n')
+      }
+      case 'seam_check': if (args.square) return describeSquareCheck(await client.reportSquareCheck(needQuilt(), args.square, { check: args.check, status: args.status }))
+        return describeCheck(await client.reportCheck(needQuilt(), args.line || 'main', { check: args.check, status: args.status, ...(args.patch ? { patch: args.patch } : {}) }))
+      case 'seam_unclaim': {
+        const out = []
+        for (const p of args.patterns) out.push(await client.unclaim(needQuilt(), needSquare(), p))
+        return out.map((r) => `Let go of ${r.released.pattern}.`).join('\n')
+      }
+      case 'seam_live': return describeLive(await client.live(needQuilt(), needSquare()))
+      case 'seam_live_set': {
+        const given = [...(args.files || []).map((f) => ({ path: f.path, op: 'put', content: f.base64 ? f.content : Buffer.from(f.content, 'utf8').toString('base64'), mode: f.mode || 'file' })), ...(args.delete || []).map((p) => ({ path: p, op: 'delete' }))]
+        const changes = given.length || !inFolder ? given : localChanges(found.dir, block).map((c) => c.status === 'deleted' ? { path: c.path, op: 'delete' } : { path: c.path, op: 'put', content: c.bytes.toString('base64'), mode: c.mode })
+        return describeLiveSet(await client.setLive(needQuilt(), needSquare(), { changes }))
+      }
+      case 'seam_restore':
+      case 'seam_reset':
+      case 'seam_clean': {
+        if (!found) throw new Error(`${name} works on a block folder: run seam mcp in a folder made by seam checkout.`)
+        const files = (args.paths || []).map((p) => path.resolve(found.dir, p))
+        if (name === 'seam_restore') return describeRestore(await restore(client, found.dir, block, { paths: files }))
+        if (name === 'seam_reset') return describeReset(await reset(client, found.dir, block, { rev: args.rev }), block)
+        return describeClean(clean(found.dir, block, { paths: files, dryRun: !!args.dry_run }), 'Call seam_clean again without dry_run to remove them.')
+      }
       case 'seam_quilts': {
         if (args.new) { const q = await client.createQuilt({ slug: args.new }); return `Made quilt ${q.slug} (${q.id}).` }
         const list = await client.quilts()
         return list.length ? list.map((q) => `${q.slug} (${q.id}), ${q.level}`).join('\n') : 'No quilts yet.'
       }
       case 'seam_open_square': {
-        const sq = await client.openSquare(needQuilt(), { title: args.title, line: args.line, task_id: args.task_id })
+        const sq = await client.openSquare(needQuilt(), { title: args.title, line: args.line, task_id: args.task_id, ...(args.on ? { on: args.on } : {}) })
         return `Opened ${describeSquare(sq)}.\nCommit in it with seam_commit (square: "${sq.short}") and merge it with seam_merge.`
       }
       case 'seam_squares': {
@@ -111,24 +219,45 @@ export async function runSeamTool (name, args, { client, found = null }) {
         if (inFolder) return describeStatus(await blockStatus(client, found.dir, block))
         return describeSquareStatus(await client.square(needQuilt(), needSquare()))
       }
-      case 'seam_log': return describeLog(await client.log(needQuilt(), { rev: args.rev || (block?.square ? block.square_short : 'main'), paths: args.paths, limit: args.limit }), { oneline: true })
+      case 'seam_log': return describeLog(await client.log(needQuilt(), { rev: args.rev || (block?.square ? block.square_short : 'main'), paths: args.paths, limit: args.limit, follow: args.follow || undefined, search: args.search, show_signature: args.show_signature || undefined }), { oneline: !args.show_signature })
+      case 'seam_describe': return (await client.describe(needQuilt(), args.rev || (block?.square ? block.square_short : 'main'))).describe
+      case 'seam_merge_base': return describeMergeBase(await client.mergeBase(needQuilt(), args.a, args.b))
+      case 'seam_search': return describeGrep(await client.search({ pattern: args.pattern, quilts: args.quilts, rev: args.rev, paths: args.paths, ignore_case: args.ignore_case || undefined, fixed: args.fixed || undefined, limit: args.limit }), { filesOnly: !!args.files_only })
+      case 'seam_grep': return describeGrep(await client.grep(needQuilt(), { pattern: args.pattern, rev: args.rev || (block?.square ? block.square_short : 'main'), paths: args.paths, ignore_case: args.ignore_case || undefined, fixed: args.fixed || undefined, limit: args.limit }), { filesOnly: !!args.files_only })
+      case 'seam_bisect': {
+        const o = { bad: args.bad || 'main', good: args.good, marks: args.marks || {} }
+        if (!args.run) return describeBisect(await client.bisect(needQuilt(), o))
+        const { bisectRun } = await import('./bisect-run.js')
+        return describeBisect(await bisectRun(client, { quilt: needQuilt(), ...o, run: args.run }))
+      }
       case 'seam_show': return describeShow(await client.show(needQuilt(), args.rev || 'main', { format: args.format || 'unified', paths: args.paths }), { format: args.format || 'unified' })
       case 'seam_diff': return describeDiff(await client.diff(needQuilt(), { from: args.from, to: args.to, paths: args.paths, format: args.format || 'unified' }), { format: args.format || 'unified' })
       case 'seam_blame': return describeBlame(await client.blame(needQuilt(), args.rev || 'main', args.path))
       case 'seam_cat': { const r = await client.cat(needQuilt(), args.rev || 'main', args.path, { format: args.format || 'diff' }); return Buffer.from(r.content, 'base64').toString('utf8') }
       case 'seam_ls': { const r = await client.tree(needQuilt(), args.rev || 'main', args.paths); return r.entries.map((e) => `${e.mode}\t${e.path}`).join('\n') || 'No files.' }
       case 'seam_commit': {
+        if (!args.amend && !args.message) return 'Say why: message.'
+        const signed = async (r, verb) => {
+          const text = describeWrite(r, verb)
+          if (!args.sign || !r?.result?.id) return text
+          const s = await signWithLocalKey(client, needQuilt(), r.result.id)
+          return `${text}\nSigned with ${s.signature.key}.`
+        }
+        if (args.amend && inFolder && !args.files && !args.delete) {
+          return signed(await amendFolder(client, found.dir, block, { message: args.message, paths: (args.paths || []).map((p) => `${found.dir}/${p}`) }), 'Amended the last commit as')
+        }
         if (inFolder && !args.files && !args.delete) {
           const r = await commitFolder(client, found.dir, block, { message: args.message, paths: (args.paths || []).map((p) => `${found.dir}/${p}`) })
-          return r.nothing ? 'Nothing to commit: no file in this folder changed since the last commit.' : describeWrite(r, 'Committed')
+          return r.nothing ? 'Nothing to commit: no file in this folder changed since the last commit.' : signed(r, 'Committed')
         }
         const changes = [
           ...(args.files || []).map((f) => ({ path: f.path, op: 'put', content: f.base64 ? f.content : Buffer.from(f.content, 'utf8').toString('base64'), ...(f.mode ? { mode: f.mode } : {}) })),
           ...(args.delete || []).map((p) => ({ path: p, op: 'delete' }))
         ]
-        if (!changes.length) return 'Nothing to commit: give files (and delete), or run in a block folder.'
         const sq = await client.square(needQuilt(), needSquare())
-        return describeWrite(await client.commit(quilt, sq.id, { expect_head: sq.head, message: args.message, changes }), 'Committed')
+        if (args.amend) return signed(await client.amend(quilt, sq.id, { expect_head: sq.head, message: args.message, changes }), 'Amended the last commit as')
+        if (!changes.length) return 'Nothing to commit: give files (and delete), or run in a block folder.'
+        return signed(await client.commit(quilt, sq.id, { expect_head: sq.head, message: args.message, changes }), 'Committed')
       }
       case 'seam_square_handoff': { const sq = await client.handoff(needQuilt(), needSquare(), { to: args.to, note: args.note }); return `Handed ${sq.short} to ${sq.holder}.` }
       case 'seam_abandon': { const sq = await client.abandon(needQuilt(), needSquare(), inFolder ? { expect_head: block.head } : {}); return `Abandoned ${sq.short}; seam_reopen brings it back.` }
@@ -147,6 +276,48 @@ export async function runSeamTool (name, args, { client, found = null }) {
         const r = await client.split(needQuilt(), needSquare(), { by: 'paths', groups: args.groups, titles: args.titles, ...(inFolder ? { expect_head: block.head } : {}) })
         return [`Kept in ${r.square.short}: ${r.kept.join(', ') || '(nothing)'}`, ...r.squares.map((q) => `New ${describeSquare(q)}: ${q.paths.join(', ')}`)].join('\n') + await sync(r.square.head, r.square)
       }
+      case 'seam_line_list': {
+        const ls = await client.lines(needQuilt())
+        return ls.map((l) => `${l.name}: ${l.patch_count} patches, tip ${l.tip ? l.tip.slice(0, 12) : '(empty)'}${l.frozen ? ', frozen' : ''}`).join('\n')
+      }
+      case 'seam_line_new': {
+        const l = await client.newLine(needQuilt(), { name: args.name, from: args.from })
+        return `Made line ${l.name} at ${l.tip ? l.tip.slice(0, 12) : '(empty)'}. Open a square on it with seam_open_square (line: "${l.name}").`
+      }
+      case 'seam_line_freeze': { const l = await client.freezeLine(needQuilt(), args.line); return `${l.name} is frozen: merges into it are refused until seam_line_unfreeze.` }
+      case 'seam_line_unfreeze': { const l = await client.unfreezeLine(needQuilt(), args.line); return `${l.name} takes merges again.` }
+      case 'seam_tag_list': { const ts = await client.tags(needQuilt()); return ts.length ? ts.map(describeTag).join('\n') : 'No tags yet.' }
+      case 'seam_release_list': { const rs = await client.releases(needQuilt()); return rs.length ? rs.map(describeRelease).join('\n') : 'No releases yet.' }
+      case 'seam_import_git': {
+        const { importGit } = await import('./import-git.js')
+        const { default: nodePath } = await import('node:path')
+        const repo = nodePath.resolve(found?.dir || process.cwd(), args.path)
+        const r = await importGit(client, { repo, slug: args.into || nodePath.basename(repo).toLowerCase().replace(/[^a-z0-9-]/g, '-'), validate: !!args.validate })
+        return describeImport(r)
+      }
+      case 'seam_sign': {
+        const rev = args.rev || (block?.square ? block.square_short : 'main')
+        if (args.signature) { const id = (await client.describe(needQuilt(), rev)).commit; const r = await client.sign(needQuilt(), id, { key: args.key, signature: args.signature }); return `Signed ${r.short} with ${r.signature.key}.` }
+        const r = await signWithLocalKey(client, needQuilt(), rev)
+        return `Signed ${r.short} with ${r.signature.key}.`
+      }
+      case 'seam_keys': return describeKeys(await client.signingKeys({ member: args.member }))
+      case 'seam_key_add': {
+        let pub = args.public_key
+        let made = false
+        if (!pub) { const k = localKey(); if (k) pub = k.public_key; else { pub = makeLocalKey(); made = true } }
+        const r = await client.addKey({ public_key: pub, name: args.name || '' })
+        return `${made ? `Made a signing key at ${signingKeyFile()} and added` : 'Added'} ${r.key}. Sign with seam_commit { sign: true } or seam_sign.`
+      }
+      case 'seam_token_list': return describeTokens(await client.tokens(needQuilt()))
+      case 'seam_token_new': return describeNewToken(await client.createToken(needQuilt(), { name: args.name, level: args.level || 'read' }))
+      case 'seam_token_revoke': { const r = await client.revokeToken(needQuilt(), args.token); return `Revoked token ${r.name} (${r.id}): it no longer reaches the quilt.` }
+      case 'seam_key_remove': { const r = await client.removeKey(args.key); return `Removed ${r.key}: commits it signed now show removed_key.` }
+      case 'seam_tag':
+      case 'seam_release': {
+        const x = name === 'seam_tag' ? await client.createTag(needQuilt(), { name: args.name, rev: args.rev }) : await client.createRelease(needQuilt(), { name: args.name, rev: args.rev, notes: args.notes })
+        return `${name === 'seam_tag' ? 'Tagged' : 'Released'} ${x.name} at ${x.short}${x.patch ? ` (${x.patch.line}:${x.patch.patch_no})` : ''}. Read it as tag:${x.name}.`
+      }
       case 'seam_merge': {
         if (args.from) {
           const r = await client.mergeSquare(needQuilt(), needSquare(), { from: args.from, message: args.message, ...(inFolder ? { expect_head: block.head } : {}) })
@@ -168,9 +339,14 @@ export async function runSeamTool (name, args, { client, found = null }) {
         return describeWrite(r, 'Picked') + await sync(r.square.head, r.square)
       }
       case 'seam_resolve': {
-        const r = await client.resolve(needQuilt(), needSquare(), { ...(inFolder ? { expect_head: block.head } : {}), entries: args.entries })
+        const r = await client.resolve(needQuilt(), needSquare(), { ...(inFolder ? { expect_head: block.head } : {}), entries: args.entries, ...(args.remember === false ? { remember: false } : {}) })
         return describeWrite(r, 'Resolved') + await sync(r.square.head, r.square)
       }
+      case 'seam_resolutions': return describeResolutions(await client.resolutions(needQuilt(), args.path))
+      case 'seam_forget_resolution': {
+        const r = await client.forgetResolution(needQuilt(), args.key)
+        return `Forgot ${r.forgotten.short} (${r.forgotten.path}): that conflict will be asked about again.`
+      }
     }
     return `Unknown tool ${name}.`
   } catch (e) {

package/package.json

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