heyquilt 0.3.122 → 0.3.138

package/RELEASES.md

@@ -11,12 +11,285 @@ Format: `## <version> — <YYYY-MM-DD>`, an optional one-line summary, then bull
 Lead each bullet with a short bold phrase. Inline `code` and **bold** are rendered;
 nothing else is.
 
+## 0.3.138 — 2026-11-01
+
+0.3.137 was tagged but never published; everything meant for it is here.
+
+- **A new session's code is in Seam from the start.** With `QUILT_SOURCE_DEFAULT=1` on the accounts API, a session you start from the app, with `quilt join`, or by an AI with `quilt_start_session` (in any tool) is a quilt from the start: its folder's files, small binaries and executables are its first patch, and the folder follows its own square, so the app shows Seam's source control straight away. No git import, no follow.
+- **A new session whose code can't go into Seam still works.** A folder with a git remote stays on git (its history comes into Seam with it later), and if Seam can't be reached or refuses, the session runs on git as before; Quilt says why and that `quilt session migrate` tries again.
+- **"Make this a quilt" for session owners.** Settings → Session → Source control has a Make this a quilt button for the session's owner. For a session with no git remote it moves the code into Seam in one step: main as it is becomes the quilt's first commit, each branch a square, and every folder follows its square live. `quilt session migrate` does the same one step (with `--link-only` for the old first half only), and so does `POST /v1/sessions/:room/migrate { step: "make" }`.
+- **"Make this a quilt" for a session with a git remote.** The same button takes it one step per click: Seam imports the GitHub repository and follows it (your remote, clones and CI keep working as they are), the session then reads its history from the quilt, and when the team is ready the button moves it in with its history, after the repository's GitHub owner has let only Seam push to main (the card lists the steps). Seam then pushes main to GitHub after each merge. If Seam can't read the repository yet, the card says how to let it.
+- **The date for moving sessions into Seam, when one is set.** When a date is set (none is yet), the owner's card says when it is. From that date a session with no git remote becomes a quilt the next time its owner opens it, and a session with a git remote that has not moved has its live file sync stopped: everyone hears "Live sync stopped: this session's folder is plain git now", in the app, the chat and every AI's next Quilt answer. Chat, tasks, the agent feed and the audit trail carry on, and nothing in git is touched: the remote, every clone and CI keep working.
+- **No more New session from GitHub.** A new session starts from a folder, and its code is committed in Seam from the start; to bring a repository and its history into Seam, use `seam github import`. An older window that still offers GitHub says so instead of cloning.
+- **The branch list is gone from the git panel.** A session still on git shows this folder's branch, how it stands against its upstream, and Check, as before; the list of every branch and who is on it went, since git says which branch a folder is on.
+
+## 0.3.136 — 2026-11-01
+
+- **Two additions at one place keep their closing brackets.** When two people both added lines at the same spot (two new entries in a JSON list, say, or two new functions), Quilt wrote a line both additions ended with, like `],` or `}`, only once, which could leave the file broken, such as a JSON file that no longer parses. Each addition now keeps its own brackets and commas. Lines both start or end with that have words in them, like a shared heading, are still written once.
+
+## 0.3.135 — 2026-11-01
+
+- **A folder behind its square never writes its old view into it.** An app back with a folder whose files were older than its square's (git behind main, say) wrote them to the branch's old copy, and the relay put them into the square as edits: older copies of main's files, and deletions of the files main added since. Once a square has moved on from where its copy was made, such a write stays in that folder and goes in only through its own follow, which takes in only what the folder itself changed.
+- **Main waits for a folder that can't follow it.** When a folder on a square runs a Quilt too old to follow a square whose base moves (before 0.3.133), main's newer patches wait to come in, and the square's card and `quilt_status` say whose Quilt needs updating. They come in once it is updated, or leaves the square.
+- **Bringing main in never takes an older copy of main's file for work.** A file in a square that is only one of main's earlier versions, or the deletion of a file main added after the square opened, was committed as a "conflict" with main when main came in. Main's version now stands, and the square's card says which files those were. Real edits are combined or kept as conflicts as before.
+- **Other people's ignored files stay out of squares.** Moving a session into Seam put untracked files that `.gitignore` or Quilt leaves out (an agent's scratch folder, logs, `supabase/.temp`, `.claude/settings.local.json`) into the main branch's square as work. They stay in the folders that have them now, and a commit never takes them.
+
+## 0.3.134 — 2026-11-01
+
+- **An app too old for a session is told just how to update.** Quilt now says "This session needs Quilt 0.3.127 or later. Update Quilt, then join again." and how for each kind of install: in the desktop app, Settings → About → Update Quilt; on Linux without a desktop, `curl -fsSL https://heyquilt.com/install.sh | sh`. It no longer says the session "moved into Seam", which read as if Seam were a way to join it.
+- **AIs hear of Seam only as where code is committed.** `quilt_status` and Quilt's answers to AIs say the session's code is committed and merged in Seam, and that chat, tasks and the session stay in Quilt.
+- **The app says the same.** The square card and panel, Settings → Session, the cloud AI card and the line shown while a session moves say the session's code is committed and merged in Seam, and that the session itself stays in Quilt, instead of "This session is in Seam".
+- **No more `npm i -g heyquilt` in Quilt's instructions.** The heyquilt package on npm is behind the releases, so the update and install steps no longer mention it.
+- **Every release has the Linux downloads again.** Releases are built on Seam's own runners now (Linux and the cloud AI machine on Fly, Mac and Windows on a Mac), so each one has all eight files, the Linux AppImages and command-line bundles included, and `curl -fsSL https://heyquilt.com/install.sh | sh` installs the newest Quilt.
+
+## 0.3.133 — 2026-11-01
+
+- **Moving into Seam never deletes a file your folder didn't have yet.** A file the session was keeping out of your folder (someone else's new file, not committed yet, or a change waiting for whoever held the file) counted as your deletion when your folder first followed its square, and the square deleted it for everyone. Your folder now gets the square's copy.
+- **Your folder and its square don't stay out of step without a word.** A change from the square that couldn't be written to your folder held up the rest and was never tried again, so a folder could keep a file the square had deleted. Each file is written on its own, the folder is brought in step again every 15 seconds, and what can't be written yet shows in Quilt's status.
+- **Main's new patches come into your square by themselves.** When someone merges onto main, every square people follow takes the new patches: one of its members' apps (whoever holds the square, else another member on it) brings them in as that member, as Quilt did with outside commits in git. Files nobody in the square changed come to every folder as main has them; a file the square changed is combined with main's change, including anything typed while it happens. Your ignored files are never touched.
+- **A conflict with main stays yours to settle.** When main and your square changed the same lines, nothing is forced: both sides are marked in the file in everyone's folder, as after a merge that conflicts. Edit the markers out, commit, and merge again.
+- **You can see how far behind main your square is.** The square card and panel, and `quilt_status`, say when main has newer patches, when they last came in and who brought them in, and which files conflict with main.
+- **Rebasing a square with `seam_rebase` no longer drops main's changes to files you have open edits in.** Your uncommitted work is combined with what the rebase changed, and a square with no commits of its own follows its new base too.
+- **The Squares sidebar has one heading.** In a session in Seam it said "Squares" twice, once as the pane's title and again right under it.
+
+## 0.3.132 — 2026-11-01
+
+- **A session without git history moves into Seam whole.** Its first patch waited on an approval nobody could give on Seam's hosted service; Seam now takes a new quilt's first content as it is, and the move puts your small binary files and executables in it too, not only text files.
+- **Letting go of a file works once your session is in Seam.** `quilt release`, `quilt_release` and the app's Release let go of your claims in Seam, as you. The move made everyone's claims as the person who moved the session: each now says whose it was, and only that person (or the session owner, naming it) lets go of it.
+- **A cloud AI needs nothing added by hand to work in its person's quilt.** Seam lets an agent in through the person it works for. When that person is not in the quilt, the AI is told so, with the command that adds them.
+- **When Seam can't be reached, your AI hears why.** A commit or merge that could not trade its key says Seam could not be reached and what to check, not "fetch failed"; a cut-over or an export push waits up to 30 minutes instead of stopping at 5.
+- **Moving into Seam no longer gives up because someone typed at the wrong moment.** An edit that landed just after the move read a branch failed its last check, and the move was undone; such an edit now goes into the square, and the move carries on.
+- **A repository and its git worktree can both follow squares.** Two of your folders moving into Seam at once could leave the worktree with a new `.git` while it followed, and git's worktree locked after going back. Each `.git` pointer is now changed where it is.
+
+## 0.3.131 — 2026-11-01
+
+- **Moving a session into Seam no longer stops at a branch git merged long ago.** A branch whose last commit is already merged into main is kept inside the merged square in Seam, not as a patch, so the move failed on it; its square now starts at main's tip, which holds that work, and the move says so.
+- **An AI's task branch gets its square too.** Branches an AI works on are named `quilt/<agent>/<task>`, and the relay took them for a square's own copy, so moving the session into Seam left them without a square. Only a square's id after `quilt/` counts as one now.
+- **Moving into Seam never puts an older copy of a file back in your folder.** A file someone had boxed went into the move's square as their whole file, on the main they had when they began, and folders took it over their newer copy. Now only their change goes onto main's newer copy, in the square and in your folder.
+
+## 0.3.130 — 2026-10-31
+
+- **`quilt session migrate` says what happened instead of "fetch failed".** A move into Seam that took more than five minutes was given up after five with only "fetch failed" (the command meant to wait ten), and so was a move through an app too old for Seam, which the relay sends away at the end of the move. The command now waits as long as the move takes and says first that it can take minutes; it refuses to start through an app that can't follow Seam (update or restart Quilt first); and if the app stops answering meanwhile, it says the relay finishes or undoes the move on its own and how to check. Every other `quilt` command says in words when the app isn't answering, or is too old for it.
+- **In a session that moved into Seam, the app's source control is Seam's.** The source control button at the top names the square your folder follows (`sq:…`, as Seam names it), and its panel commits that square with a message and merges it onto main, so a person no longer needs the `quilt commit` command or an AI to land work. The panel no longer lists the branches kept read-only for a move back, Session settings' Source control says where the history is instead of offering git's agent rules, Sync with GitHub and a GitHub token, and nothing offers to connect GitHub.
+- **In a session that moved into Seam, the app shows your files as they are now.** Its Files list and an open file showed the session's copy from the moment of the move, frozen, so a partner's edit or a new file never appeared there (your folder had them). They come from your folder now, which is your square's live copy, and redraw as it changes. The number on the source control button is what your square holds not committed yet, listed in its panel, instead of the session's changes from before the move.
+- **A folder on a branch with no square says so in plain words, with a button.** The app's card and source control panel say your folder's branch has no square in Seam yet, with Open a square for it, instead of the relay's words naming a tool; it opens the same square the relay opens on the first write there, with your files as its work.
+- **Nothing in a session in Seam asks you to use git.** Ask for a commit is gone from the session menu there (whoever is on a square commits it, and a request is refused with how), @Quilt no longer offers git's status or trimming the branches kept for a move back, Account settings say the open session is in Seam, and your cloud AI's settings say it lands work in its folder's square in Seam instead of pushing branches with pull requests.
+- **Going back to git leaves your square work yours.** On `quilt session migrate --back`, each file's unfinished work from the square went into the box of whoever's folder reached the session first, so the person who actually wrote it could find their next edit reaching nobody (or undone) until someone else committed. Now each file is boxed by whoever last wrote it in the square.
+- **Everyone sees when the session is moving into Seam or back.** A large session's move takes minutes, and the apps used to show the session as it was until it landed. Now every member's app (and quilt_status) says "Moving into Seam" or "Moving back to git" while it runs, with what to expect: keep Quilt open, it can take a few minutes, your edits are kept. Committing and merging wait until it is done.
+- **Commit and Merge onto main say what happened in plain words.** The message after Commit used to be the tool's own text (ids, "held by person:…"); now it is `Committed "<message>": 3 files.`, and a merge says which patch it made, what it combined with, and that your folder carries on, without command-line hints.
+- **Patches are named after their work, not "main".** A square the move into Seam opened for a branch carries the branch's name, so every patch merged from it was called "main". Merged from the app, `quilt commit`'s folder or any AI's seam_merge, such a patch now takes its commit's message, or "3 commits: …".
+- **The left sidebar shows squares in Seam, not boxes.** There are no boxes there (every edit is live in its square): the sidebar lists each square, who is on it, and how many of your square's files are not committed yet.
+- **When a session stops by itself, the app says why.** Sent away to update Quilt, ended by its owner or not let in, a session used to drop you back on Home without a word; the reason now shows for a few seconds as it closes.
+- **Moving a session into Seam loses nothing, even when it takes minutes.** Edits and claims made while the move runs go into their squares (they were left behind before). An edit that reaches a branch's old copy after the move, from an app that has not caught up yet or one coming back with work made offline, goes into the branch's square and stays in the old copy for going back; before, a typed edit there was dropped without a word. If the relay restarts or the session moves to another relay machine in the middle of a move, the session is back as it was and the next `quilt session migrate` tidies up the squares the stopped one opened, instead of being stuck half moved.
+- **A branch with no square gets one when someone writes there.** When the move opened no square for a branch (main with nothing new on it, say), edits to it are kept, and the first person who writes there gets a square for it, held by them and started where the branch was; every folder on the branch follows it with its edits. A branch checked out after the move gets a square at main's tip, with the folder as it is.
+- **The session's read token is looked after.** Every folder reads its square with it. The move checks it and makes a new one when it is missing, about to end or no longer taken by Seam; after the move the owner's Quilt renews it by itself a month before it ends or as soon as Seam turns it down (`quilt session migrate --shadow <quilt>` does it by hand), and a folder that can't read its square says so. The move also says when a branch's square starts at main's tip because the relay never fetched that branch from git. An older Quilt turned away from a session that moved into Seam is told which version it needs.
+- **Going back to git keeps every square's work.** When nobody's folder follows a square any more (everyone on it is offline, or a cloud AI's machine was replaced), `quilt session migrate --back` commits its work in the square, where it stays readable in Seam, and copies it into its branch, so it lands once even when a folder brings the same work back later. What can't go into a branch (a link, a very large file) is named with the `seam cat` that gets it.
+- **An edit in a folder that follows its square always reaches the others.** On a Mac, an edit made at the moment another folder's square opened or closed in the same app (after a merge, say) could sit unseen until the next edit; the folder is now looked at every second as well, as it was before the move.
+- **Large files git doesn't have come along into Seam.** The move names them, and your folder puts them in its square when it follows it, in chunks however large.
+- **Moving into Seam, or coming back to it, keeps everyone's work.** When your folder first followed its square, every file it lacked or still had as git left it was taken for your deletion or edit: a branch that left main before main's newer work, a folder whose git was behind, or a Quilt that was closed during the move undid others' work in the square, and on main at the next merge. Now only what your branch changed since it left main (committed or not, a deletion too) goes in as yours, the square's versions of everything else come to your folder, and a file you edited while away is combined with others' changes to it.
+- **Everyone's AIs can commit in every square right after a session moves into Seam.** The squares the move opened were held by whoever ran it, so an AI working for anyone else was refused ("this square is held by …") until that person's own app happened to share them. Now the move makes every person in the session a writer of every square, and names anyone Seam would not take.
+- **An AI working in a session that moved into Seam is told the Seam way, whenever it started.** An AI session (Claude Code, Cursor, Codex, Gemini or a hosted agent) that started before the move was told the git way when it started, and kept it: now its next Quilt answer says, once, how work lands in Seam. A git tool it still calls from its old tool list answers with the Seam tool to use, instead of a bare "disabled". A task that had a GitHub pull request before the move no longer makes Done refuse an AI (or fail for a person), and moving it to QA no longer mentions it.
+- **Your cloud AI's commits and merges in Seam work end to end, as itself.** Its Quilt key is traded for a Seam token of its own through Quilt, it commits and merges its square, and its folder carries on in the next square, while you keep acting as yourself on the same computer or square. If Seam doesn't let it into the quilt yet, it says exactly what does (`seam quilts add agent:<its id> --level write`) to pass on to you, instead of "no such quilt". When its merge waits for someone's approval, it asks in Quilt's chat too, so you see it, and you approve from your own AI.
+- **quilt_history reads Seam as you, or as your cloud AI.** It used the separate "Connect Seam" sign-in, so most folders read the history through the relay; now it uses the sign-in your Seam tools use.
+- **A hosted agent can read the project's rules in a session that moved into Seam.** quilt_project_rules reads AGENTS.md and the other rule files from main in Seam instead of refusing.
+- **seam_open_square in a folder that follows its square points at that square.** An AI there opened a second square beside its folder's and then had to send whole files to it; now it is told to edit in the folder and seam_commit.
+- **An AI that takes its next task just as its last one's branch merges gets a branch for it.** Its folder leaving the merged branch and moving to the new task's branch both changed branch at once, and the task could end up with no branch of its own.
+- **A folder that can't follow its square yet no longer piles up connections to the relay.** Each failed try (and a try still waiting when Quilt stopped) left a connection behind that kept reconnecting for good.
+- **Edits made just as your folder changes square are kept.** If you or your AI saved a file in the moment the session moved into Seam, or while a merge moved your branch on to its next square, the square's older copy could be written over it. Now the edit goes into your square and stays on disk.
+- **Your git worktrees keep working when your folder follows its square.** The folder's `.git` is set aside while it follows its square in Seam, and every worktree made from it (`git worktree add`, in the folder or beside it) answered "not a git repository" meanwhile. Now they keep working, with their branches and work in progress, and are as they were when git comes back. A folder that is itself a git worktree is locked in its repository meanwhile, so `git worktree prune` or `git gc` there can no longer drop it.
+- **The audit trail shows a folder that follows a square once.** It used to count a second visit for it, and another at every merge.
+- **Who changed what carries on in Seam.** Edits made in a square are on record as their author's, as on a branch: a file's History, Changes, the session's activity and the Files tree's "edited by" marks go on past the move into Seam and past every merge, instead of stopping there.
+- **Coming back after your square merged takes in only your own edits.** If your app was closed while others' work in your square was merged, the files you edited meanwhile are combined with the square's, line by line, instead of your older copy going back in over their changes.
+- **Following a square costs less.** A folder that follows a square no longer downloads the whole session (its chat, tasks and activity) a second time, at the start and again at every merge.
+- **A submodule's files stay with its own git.** A session no longer shares the files inside a submodule (the folders `.gitmodules` names), and moving a session into Seam never puts them in a square; git keeps them, as it always did.
+- **The Loom keeps showing who works on what after the move into Seam.** Editing a file in your square claims it for you as it did on a branch, so the Loom's stitches, quilt_before_edit and the file queue carry on. Someone who may not post in the session keeps their edits on record in the activity too, a new file in their square included.
+- **A link that arrives with commits from outside is a link.** Commits brought into your folder by themselves wrote a link (symlink) as a file holding its target's name, and a folder that already had the same link stopped bringing commits in, asking someone to merge by hand. Now links come in as links.
+- **Moving into Seam again after going back starts clean.** A file your branch had deleted, which main had deleted too by then, still showed as a deletion in your square's work. It no longer does.
+- **A branch whose square starts at main's tip no longer undoes main's newer work.** When Quilt never learned a branch's own commit, its square starts at main's tip with the branch's files over it, and files main had changed since the branch left it went in as the branch's older copies: merging the square would undo main's changes. Now the relay leaves out, at the move, every file that is only an earlier version of main's own (from git's history), and your folder's first look at the square keeps only what your branch changed itself.
+
+## 0.3.129 — 2026-10-31
+
+- **See what you share.** While you share your screen in a call, a small preview of it sits in the bottom right corner of the session. Close it with its ×; you keep sharing, and Show in the call brings it back.
+
+## 0.3.128 — 2026-10-31
+
+- **The screen button in a call shares your screen.** In the desktop app it did nothing: Quilt let its window use the microphone only, so the request to share a screen was turned down before any picker opened, and the refusal was dropped in silence. Now the Mac's own picker opens (Quilt's on Windows and older Macs), and if sharing still can't start, Quilt says why instead of doing nothing.
+
+## 0.3.127 — 2026-10-31
+
+- **Your folder follows the session into Seam by itself.** When a session's owner moves it into its squares, your own folder (and each cloud AI's) carries on where it is: nothing in it is rewritten, every edit goes live in your branch's square for everyone on it, and edits made while Quilt was closed go in when it starts. The session view and quilt_status say which square your work is in. In a quilt it is all Seam, so the folder's git is set aside in `.quilt/git-before-seam` meanwhile (never deleted); if the owner moves the session back, git comes back and your folder syncs with its branch as before, with the square's work in it. Seam is now on by default (`QUILT_SOURCE_URL=off` turns it off), and it changes nothing for a session that is not a quilt.
+- **Every AI in a session that moved to Seam can land its work, with nothing to set up.** The Quilt tools every AI already has (Claude Code, Cursor, Codex, Gemini, your cloud AI and hosted agents alike) offer Seam's everyday tools there: seam_commit commits the square your folder is on, seam_merge merges it onto main once its checks pass, and seam_square_status, seam_diff, seam_log, seam_rebase, seam_resolve, seam_checks and seam_events do the rest. `quilt commit "<message>"` does the same from a terminal. All of them work as you (your AI sessions are you), as your cloud AI, or as the hosted agent, from the Quilt sign-in each already has. quilt_status says the new way in a few plain lines, the git tools step aside, and after a merge your folder carries on in a fresh square by itself.
+- **Squares go by the names Seam gives them, and going back to git is not one-way.** Quilt's messages name a square as Seam does (`sq:` and the end of its id), so a name you copy works in `seam diff`, the Seam tools and `--carried`; squares opened together used to look alike. `quilt session migrate --back` closes the squares it carries back to the branches, so their claims let go, and the session can move into Seam again later. A large session's move no longer says "the relay did not answer" while the relay is still at it.
+- **No edit vanishes in a session that moved into Seam.** An older Quilt is asked to update instead of sending edits nowhere, and if an edit still reaches a branch's old copy, Quilt says so in the app and in quilt_status. Moving a session into its squares also keeps its images and other binary files, links, executables and files git ignores, which it used to mark as deleted.
+
+## 0.3.126 — 2026-10-31
+
+- **Share your screen in a call.** In a call, the screen button next to mute shares a screen or a window with everyone in it. On a Mac with macOS 15 or later the system asks which; on Windows and older Macs Quilt shows your screens and windows to pick from. Partners see it in the middle of the session with the chat still beside it, fitted or at its own size, and full screen when they want; Hide puts back what was there, and the call says who is sharing. It goes straight between your computers, like the voice, and sharing needs Quilt 0.3.126 on both sides. Agents see who is sharing in quilt_status.
+
+## 0.3.125 — 2026-10-30
+
+- **Your cloud AI no longer goes silent on long work.** A run that reached the time limit used to vanish with "it printed nothing Quilt could read", losing what it had done. Now it says it stopped at the limit, what it changed stays in the folder, and replying carries the same chat on. The limit is two hours instead of thirty minutes, and asked for work, your AI first says it is on it.
+- **Quilt uses far less memory in a folder with many uncommitted files.** Every two minutes it worked out again who changed each uncommitted file, reading every one and its committed copy; on a cloud AI hundreds of files away from its commit, that took hundreds of MB each time. Now only files that changed since the last look are read again.
+- **The app no longer churns through gigabytes of memory in a busy session.** It worked out a session's whole status (every task, comment and change) on every presence update, several times a second, about 3 GB of short-lived memory a minute, and the app's memory settled at over 3 GB. The window now gets the status at most twice a second, STATUS.md is written at most every 1.5 seconds, and checking whether a file is text no longer copies it twice.
+- **A session can read its code's history from Seam while git stays in charge.** Behind `QUILT_SOURCE_URL` (off by default), the owner links a session with a git remote to the quilt its import fills (`quilt session migrate --shadow <quilt>`); quilt_history then shows the quilt's patches with the session's own changes, for every AI tool. In the cut-over, `quilt session migrate` makes that session the imported quilt itself: branches become squares at their imported commits, claims become Seam claims, and `--back` returns it to git once no square is left open (or each is named with `--carried`). Every app now tells the relay it can work in a quilt. Nothing changes for a session that is not linked.
+- **A file's History and Blame, and code search, in a session linked to a quilt.** In a session that reads a quilt from Seam, an open file's Changes becomes **History**: what people are changing now and have not committed, then the patches that touched the file, each opening in place with its diff (the same history quilt_history gives agents). A third segment, **Blame**, shows who wrote each run of lines, in which patch and how long ago; lines typed now are tinted and marked live, and a patch number opens it in History. A search field in the top bar searches the code on main and opens the hits as a tab you can close, each hit opening its file at that line. The relay reads Seam for everyone with the session's own read token, so your app needs no Seam setup, and quilt_history in your folder now shows the quilt's patches too. A session that isn't linked looks as before.
+
+## 0.3.124 — 2026-10-29
+
+- **People show with the AI they really use.** Someone whose Settings still said Windsurf (an older Quilt saved its guess when they changed their colour) showed as Windsurf even with their Claude Code connected. The AI connected through their app now wins, and partners see it right even before that person updates.
+- **A cloud AI you named knows its name.** Its runs are now told they are, say, Moss, Daniel's AI, so a message to @Moss is answered as Moss rather than as someone else answering about Moss.
+
+## 0.3.123 — 2026-10-26
+
+- **No more "left the call" sound while you can still hear everyone.** When someone's connection to Quilt blinked for a moment, the call played its leave sound (and then its join sound) although the audio never stopped. The sounds now follow who is really in the call: someone who hangs up is heard leaving at once, and a blink plays nothing.
+- **Your cloud AI no longer runs out of memory and goes quiet.** Each time its machine woke to a stale connection it joined the session again, and the old copy of the session stayed in memory until the machine crashed; a run caught in the middle posted its answer into the old copy, where nobody saw it. Old copies are now let go, and a run's answer goes out on the session it is in now. A session the relay closed for good is stopped too, not left running beside the new one.
+- **Seam has its own repository**: Seam's server, the `seam` command, its site and its database migrations moved out of this repository into their own (the Seam quilt `seam`), and Seam's changes are listed in its own RELEASES.md from now on. Quilt uses a pinned `@heyquilt/seam` (0.88.0) and Seam's API, and Quilt's tests no longer run Seam's.
+- **Seam keeps a daily copy of every quilt's files elsewhere**: a Seam server run with `SEAM_COPY_DIR` (a second volume) or `SEAM_COPY_SUPABASE_URL`, `SEAM_COPY_SUPABASE_KEY` and `SEAM_COPY_BUCKET` (a bucket in another project) copies each quilt's new uploads, archive and journal there once a day, so a lost bucket can be served from the copy. Redacted content leaves the copy too.
+- **Seam checks stored file contents too**: a Seam server run with `SEAM_SCRUB` now also reads a thirtieth of each quilt's stored files a day straight from storage and checks each against its fingerprint, so every file is checked once a month, checks every folder listing of each line's latest version daily, and checks every upload of the past week is fully stored; a damaged one is reported and holds cleanup back until it is looked at.
+- **Big files go to Git LFS on export.** Seam's export to a git remote can now send files over a size you choose, and files your `.gitattributes` marks for LFS, to the remote's LFS store, so hosts that refuse large files accept the export. Set it with `seam export remote --lfs-url`.
+- **Signed exported commits.** A Seam server with a signing secret now signs every commit it exports to a git remote with the quilt's own key, so git and your git host can show each one as verified. The export status shows the key to trust.
+- **Exported history shows stacked work.** A Seam server can now mark each exported git commit whose work was built on top of another unfinished piece of work with a `Quilt-Stacked-On` line naming that piece, so the order the work was planned in survives in git.
+- **A forgotten claim goes to whoever waits.** On a Seam server with idle release on, a file claim whose work has gone quiet now passes straight to the first person waiting for it, with the last note, and both are told; with nobody waiting it is let go and the holder is told why.
+- **Exported commits you can prove.** A Seam server can now end every commit it exports to git with a `Quilt-Attestation` line naming the signed log entry that merged it, so anyone can check with `seam verify` that the commit came from the quilt. It is off unless the server turns it on, because it changes the commit ids of what is exported next.
+- **Your AI fixes what Seam finds.** With "Work on its own" on and signed in to Seam, your AI now picks up a conflict in your work, a check that failed before merging, a change of yours that was reverted after merging (that one first), and a review someone asked it for. It merges only if you set it to merge when the line's rules allow it; by default it leaves the work ready for you.
+- **Fix an earlier commit without a rebase.** `seam square absorb` puts a square's shared live work into the commit of the square that last changed each file and rewrites the commits above it, so a review fix to commit 2 of 5 lands in commit 2. Files no commit of the square changed stay live. Also `seam_absorb` and `POST /squares/<s>/absorb` (seam 0.52.0).
+- **Approvals survive a typo fix.** An approval now still counts after the work is moved onto a newer version of the line, or after a commit that only changes comments or spacing. A real code change still asks the reviewer to look again. `seam line require main --approval-survives whitespace` makes a line stricter (only respacing keeps an approval), `docs` makes it looser (doc edits keep it too).
+- **Approve just your part.** `seam review approve --scope 'db/**'` approves only the paths you own: it settles the rules for those paths and asks someone else for the rest. A later change outside your part asks you to look again.
+- **The right reviewers, asked for you.** `seam review request` now also asks whoever the line's rules say must approve (a schema owner, the API team), and says which rule each was asked for; with no `--to` it asks just them.
+- **Suggest the fix, not just the problem.** A review comment on a line can now carry the replacement text (`seam review comment --path a.js --line 12 --suggest '…'`), and whoever holds the work applies it in one step with `seam review apply <id>`, as a commit that credits the reviewer. A suggestion on a file that changed since is refused rather than applied blindly.
+- **Pick up where you left off.** `seam review` now starts with what changed in a piece of work since you last looked at it, and `seam review interdiff` compares with that look when you have not approved or asked for changes yet.
+- **Ask someone to review.** `seam review request --to person:ann,agent:rev -m "…"` asks members to review a piece of work. Each gets a `review.requested` event with what the work still needs, and the review lists who was asked until each of them approves or asks for changes.
+- **A review says what is still missing.** A piece of work's review now lists what still stands between it and a merge: approvals still to get (and from whom, for which files), requests for changes not yet answered, and checks that are not green. `seam review` prints it as "needs: …", and "ready" means that list is empty.
+- **Stale approvals are named.** When a real code change means an approval no longer counts, the reviewer gets a `review.stale` event once, and the review standing lists it under `stale` with who gave it, the commit they saw and why (`class`: the change since is more than the line lets an approval survive), and `seam review` says "stale approval from …".
+- **See what changed since you reviewed.** `seam review interdiff` shows the files that changed in a piece of work since your last review, each marked as a comment fix, a docs change, logic and so on, and keeps changes that came in from the line under it out of the way.
+- **Working alone with your agents, your own approval counts.** In a quilt where you are the only person, you can approve the work your agents did, so a line that needs an approval no longer leaves you stuck. Your agents still cannot approve each other's work, and the moment a second person joins, approvals need someone other than the work's owner again.
+- **Take your whole quilt with you.** `seam export archive` (admins) downloads everything Seam keeps for a quilt as one file: its full history, every stored file and its members, with a checksum for each part. `seam export check <file>` checks that file on your own computer, with no server, and lists its lines and commits; `seam export extract <file> main --to <folder>` takes any version's files out of it, still with no server. `seam export git <folder> --from <file>` turns it back into a git repository with the same commits Seam's git export makes, also with no server. Each archive taken is recorded in the quilt's history: who took it and how much.
+- **See which infrastructure config a version of the code expects.** `seam quilts infra-paths default` makes `seam stack` answer an `infra` value that changes exactly when the deploy files (`fly.toml`, `infra/`, workflows, `Dockerfile`) change.
+- **Merged work points at the real database.** `seam line require main --stack-defaults db_branch=supabase:<ref>` makes every merge into the line record the line's own database, even when the work was done against a preview database that goes away afterwards.
+- **Say which database a piece of work runs against when you start it.** `seam square open "<title>" --stack-keys db_branch=supabase:<ref>` (and `stack` on the `seam_open_square` tool) gives the square its stack keys; its first commit carries them and every later commit inherits them.
+- **See which database a version of the code runs against.** `seam stack <revision>` (and the `seam_stack` tool) lists the pointers a commit carries, such as its database branch, each inherited from earlier commits until one changes it, and works out the schema level from the newest migration file under `supabase/migrations`. An admin can point it at another folder with `seam quilts migrations-dir <folder>`, or turn that off with `none`. `seam diff <a> <b> --stack` says which of them changed between two versions: did the schema move, or only the code? A folder checked out with `seam checkout` keeps the stack of its version in `.seam/block.json` (`stack`), so a deploy script can read the migration level from the folder it builds. A line can insist that every merge names a database branch (`seam line require main --needs-stack db_branch`), never moves the schema level back (`--monotonic-stack db_migration`), and takes migration files only in date order (`--migrations-in-order on`).
+- **Check who gets the credit before an import writes anything.** `seam import git <url> --ask-authors` reads the repository, lists every author with the person each would be credited to, and waits until you answer with `seam import authors`.
+- **Imports credit people by their email.** When a git repository comes into Seam, commits whose author email is the Seam account email of someone in the quilt are credited to them straight away, starting with your own; you no longer need an authors file for people who are already members.
+- **A Seam server's settings all take effect.** Settings such as the tip journal, the scrub, cleanup and event retention were quietly ignored when Seam ran as its own server; they now apply as set.
+- **Agents hear what happened without asking.** Every Seam tool answer now ends with the new events about the agent's work since its last answer (merges that touch its files, reviews, check results, claims) and anything waiting on it, like someone queued for a file it holds. The first answer starts fresh, so nobody gets a flood of old news.
+- **Events can be worked out off the API machines.** A Seam server's answering machines can run with `SEAM_DERIVE_WORKERS=queue` and leave events and webhooks to a separate `seam worker` process, so a slow webhook or a busy quilt never slows down requests. Nothing changes unless it is set.
+- **A read-only block names its square truthfully.** Opening one at a commit that is not part of that square is refused (`not_in_square`) instead of showing another square's files under its name.
+- **Folding a square into the one stacked on it collapses the stack.** The square on top takes over the folded square's starting point, so it holds both squares' work and merges on its own.
+- **Fold and split never half-finish.** Folding or splitting a square now happens all at once, so a square that changed meanwhile leaves nothing behind, and a fold carries the folded square's claims and the squares stacked on it over to the square it folds into.
+- **Edits made during a merge are kept.** When someone saves into a square's live work while it is merging, those saves no longer sit on a square that can't change: they move to a new follow-up square for the same person and task, ready to commit.
+- **More than one webhook.** `seam events --webhook <url> --add` posts your events to another address beside the ones you have (up to 5 per quilt), each with its own kinds, and `--remove` takes one away. A plain `--webhook` still replaces them, as before.
+- **Follow your events live.** `seam events --follow` prints each event as it happens until you stop it, and `GET /v1/quilts/<q>/events/stream` sends them as server-sent events, resuming where a dropped connection left off.
+- **Old events can expire.** A Seam server can keep events for a set number of days (`SEAM_EVENTS_RETENTION_DAYS`, off unless set). Asking for events from before that answers `410 events_expired` with the oldest event still kept, so an agent knows to catch up from the log instead of missing events silently.
+- **Wait for your next event.** `seam events --wait 30` (`?wait=` over HTTP, `wait` in `seam_events`) holds the call open until something happens to your work, up to 30 seconds, so an agent hears events at once without a webhook or a busy loop.
+- **Hear when a timed claim runs out.** A claim made with `expires_in` is now released when its time is up, and its holder gets a `claim.expired` event saying so.
+- **A refused commit reaches you as an event too.** When a commit touches a file someone else's square claims, you also get `claim.refused` with who holds it, their note and your place in its queue, so a webhook or another tool hears it.
+- **Check results reach you as events.** When a check (CI or a runner) reports green or red on your square, or on a line after your patch merged, you get a `check.verdict` event with the check's name, the commit and a link to its log, in `seam events`, `seam_events` and webhooks.
+- **Hear when your git export stops.** When the export to GitHub or another git host starts failing, is refused (someone pushed there) or recovers, the quilt's owner and admins get an `export.state` event with the remote's message.
+- **Handed-over files reach you as events.** When someone hands you a file you waited for in its queue, you get `claim.granted` with their note, and both of you get `claim.handoff`.
+- **Reviews reach you as events.** A comment, an approval or a request for changes on your square sends you `review.comment` or `review.decision` (in `seam events`, `seam_events` and webhooks), with the text and the file and line it is on.
+- **Seam tells you why your merge is waiting.** When a merge of your square stops on a line's rules (an approval or a check it still needs), you get a `policy.needed` event listing each need, even when someone else or an agent asked for the merge.
+- **Delete your Seam account.** Account settings on seam.heyquilt.com (or `seam account delete --confirm <your email>`) deletes your account: your computers, agents and apps are signed out, and your patches and reviews keep your name. Give away or delete the quilts you own first.
+- **Sign out a lost computer from anywhere.** Account settings on seam.heyquilt.com lists every computer signed in with `seam login` and signs any of them out; `seam computers` and `seam computers signout <id or name>` do the same from a terminal.
+- **Imports from git can credit people by name.** `seam import git <repo> --authors authors.json` maps git author emails to members of the quilt, so their old commits show as theirs in log and blame; everyone else still comes in under their git name.
+- **`seam bisect` can look only at some paths.** `seam bisect main tag:v1 --run "npm test" -- src/auth` tests only the commits that changed `src/auth`, as `git bisect -- <paths>` does, so a long line with unrelated changes takes fewer steps. Also `paths` in `seam_bisect` and `POST /bisect` (seam 0.39.0).
+- **Find out where a change went.** `seam contains <rev>` lists the lines that have a commit (a square's commit counts through its patch) and every square that cherry-picked or reverted it, merged or not, so "is the fix in release/2.3?" has an answer. `seam merge-base --is-ancestor a b` says whether one revision is in another's history. `seam show` adds who merged the patch, its checks and where it was carried. Answers about commits that never change carry ETags and `Cache-Control: immutable`, and blame that takes long to work out answers `202` with a job to wait on instead of timing out. Also `seam_contains`, `seam_ancestor`, `GET /contains/<rev>` and `GET /ancestor` (seam 0.38.0).
+- **`seam diff` shows renames and can look through whitespace.** A file moved with at least half its lines kept shows once, as `old => new` (`R90` in `--name-status`), instead of a delete and an add (`--no-renames` to turn it off). `-w` looks through whitespace and `--ignore-space-at-eol` through trailing spaces, so a reformat drops out, and `-U <n>` sets the context. Large diffs come in pages; `seam diff` reads them all. Also in `seam_diff` and `GET /diff` (seam 0.37.0).
+- **`seam log` filters, counts and pages.** `-G <regex>` finds commits whose changed lines match, `--grep <text>` (`-E`, `-i`) searches messages, and `--author`, `--on-behalf-of`, `--task`, `--since` and `--until` say who, what for and when. `--group-by author` (or `on_behalf_of`, `task`, `tool`) counts commits and lines added and removed, like `git shortlog -s`. `--graph` names the square a merge brought in, `--include-hidden` shows the commits an amend replaced, and a long log gives a `--cursor` for its next page. Also in `seam_log` and `GET /log` (seam 0.36.0).
+- **`seam search` finds code properly.** Search with words, `"phrases"`, `/regex/`, `path:`, `lang:`, `symbol:` (definitions first, then calls), `class:`, `-term` and `OR`, at any revision or in a square, in one quilt or all of them (`--all`). Results are ranked: matching file names first, then definitions, then lines. The server keeps an index of each file version (which words it can contain, and its definitions), so a search never reads a file that can't match. Also `seam_search { query }` and `GET /v1/quilts/:q/search?q=` (seam 0.35.0).
+- **Seam blame is kept, and does more.** The server works out who wrote each line once per change and keeps it, so blame is a lookup the second time. `seam blame` takes `-L a,b` for a span, `--ignore-rev` to look through a reformat (or list them in `.seam-blame-ignore`), `-M` to keep the origin of moved code, and `--reverse <rev>` to see how long each line lived. `main~200` and merge bases read a few rows however long the line is, and `log --follow` keeps the renames it finds and marks them (seam 0.34.0).
+- **Seam warns when someone changed the code yours depends on.** Seam now indexes the functions, classes and other definitions in each file (JavaScript, TypeScript, Python, Go, Rust, SQL, Markdown). `seam square show`, `seam rebase` and `seam merge` warn, without refusing, when a patch merged since you started changed a function you also changed, or one you started calling. `patch.merged` reaches you when a patch changed something your files call, even with no file in common. Every commit has a change class (whitespace, comment-only, docs, test-only, dependency, CI config, schema or logic), shown by `seam show`. `seam watch <glob> [--classes logic] [--min-lines 50]` tells you of matching patches (`watch.triggered`; also `seam_watch` and `/watches`) (seam 0.33.0).
+- **Seam finds the patch that broke a check, and reverts it.** When a check with runners goes red after a merge, Seam asks the runners for runs at up to 8 patches between its last green patch and the red one, narrows the range round by round, confirms the culprit (by another runner when there is one, and against the patch before it), and reverts it as the `system` member, handing the patch's holder a square to fix it in. A check that passes again at the tip is called flaky and nothing is reverted. At most 3 such reverts per check per line an hour; past that the holder and the admins get `check.culprit`. `seam check pipeline ci` shows a bisect's progress. Lines can batch post-merge checks: `seam line require main --batch 10/120` (seam 0.32.0).
+- **Seam remembers how each part of a conflict was settled, and forgets what nobody uses.** Besides the whole file's answer, Seam now keeps each clashing region's answer for the squares involved. The same clash in those squares, or a square stacked on one, is settled the same way even when the rest of the file changed. An answer nobody reused for 90 days is dropped. `seam resolutions --hunks` lists the regions, and forgetting a file's answer forgets its regions too (seam 0.31.0).
+- **Seam conflicts don't pile up when you rebase.** Rebasing a square that still holds a conflict now gives one clean conflict against the new tip, with your side intact. Before, the old conflict was wrapped in a new one and your side's text was lost from it. If `main` made the same change as yours in the meantime, the conflict settles by itself. A square stacked on a conflicted square can hold a three-sided conflict; pick a side with `seam resolve --side n`.
+- **Seam says who should settle a conflict, and stops an AI that keeps failing.** Each `conflict.added` event now names its `resolver` (whoever claimed the file in the square, else the square's holder), the `attempt`, how many attempts an AI has left, the conflict markers and the base and both sides. An AI gets two attempts at a file. The third time, the event says `escalated` and goes to the person the AI works for (or the quilt's owner), and the AI is told to stop.
+- **Seam's merge window recovers by itself and never blocks a fix.** An unfrozen line starts at half its merge window. An hour with no merges gives a line back its whole window. The automatic revert of a red patch, and the fix square it opens for the patch's holder, merge even when the window is full. Two check results arriving at once both count now; before, one could overwrite the other.
+- **Choose how far Seam combines clashing changes on a line.** `seam line require main --auto-combine lines|additive|whitespace` (also `auto_combine` in `seam_line_require` and `PUT /lines/:l/policy`) sets the highest merge step that applies by itself. `lines` turns off combining two inserts at one place, which then becomes an `order` conflict; `additive` also turns off whitespace settling; `whitespace` is the default, as before. `seam resolve <path> --rule additive|whitespace|words|union` (`rule` in `seam_resolve`) settles one conflict with a step the line doesn't apply by itself (seam 0.30.0).
+- **Seam reads `.gitattributes` when it merges.** `merge=union` files (a changelog, a list) keep both sides of a clash, yours first, instead of stopping. `binary`, `-merge` and `merge=binary` files are never merged by content: when both sides changed one, you pick a side. Every `.gitattributes` from the top folder down applies, as in git.
+- **Seam merges follow renames.** If your square renamed a file and someone changed the old path on `main` (or the other way round), the merge puts their change into the renamed file instead of stopping with a delete-against-edit conflict, and keeps the rename. Renames are found from `copy_from`, or from a deleted file with the same or mostly the same content. Two different renames of one file are a `name` conflict: `seam resolve <path> --ours|--theirs` keeps one side's path, `--keep-both` keeps both (seam 0.29.0).
+- **A Seam merge takes your live work with it.** `seam merge` (and `seam_merge`, `POST /lines/:l/merge`) now commits what you shared with `seam live share` first, as you, so the patch holds what everyone could see. If someone else is still saving into the square, it waits for them to pause (up to a minute) and otherwise says `writers_active`; `--no-commit-live` (`commit_live: false`) merges only what was committed (seam 0.28.0).
+- **New repo on seam.heyquilt.com.** Your repos has a New repo button: name it (its address comes from the name, or pick one), choose you or an org you run, and Create repo opens it. An empty repo's page now shows three steps to put your first work in (open a square into a folder, commit, merge) instead of an empty file list, and its banner's command opens that first square.
+- **Orgs and team settings on seam.heyquilt.com.** Seam now has orgs: Your orgs (in the account menu and on Your repos) lists them, New org makes one with you as its owner, and an org's page shows its repos and its members, where its admins add people by email and change or remove their roles. New repo asks who owns it (you or an org you run) and who can read it (private, or public to anyone). A repo's Settings add who can read it, its members (add a person by email with a read, write or admin level, change or remove them) and its owner (move a repo of yours into an org). `seam org add` and `seam quilts add` take an email as well as a member id, and `POST /v1/orgs/<org>/members` adds by email (seam 0.53.1).
+- **A repo's big banner is for empty repos only.** Every page of a repo with patches, its home included, now has a one-line head (name, patches on main, the checkout command), so what you came for starts near the top. An empty repo's home keeps the banner, with its own Patchwork beside it.
+- **Patchwork on a repo's home.** The live quilt from Your repos now has a card of its own on each repo's home, "Happening now", with only that repo's patches landing, squares opening and conflicts.
+- **Seam's Patches is a table, twenty a page.** Each patch is one row (number, title, author, square, files, when it merged, commit), with page numbers and Newer and Older under it. Each page is read in one call instead of walking the history, so it comes in about a second.
+- **Seam keeps its frame as you move around.** The bar with your account, a repo's banner and its tabs now stay on screen when you switch between Code, Patches, Squares, Activity and Settings (or go to your agents or settings): they're no longer fetched and drawn again on every click, only the page under them is.
+- **Import from GitHub into Seam.** Connect GitHub on seam.heyquilt.com/github: install the Seam app on your GitHub account or organisation, pick repositories, and import them with one click. Seam keeps each one up to date as you push to GitHub, with no token to make or paste. From a terminal: `seam github` and `seam github import owner/name --installation <id>`; agents have `seam_github` and `seam_github_import`. (Switched on once the Seam app is created on GitHub.)
+- **Seam has its own account pages.** seam.heyquilt.com now has Create account, Forgot password and Account settings (your name, change password, sign out of every browser, your agents); nothing in the account menu or on the sign-in page sends you to heyquilt.com any more. Your agents, approving `seam login` on a computer and allowing an app to use Seam work again: those pages had been sent to a repo's address instead.
+- **Seam's pages show up at once.** Every page of seam.heyquilt.com now shows its outline straight away while the rest fills in, instead of a blank wait: a repo's files and README come first and its numbers, charts and people stream in after. Squares and Activity come thirty or forty at a time with Older and Newest links instead of everything at once, a thin bar at the top answers every click, and the site no longer loads pages in the background for every link on a long list. Your repos went from about 7 seconds to about 1, a repo's Patches from about 10 to 3.
+- **Seam's Your repos page shows what's happening, live.** A small quilt in the header holds the last sixteen things that happened across your repos, one patch each: green when a patch landed, amber when a square was opened, red for a conflict. Each new one is sewn in as it happens, with a line under it saying which repo, who and what. Hover a patch to see whose it was.
+- **Create your account with GitHub.** Where Sign in offers Continue with GitHub (or Google), Create your account does too.
+- **Seam protections by path**: an admin can say who may list, read, write, merge or administer each part of a quilt, as one ordered table where the last matching row decides (`seam protect add src/ team:web write`, `seam protect add secrets/ everyone list --exclude`, `seam team set web …`). Paths you may not read leave your trees, diffs and block folders, a blob id cannot be reused to read a file you may not, and a write you may not make is refused with its path. A quilt keeps today's rules until its admin writes a table, and a Seam server takes tables only with `SEAM_PROTECTIONS=1` (seam 0.41.0; also `seam_protections`, `seam_protections_set` and `seam_team_set`).
+- **Paths kept for people**: `seam line require main --human-only "db/migrations/**"` lets agents read those files and never change them on that line, whatever else they may do; an agent's commit or merge there is refused with the path, and its block folder holds them read-only (also `human_only` on `seam_line_require`). Needs `SEAM_PROTECTIONS=1` on the server.
+- **Seam signs its log**: with `SEAM_ATTESTATION=1` a Seam server signs every row of every quilt's history as it is written and publishes its key at `/.well-known/seam-keys.json`; `seam verify` checks a quilt on your own computer and names any row that was changed, removed or never signed (also `seam_verify`, `GET /v1/quilts/:q/verify`).
+- **Redact a secret from a Seam quilt**: `seam redact <path or blob> --reason "…" --yes` removes those bytes from every pack, so every read shows a tombstone instead, and refuses them if anyone adds them again, without changing history or any id (also `seam_redact`, `POST /v1/quilts/:q/redact`). Only a person with admin can do it, and it cannot be undone.
+- **Sealed quilts**: `seam quilts new <slug> --sealed` makes a quilt whose files are encrypted on your computer before Seam ever sees them; its key stays with its members (`seam seal key`, `seam seal grant <member>`, `seam seal rotate --without <member>`). Block folders seal and open files by themselves; the server still keeps paths, sizes and history, and never merges file contents, so a file two people changed comes home as a conflict to settle. Needs `SEAM_SEALED=1` on the server.
+- **Seam catches secrets before they are committed**: a commit that adds an AWS, GitHub, Slack, OpenAI or Supabase service key, a private key, or a long random value assigned to a name like `secret` or `token` is refused with the file, line and a finding id, never the key itself; if you checked it is not a secret, `seam commit --allow <id>`. `.env` files are never committed, and a Seam key found in a file is revoked on the spot. Turn it on per quilt with `seam quilts secret-scanning refuse|warn|off`, or for a whole server with `SEAM_SECRET_SCANNING=1`.
+- **Public Seam quilts**: `seam quilts public on` lets anyone read a quilt, signed in or not, by its id, while writing still needs a member; protections can keep paths out of public view. Needs `SEAM_PUBLIC_QUILTS=1` on the server.
+- **Rules by kind of change**: Seam now tells a comment fix from a code change, a docs edit from a migration, and spots a deleted or skipped test, so a line's rules can let a comment-only fix merge alone while a schema change waits for its owner and a skipped test for a person (`seam line require main --rules rules.json`). `seam policy` shows a square's classes and what it still needs; a refused merge lists every need at once. Rules need `SEAM_PROTECTIONS=1` on the server.
+- **A line's policy keeps its history, and can wait for a second admin**: every change to what a line needs is a version you can read back (`seam policy versions main`). With `SEAM_POLICY_APPROVAL=1`, a change goes live only when another person with admin approves it (`seam policy approve main 3`), or, if you are the quilt's only admin, when you confirm it with your signing key (`seam policy confirm main 3`).
+- **Seam orgs**: a quilt can belong to an org instead of the person who made it (`seam org new acme`, `seam quilts new web --org acme`, `seam quilts move --quilt old --org acme`); the org's members reach its quilts by their role, owner and admin administer them, member writes. With `SEAM_ORG_OWNERSHIP=1`, agents no longer make quilts on their own: a person makes the quilt and adds them.
+- **Agent tokens for Seam**: `seam token agent new --agent agent:<id> --paths src --hours 8` gives an agent a key for one quilt that reaches only its own squares and the paths you name, at a level you choose, for a few hours, and never more than you can do; revoke it any time. With `SEAM_AGENT_TOKENS=1`, an agent's own key reads but writes only through such a token.
+- **Only people make Seam lines and tags, where protections are on**: an agent or CI token asking for a line, tag or release is told to open a square instead, unless the quilt's admin allows it (`seam quilts agents-make-lines on`).
+- **Seam shows a quilt's health numbers**: `seam metrics` (the `seam_metrics` tool, `GET /v1/quilts/<q>/metrics`) shows a quilt's admin how far its log archive lags, its open scrub findings, packs overdue for purging and the derive queue, and which of them are past the thresholds the monitors alert on.
+- **Seam runs this repo's CI and deploys**: GitHub Actions no longer run on every push to main. The repo lives on Seam, and after each patch merged into its `main` the runner runs the tests and the deploys whose files changed (`docs/seam-ci.md`). A Seam line can now name the paths each check is about (`seam line require main --only "deploy=src/**+!src/vault/**"`), and `seam runner --config` runs a command per check, woken by Seam's webhook and stopped when idle so it costs nothing in between. This repo now lives in the Seam quilt `heyquilt`; work merged into its `main` runs them.
+- **Seam reads empty files from hosted quilts**: checking out or reading a file with nothing in it failed with an internal error on the hosted server, so any repo with an empty file (an `__init__.py`, say) could not be checked out there.
+- **A Seam check that never passed opens no bisect**: a red check on a line where it never went green no longer searches the whole history for a culprit (after an import, that was every imported patch); it bisects from the start only when the check was set up before the line's first patch.
+- **Seam sees an edit made the moment after a checkout**: a file changed in the same instant Seam wrote it, to the same size, could look unchanged to `seam status` and `seam commit` on filesystems with coarse file times; such a file is now read again.
+- **`seam runner` rides out a Seam restart**: when Seam answers 5xx or drops the connection for a moment (a deploy of Seam itself, say), the runner waits and tries again instead of marking the check red.
+- **Stop a Seam bisect**: an admin ends an open bisect with `seam check pipeline ci --stop` (`seam_pipeline` with `stop`); its waiting runs are cancelled and nothing is reverted.
+
 ## 0.3.122 — 2026-10-26
 
+- **Seam tells you when it moves your stacked square**: when a square's parent merges (or moves, with restack on), its holder gets a `square.restacked` event with the old and new head and how many conflicts it now holds, by `seam events`, `seam_events` or a webhook. Needs `seam` 0.48.0 to ask for it by name.
+- **Seam can check the tree that merges**: `seam line require main --pre-merge-checks on` (or `pre_merge_checks: true` in `seam_line_require` and the line policy) makes a line take a merge only when its required checks are green on what actually merges. A square the line moved past on its own paths is refused with `checks_stale` until it rebases and its checks run again. Off unless turned on. Needs `seam` 0.47.0 for the flag.
+- **Take one Seam commit as a tarball**: `seam export tarball [rev] [--paths a,b] [--out file]` (or `seam_export_tarball`, or `GET /v1/quilts/:q/tarball/:rev`) writes the files of a commit as a `.tar.gz`, as `git archive` does; the same commit always gives the same bytes.
+- **Seam CI tokens expire**: a new quilt token (`sqt_`) lasts 90 days, or 1 to 365 with `seam token new <name> --days <n>` (`expires_in_days` over HTTP); after that it no longer signs in. `seam token` shows when each expires. Tokens made before keep working. Needs `seam` 0.45.0 for `--days`.
+- **Seam fences lockfiles and migrations**: a Seam server run with `SEAM_OWNER_PATHS=default` gives the first square that changes a lockfile or a migration the whole pattern (`(owner)` in `seam claim`), so another square's change there waits in line instead of colliding; it lets go 2 quiet hours after the last write. Off unless set. Needs `seam` 0.44.0 to show `(owner)`.
+- **Seam numbers claim changes**: the claims list over HTTP now carries `claims_version`, which goes up by one for every claim change in a quilt, so a program keeping a copy of the claims can tell when it missed one.
+- **Say you are done with Seam files sooner**: `seam claim finish` (or `seam_claim_finish`) lets go of the files Seam claimed for your square as you wrote them, at once instead of after 10 quiet minutes; a file someone waits for goes to the first in line, with your note. Claims you made on purpose stay. Needs `seam` 0.43.0.
+- **Wait in line for a claimed Seam file**: `seam claim request <claim> --title …` (or `seam_claim_request`) queues your square for a file another square claims; the holder hands it over with `seam claim handoff` and a note (or `seam_claim_handoff`), and cannot just let go while someone waits. `seam claim withdraw` stops waiting. Needs `seam` 0.42.0.
+- **Seam claims the files you are editing**: a Seam server run with `SEAM_AUTO_CLAIMS=1` claims each file a square writes that nobody holds, so another square's write to it is refused while you work; the claim lets go 10 minutes after your last write to it. Claims list it as `(auto)`. Off unless set. Needs `seam` 0.41.0 to show `(auto)`.
+- **Seam lets go of claims on quiet squares**: a Seam server run with `SEAM_CLAIM_IDLE_MINUTES` (5 to 1440) releases a square's claims once nothing has happened in the square for that long, so a forgotten claim stops blocking others. Off unless set.
+- **Seam claims can expire**: `seam claim <pattern> --expires <seconds>` (or `seam_claim` with `expires_in`) makes a claim that lets go by itself after that time, from a minute to a week. Claims made without it hold until the square ends, as before. Needs `seam` 0.40.0.
+- **Seam signs its own reverts**: a patch reverted because a check went red now shows Seam as its author instead of whoever reported the check. A revert that cannot merge is still handed to the reporter to finish.
+- **Pinned quilts export as submodules**: a pointer to a quilt imported from git now exports as a git submodule entry at the pinned commit's sha, so the exported repository pins the same commit git had.
+- **Seam folders show pointers to other quilts**: a pinned quilt shows in a Seam folder as a folder holding `.quilt-pointer`; edit it to pin another patch and commit as usual. Needs `seam` 0.39.0.
+- **Seam checks pointers to other quilts**: a commit that pins another quilt at a patch (`mode: 'quilt'`) is refused unless you can see that quilt and the patch really is that commit.
+- **Archive a quiet Seam square**: `seam square archive` (or `seam_archive`) puts a square to sleep: its claims are released, `seam squares` leaves it out (`--archived` lists them) and it stops counting toward a squares limit. Its work is kept, and the next commit to it wakes it. A Seam server run with `SEAM_SQUARES_TTL_DAYS` archives squares left idle that long, and every square shows when it would be archived.
+- **Seam folders leave out secrets and personal files**: a Seam folder no longer picks up new `.env` files, build folders or editor swap files, and `seam clean` leaves them alone. A `.seamignore` file works like `.gitignore` for files only you want left out, and is never committed. Files already committed keep working. Needs `seam` 0.37.0.
+- **Seam refuses to commit secrets and junk**: a Seam server run with `SEAM_IGNORED_PATH=1` refuses any commit that adds `.env` files, `node_modules`, build folders or editor swap files, or a new file a `.gitignore` names, whichever tool or agent sent it. Deleting such a file still works. Without the setting nothing changes.
+- **Split a Seam square by who claimed what**: `seam square split --by claim` (or `seam_split` with `by: 'claim'`) moves each claimed part of a square into its own square, held by whoever claimed it, and `--stacked` chains the new squares one on another instead of side by side. Needs `seam` 0.36.0.
+- **Stacked Seam squares follow their parent**: on a Seam server run with `SEAM_RESTACK=1`, a commit or amend on a square moves the squares stacked on it onto its new work by themselves (conflicts kept as markers), and the answer lists them. When a parent merges, the squares on it now leave the stack for good. Without the setting, commits work as before.
+- **Move a stacked Seam square**: `seam square reparent --onto <square>` (or `seam_reparent`) moves a square onto another open square on its line, and `--line` takes it off its stack onto the line's tip; its work is rebased there, conflicts kept as markers. Needs `seam` 0.35.0.
+- **Seam says when someone claimed files you changed**: a Seam square's status (`seam square show`, `seam_square_status`) now lists other squares' claims on its line that cover a file it changed or a pattern it claims, with who holds each and for which task, so an agent hears about it before it merges. Needs `seam` 0.34.0 to show it as text.
+- **Hide a Seam square**: `seam square hide` (or the `seam_hide` tool) leaves a scratch square out of the squares list without closing it; its work and claims stay, and `seam squares --hidden` still shows it. `seam square unhide` puts it back. Needs `seam` 0.29.0.
+- **Pair on a Seam square**: `seam square share --with <member>` (or `seam_share`) lets up to three more people commit to a square you hold; `seam square unshare` takes one off. Agents with their own accounts still get their own squares. Needs `seam` 0.30.0.
+- **Rename a Seam square**: `seam square edit --title`, `--task` and `--line` (or `seam_square_edit`) change a square's title and task, and move it to another line before its first commit. Needs `seam` 0.31.0.
+- **Seam tells you who holds a task**: opening a square for a task someone else already holds no longer hands you their square; Seam says whose it is, and `--another` (or `another: true`) opens a second square on the task. Needs `seam` 0.32.0 for `--another`.
+- **Abandoning a Seam square keeps stacked work safe**: a square with other squares stacked on it can no longer be abandoned out from under them, which let its abandoned commits reach main through them. Seam names each one and its holder; `seam square abandon --cascade` abandons your own stacked squares with it. Needs `seam` 0.33.0 for `--cascade`.
+- **Seam stores large files in pieces**: a Seam server run with `SEAM_CHUNKING=1` stores each file over 1 MiB as small pieces cut by content, so a file is no longer limited to 64 MiB and editing a big file stores only the pieces that changed. Files read back exactly as before, and files stored earlier are untouched. Without the setting nothing changes.
+- **Seam rides out a damaged file download**: when file storage hands back bytes so damaged they no longer unpack, Seam now reads them once more, as it already did for other damage, instead of failing the request.
+- **Seam keeps commits going under strain**: a Seam server run with `SEAM_SHEDDING=1` that sees its database or file storage failing puts off the least urgent requests first (history searches, then diffs, then file fetches) and agents' before people's, answering them with when to try again, so a person's commit and merge still go through. Without the setting nothing changes.
+- **Seam can cap file downloads per token**: a Seam server run with `SEAM_FETCH_RATE=1` lets each token ask for files at most 50 times a second (a person's 250), answering the rest with when to try again; `seam` 0.28.1 waits and asks again instead of failing. Without the setting nothing changes.
+- **Seam stops sign-in guessing**: credentials that fail to sign in to Seam 10 times in a minute are refused for a minute after the last failure (`auth_lockout`, with when to try again), even if the next try is right.
+- **Seam can cap open squares**: a Seam server run with `SEAM_SQUARES_LIMIT=50` lets each person or agent hold at most 50 open squares in a quilt; one more is refused with the name of their idlest square to merge or abandon. Without the setting nothing changes.
+- **Seam caps uploads**: one member can upload at most 100 GiB an hour into a quilt (a person 500 GiB) and a quilt takes at most 1 TiB a day; past that Seam says when to try again (`upload_rate`).
+- **Seam caps commits per quilt**: a quilt takes at most 6,000 commits an hour and 200 changes a second from all its people and agents together; past that a commit gets the usual "too many requests" answer (`quilt_busy`) saying when to try again, so one runaway quilt cannot crowd out the rest.
+- **Seam's limits hold across machines**: a Seam server run with `SEAM_SHARED_LIMITS=1` counts each token's requests, commits and merges in its database, so a token has one allowance however many Seam machines answer it (before, each machine counted its own). Without the setting nothing changes.
+- **Seam says when to come back**: every "too many requests" (429) and "unavailable" (503) answer from Seam now has a standard `Retry-After` header as well as `retry_after` in the body, so any HTTP client or agent tool can wait the right time without reading Seam's JSON.
+- **Seam refuses cut-off records cleanly**: a commit or conflict record that arrives cut short now gets a plain "truncated" refusal instead of an internal error. Found by new automatic tests that throw thousands of random edits at Seam's merge and its record format on every change.
+- **Seam clears out files nothing uses**: a Seam server run with `SEAM_GC=on` (with the daily check on) removes, after a check that found nothing wrong, the records of uploaded files that no change and no shared work in progress uses and nobody has asked about for a day. The bytes stay for 30 days, so nothing is lost to a mistake. `SEAM_GC=dry-run` only logs what it would remove. Uploads left with nothing in them are cleared the same way, and their storage is freed 30 days later.
+- **Seam checks its own records for damage**: a Seam server run with `SEAM_SCRUB=1` (and derive workers on) checks each quilt it writes to once a day for gaps in its history, missing changes on a line, a line pointing at an unresolved conflict and rewrites that lost their original, records each problem it finds and raises an alert in its log. It never changes anything it finds.
+- **Seam's background work can run from a queue**: a Seam server run with `SEAM_DERIVE_WORKERS=<n>` puts the work each change triggers afterwards (filing a commit's order on its files, sending events) in a shared queue that n workers per machine take from, so a burst of changes does that work once and any number of machines can share it. A job that fails is retried a minute later. Without the setting nothing changes.
+- **Seam keeps a second copy of every merge**: a Seam server run with `SEAM_TIP_JOURNAL=1` answers a merge, a new or frozen line, or a square's change only after the change is also written to object storage (writes within 200 ms share one write), so a lost database can be rebuilt up to the last merge, not only up to the last archived segment. If that copy cannot be written the answer is `503 journal_unavailable` and the change is still saved. Copies already in an archived segment are deleted a day later.
 - **Seam follows a live git repository**: `seam import git https://… --into <slug> --follow` imports a git remote on the server and keeps taking its new commits on `main` and `release/*` every 10 minutes, or at once when a git hook or cron job pokes it (`POST /v1/imports/:id/poke` with the import's secret; `seam import poke`). Those lines stay frozen while git leads, so nothing merges in Seam until cut-over; a rewritten branch stops the follow. `seam import status` shows where it is. Also as the `seam_import_remote`, `seam_import_status` and `seam_import_poke` tools.
 - **Seam exports to any git remote**: `seam export remote <url> --quilt <q> [--line main,release/*] [--releases] [--credential <name>]` pushes each merge on those lines to GitHub, GitLab or any git remote as it lands, fast-forward only, with release tags when asked. A remote someone else pushed to is refused, never forced, and `seam export status` says which line and commit; failures to reach the remote retry by themselves. Also as `seam_export_remote` and `seam_export_status`, and `PUT`/`GET /v1/quilts/:q/export`.
 - **Seam cut-over**: `seam import cutover <id>` ends a followed import for good: one last pass, a check that the git remote has nothing the import lacks, then the lines take merges in Seam and `main` exports back to the same remote after each merge, continuing git's history. It refuses and changes nothing if git moved. The day's steps are in `docs/seam-cutover.md`.
 - **Squares close themselves while git leads**: during a followed import, a square whose diff someone applied in git and pushed is closed as merged by the next follow pass (`merged.how = matched`), with the git commit it became. A square whose diff was edited on the way is closed by an admin with `seam square merged <square> --as <sha>` (also `seam_square_merged` and `POST /v1/quilts/:q/squares/:s/merged`).
+- **Seam knows which blocks are open**: `seam block open <square> [--paths a,b] [--mode sparse|virtual|api-only] [--read-only] [--at <rev>]`, `seam block touch`, `seam block close` and `seam block` (also the `seam_block*` tools and `/v1/quilts/:q/blocks`) keep a row per block on the server: who has which square open, on which machine, which folders, and the commit it is at. A live block follows the square's head; a read-only one stays where it was opened. Up to 20 per member on a quilt; a block untouched for seven days is closed.
+- **Seam's tools over HTTP**: Seam's server answers MCP at `/mcp` (Streamable HTTP) with the same `seam_*` tools as `seam mcp`, as whoever the request's key or token belongs to, so a hosted agent or chat app with nothing installed can use Seam from any AI tool.
+- **Seam says when a file went**: `seam log -- <path>` on a line also says whether the path was ever there and, if it has been deleted, the last patch it was in (`existed` and `last_present` in the answer and in `seam_log`).
+- **Seam's docs say what the server does**: the overview says a quilt starts with `main` and can have release lines, and the API docs name `.seam/` (not `.quilt/`) as the folder commits refuse.
 - **Busy lines no longer drop merges**: a merge waiting behind many others on the same line for more than 10 seconds was ended as if its server had died; it now keeps itself alive while it waits.
 - **A Settings tab for each repo on seam.heyquilt.com**: admins set the export to a git remote there (address, lines, releases, the credential's name) or turn it off; everyone who can read the repo sees whether it is up to date, what was pushed last and the last error.
 - **Seam asks your test runners to run checks.** A line's policy can name who runs each check (`seam line require main --checks ci --runners ci=agent:ci`). Seam then sends them `check.requested` when a square gets a new commit, when it asks to merge, and after each merge on the line; runners can also list what's waiting with `seam checks --state queued`. Only a named runner's result counts; anyone else's is kept as advisory.
@@ -69,7 +342,6 @@ Seam gets nearly everything its docs said was missing.
 
 ## 0.3.117 — 2026-10-25
 
-- **Your AI is no longer held back when it finishes.** The AI sessions on your computer (Claude Code, Cursor, Gemini CLI) no longer get Quilt's hook as they finish a turn, which could send them back to work with messages that were for you. Quilt takes out the one it wrote earlier the next time a session starts. Files they edited are let go when their session ends, or after 20 quiet minutes. Agents that joined as their own members, your cloud AI among them, keep it: they still answer what is written to them before they stop.
 
 ## 0.3.116 — 2026-10-25
 
@@ -91,10 +363,6 @@ Seam gets nearly everything its docs said was missing.
 
 ## 0.3.114 — 2026-10-25
 
-- **Quilt Source has its own site.** frame.heyquilt.com now opens on a page that says what Quilt's source control is (quilts, squares, patches and blocks, how a square gets to main, what happens to a conflict, how agents use it), with docs: getting started, git commands side by side, squares and merging, agents, and the HTTP API. Your repos are under Your repos, and old repo links still work.
-- **A repo's home page.** A repo opens on its numbers (patches on main, patches this week, open squares, conflicts, how long squares take to merge, each with its trend), its files with the last patch that changed each one, patches a day for the last month, its README, what it's written in, its open squares, and who works on it.
-- **A fresh import takes merges at once.** Right after `quilt import git`, merging into main was refused for an hour because the imported history counted against main's hourly merge limit. Imported patches no longer count.
-- **Your cloud AI runs the newest Quilt on its machine.** When your cloud AI updated Quilt on its machine (by running the install script), its AI tool's Quilt tools and hooks kept running the version the machine was made with, and the AI could not fix that by itself. Now the machine's `quilt` command, and the Quilt tools and hooks of every AI tool on it, run whichever installed Quilt is newest, and a machine with a newer one installed starts on it the next time it goes idle.
 
 ## 0.3.113 — 2026-10-24
 
@@ -314,34 +582,22 @@ Everything from 0.3.88 to 0.3.91, which did not publish: git for everyone, boxes
 
 ## 0.3.91 — 2026-10-18
 
-- **A new session follows its workspace's git rule at once.** A session made in a workspace, or moved into or out of one, picks up the workspace's, team's or org's git rule right away instead of up to ten minutes later. Deleting a workspace lifts its rule from its sessions at once too.
 
 ## 0.3.90 — 2026-10-18
 
 Your AI on a cloud machine, boxes you can see, and one control for git.
 
-- **Your AI on a cloud machine.** Settings → Your AI: connect Claude Code, Codex or Cursor and it runs on a cloud machine of your own, so it keeps taking tasks, answering @mentions and messages while your computer is closed. Sign the tool in right in the card with its own login: Quilt never sees it. See its status, its sessions and today's use against its daily cap; change its model, instructions and cap; wake it or disconnect it. Included in every plan for now.
-- **See who has unfinished work.** In the people panel, each person's boxed files are listed under them with what changed, opened in place. Ask for someone's boxed file there, or unpack your own to put it in everyone's folder. Boxed files have an amber mark in the file tree.
-- **One control for git, everywhere.** Off for everyone, on with agents pushing their own branches, or on with agents pushing any branch: the same three-way control in session, workspace, org and default settings, and for teams and orgs on heyquilt.com. Choices a higher rule doesn't allow are greyed, with who set the rule.
 - **Fixed: a new session in a workspace got the workspace's git rule only after up to ten minutes.** It applies at once now.
 
 ## 0.3.89 — 2026-10-17
 
 Unfinished work stays in boxes, and the relay spreads over many machines.
 
-- **Your AI's unfinished work stays in a box.** When an AI edits a file in a git folder, the change is boxed: everyone sees it, but it is only in its owner's folder, so nobody else's AI can commit it. It reaches everyone when its owner commits it, puts the file back, unpacks it (`quilt_unpack`) or hands the file off. `quilt_status` lists boxed work, and a box whose owner has been away a day gets one reminder a day.
-- **Hosted agents' writes box too**, until they commit with `quilt_git_commit`.
-- **The relay runs on many machines.** Each session lives on one machine, and new sessions go to the least busy. A heavy session (big or busy) gets a machine of its own and moves there; people reconnect by themselves in a few seconds.
-- **Fixed: hosted agents' and branch leases' files could be removed** by the relay's sweep of idle sessions.
 
 ## 0.3.88 — 2026-10-17
 
 Git for everyone in a session.
 
-- **Everyone pushes once one person connects GitHub.** When the session owner (or a workspace, team or org rule) has git on and someone has connected GitHub, everyone in the session, people and agents alike, can `git push` with nothing to set up. Each person gets a one-hour token for that repository only, taken back when they leave or git is turned off. Your own git settings and keychain are never touched.
-- **Off means off for everyone.** Turning git off now stops people's pushes too, not just agents'. Commits from the app's commit panel still go.
-- **Team git rules.** A team can set git for the sessions its members own. Org, team and workspace rules are ceilings: a session owner can tighten them, never loosen them, and is told who set the rule.
-- **No more `gh auth login`.** Quilt no longer tells you to sign in to GitHub in another tool; it says whose connection git goes through.
 
 ## 0.3.87 — 2026-10-17