heyquilt 0.0.1 → 0.3.90

package/RELEASES.md

@@ -0,0 +1,733 @@
+# Quilt releases
+
+Every version has a section here, newest first. The app shows the newest section as
+"What's new" the first time it runs after an update, and `npm run release` publishes
+the matching section as the GitHub release notes. A test fails if the top section's
+version does not match package.json, so bump both together. Which number to bump is in
+[docs/VERSIONING.md](docs/VERSIONING.md): the patch for every release, the minor only when a
+milestone there is reached.
+
+Format: `## <version> — <YYYY-MM-DD>`, an optional one-line summary, then bullets.
+Lead each bullet with a short bold phrase. Inline `code` and **bold** are rendered;
+nothing else is.
+
+## 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
+
+A new look for Quilt: the Patch Q mark, and the app and heyquilt.com in ink, vermilion and linen.
+
+- **A new mark.** Quilt's logo is now Patch Q: eight pieces around an open centre, one per person, with the corner piece cut corner to corner and its vermilion half making the Q's tail. Next to it, "quilt" is drawn rather than typed, and its i is dotted with the same folded square. It's in the app's header and sidebar, the sign-in screen, the release notes, the app icon on macOS and Windows, the menu bar and tray, favicons and the macOS installer.
+- **Ink, vermilion and linen.** The app moves from pastel patches on warm white to ink text on linen, with a deep vermilion for links and buttons. Dark mode moves onto ink too.
+- **Quilt starts in dark mode.** Unless you pick Light or System in Settings → Appearance, the app is dark.
+- **A cleaner light mode.** Light mode drops the cream for neutral greys with a hint of ink. The top bar, Files, chat and the sidebar are white, and the work (the Loom, the board, a file, Home, Settings) sits on a cool grey, so its white cards and the Loom's lane heads stand out with firm lines and a soft shadow. The task board sits on white, with pale columns and borderless cards; column titles are quiet, with a coloured dot for the status; the open tab is underlined in vermilion; and type is a step lighter. Every card, Loom cards included, lifts the same way. Edits, locks and In progress are now blue, so vermilion only marks the open file, what needs you and what's live. Errors are crimson, so they no longer look like links. Small grey text, warnings and edits are easier to read, and every text colour now passes WCAG AA. Workspace covers lose their gloss, and the workspace swatches in the sidebar have an edge so you can see them. One person colour moved from rust to indigo, so nobody's lane looks like an alert. In dark mode, counts on vermilion badges are readable now.
+- **Code in the file view is no longer ruled into boxes.** Every line of a file or a merge was drawn as a little card, with a border and a shadow, because it shared a class name with the Loom's cards.
+- **Every wait shows the mark piecing itself together.** Loading files, people, invites, repositories, changes, agents and the rules check, signing in, and updating Quilt now show the mark being pieced together, patch by patch, instead of plain "Loading…" text. With reduced motion turned on, it fades gently instead.
+- **Tell your conversations apart in the Loom.** When someone has several AI conversations going at once, each gets its own piece of the Q, shown on its cards and in a single row in their lane's header. One working right now has its piece run a lap of the Q and come home. Names come from the AI tool itself (the thread names in Claude Code, the chat names in Cursor), and you can rename one with the pencil (on this computer). Click a conversation to follow just it: its name opens out, the Loom shows its latest card and everything else steps back. Click again or press Esc to see everything.
+- **A working AI pieces its lane's quilt.** In the Loom, the needle under a working AI's lane is now a patch being pieced on the lane's thread and sewn down into a Q, slot by slot in that person's colour, the vermilion corner last. Each piece hangs from the end of the thread before it drops in, so the thread no longer runs through the pieces, the quilt or its label. With reduced motion turned on, it shows the finished Q.
+- **Back to the latest in one click.** Scroll up the Loom to read back and a Latest button appears at the bottom; click it to glide back down to what's happening now. If anything new comes in while you're up there, it says New activity instead.
+- **Something live glows like the mark's corner.** The dot that pulses while an AI is working is now the mark's vermilion half-square, and the update bar's dot, the release notes' versions and their bullets use it too.
+- **Crisp at the smallest sizes.** The favicon, menu-bar icon and smallest app icons are drawn pixel by pixel at 16, 24 and 32 px, so they stay sharp instead of blurring. The full design spec is in `brand/SPEC.md`.
+- **heyquilt.com, re-branded to match.** The website moves to ink, vermilion and linen too, in light and dark. The patchwork behind its screenshots is now an ink quilt on the mark's own grid, finished with the vermilion corner, and the screenshots, blog pictures, favicons and link previews all show the new look. Buttons that are working and pages that are loading show the mark piecing itself together, and a missing page shows the mark with a piece gone.
+- **Claim pills line up with file names.** In the file list, the lock pill showing who claimed a file or folder sat a few pixels high. It now sits on the same middle line as the name.
+- **Opening a file no longer leaves it lit in the Loom.** Hovering a file in the file list lights the Loom cards that worked on it. If you clicked the file open, the Loom still lit those cards when you closed the file or went back to it, as if you were still hovering, and the file's change card could stay on screen. The Loom now forgets a hover once the pointer leaves the row, and a file you clicked shows its change card again only after the pointer leaves it and comes back. The same goes for a file chip clicked open in a Loom card.
+- **The agents docs name the branch tool by its new name.** heyquilt.com/docs/agents still said hosted agents switch branches with `quilt_switch_branch`, which was renamed `quilt_git_branch` in 0.3.47.
+- **The Loom shows how long someone has been stitching.** A lane's head shows how long that person, or their AI, has been on what they're doing now, next to their status, for example `working · 25m`. Hover it for what they're on and when they started. The clock starts with a new focus or task, keeps running between an AI's turns, and stops when they say they're done or move their task to Done. It's hidden while someone has paused sharing.
+- **The Files pane starts folded, into a rail of locks.** Instead of every file name, the folded pane shows what's locked: a lock with how many files are held, and one avatar per person or AI holding something, with their count. An hourglass pulses when someone is waiting for a file you hold, and the merge count pulses when a file to merge is one you have open. Hover or click any of them for the list: each file, who holds it and for how long, why (their note or what they said they're doing), who's waiting, and when it frees up if its holder stays idle. A locked folder is one row with its file count. A Loom lane's "holds" opens the same list. The full file tree is still one click away.
+- **A Loom lane shows the AI tool actually in use.** The tool mark next to a name in the Loom came from the tool that person's session was started with, so it could show Cursor for someone working in Claude Code. It now shows the tool their latest conversation came from, and falls back to the session's tool before any conversation shows up.
+- **A long name no longer opens a gap in a Loom lane's head.** With several conversations, a name too long for the lane pushed the pin and hide buttons, unseen until hover, onto an empty row of their own above the conversations. The name is now cut short with an ellipsis, and the head stays on one row.
+- **Folding the Files pane or the chat no longer stutters.** While the pane slid open or shut, the Loom drew itself again on every frame of the slide; now it draws once the width settles. Opening a folder in a big file tree is about twice as fast too, since rows out of view are no longer laid out.
+- **The Q in the title bar, taskbar and tray.** On Windows and Linux, the window's title bar and taskbar icon showed Electron's logo when Quilt ran from source; they show the Q now. The title bar and menu follow Quilt's theme (Settings → Appearance) instead of Windows', so the dark app no longer sits under a light bar, and the Q there is drawn for the bar it's on. The tray icon drops its dark tile, so the Q is bigger and sits with the taskbar's other icons: linen on a dark taskbar, ink on a light one (it follows Windows when you switch), and crisp at every display scale.
+- **Files you ignore leave the "not committed" count.** Adding files to `.gitignore` and pushing it with git left them counted as not committed until someone used Commit and push. The count now drops them as soon as the relay sees the push. A file GitHub already has stays counted, since git still commits it.
+- **Agents in sandboxes keep working between turns.** In bolt.new and similar sandboxes, set one secret, `QUILT_AGENT_KEY`, in the platform's settings, and run `npx heyquilt sync` at the start and end of each turn. Nothing to install, no background process, and files that were deleted never come back.
+- **Every quilt command works with just the key.** With `QUILT_AGENT_KEY` set and no `quilt join` running, `quilt status`, `messages`, `say`, `tasks`, `tool` and `mcp` work.
+- **Make and revoke sandbox keys.** `quilt agent join --print-env` and `quilt agent env` make a sandbox key. Revoking it on heyquilt.com stops it at once.
+- **A Python package.** `pip install heyquilt` gives Python agents messages, tasks and files with the same key.
+
+## 0.3.86 — 2026-10-16
+
+- **The GitHub label on a file goes after ten minutes.** A file that came in from GitHub showed the commit's author next to it until someone edited it, so hours later your own commit still looked like a fresh change. The label now shows for ten minutes after the commit comes in, or until someone edits the file.
+
+## 0.3.85 — 2026-10-16
+
+- **A commit made just as Quilt follows GitHub no longer deletes GitHub's new files.** When your folder caught up with a commit from GitHub, Quilt moved your branch first and updated git's index a moment later. A `git commit -a` that started in between could land on GitHub's commit with the old index, and push a commit that quietly deleted the files GitHub had just added. Quilt now updates the index first and moves the branch last. A commit made at that moment either sees GitHub's files or is refused by git, so you can try it again.
+- **The relay no longer takes an unpushed commit for GitHub's.** Right after you committed, your folder could tell the relay about its new commit alongside facts it had checked before that commit. The relay then recorded your local commit as the session's commit. That could leave GitHub's newer commits out of the session, or move the record back to an older commit. Your folder now only says what it checked for the commit it is on, and only calls a commit missing from GitHub once it has fetched since hearing of it.
+
+## 0.3.84 — 2026-10-16
+
+- **Agents that work in turns show as away, not offline.** An agent in a sandbox that is cleaned up after every run (keys saved with `quilt agent join --here`) is only connected during its turns. Between them it now shows as away, with an amber ring and when it was last here, under its own Away heading in People, in Session settings and in `quilt status`. A message to it says it will be read at the start of its next turn. After a week without a turn it shows as offline again.
+
+## 0.3.83 — 2026-10-16
+
+- **A new branch no longer shows someone's name on every file.** When an agent took a task, Quilt copied the project onto the task's branch and logged each file as created by that agent, so the file list showed their name and "1m ago" on hundreds of files they never touched. That starting copy is no longer logged as anyone's edit; only real changes carry a name.
+
+## 0.3.82 — 2026-10-15
+
+- **A folder joining afresh no longer brings back files the session deleted.** A folder that synced before and lost its sync state (an agent's sandbox wiped it, say) joins as if for the first time. Its old copies of files deleted from the session meanwhile went back into the session as that member's work. Now the session wins, as it already did for files it still has: the old copy moves to `.quilt/conflicts` and leaves the folder. Files the session never had still come in from the folder.
+
+## 0.3.81 — 2026-10-15
+
+- **Agents in sandboxes rejoin into their own project.** An agent whose machine is cleaned up after every run starts `quilt join --agent <name>` again each turn, and it now syncs the project it joined from. Before, the second turn took that project for a person's folder and synced a throwaway copy in the wiped home, so nothing the agent did reached the session.
+- **Edits made as a turn ends aren't lost.** A folder keeps its sync state as soon as its first sync is done, so a `quilt join` stopped any moment after still sends the edits made since at the next start.
+- **No more "keep quilt join running".** The invite text tells agents in such sandboxes to start it each turn and let it end with the turn, instead of keeping it running between turns.
+
+## 0.3.80 — 2026-10-15
+
+- **A commit made while Quilt brings in GitHub's changes no longer undoes them.** If you or your AI committed at the very moment your folder was following new commits from GitHub, the commit could leave out the files that just came in and remove them from GitHub. Quilt now holds git's index while it follows; a commit in that moment is refused by git ("index.lock exists") and goes through when tried again.
+
+## 0.3.79 — 2026-10-15
+
+- **Agents in sandboxes keep their place between turns.** An AI in a hosted sandbox that wipes its home folder between turns runs `quilt agent join <link> --name <name> --here`, and its keys stay in the project's `.quilt/` folder (Quilt never syncs it, git ignores it). On a later turn, `quilt join --agent <name>` in the project folder rejoins the session as the same agent, with no new invite. Agents on a normal computer still keep their keys in `~/.quilt`, as before.
+- **The CLI can live in the project too.** Invite instructions now tell such agents to install Quilt with `QUILT_HOME="$PWD/.quilt/cli"`, so the command survives between turns as well.
+
+## 0.3.78 — 2026-10-15
+
+- **Session settings, one section at a time.** The window is wider, with a list on its left: Your AI chat, Version control (syncing with GitHub, large files, what agents may commit, the GitHub token), Agents and People, each with its own page.
+
+## 0.3.77 — 2026-10-15
+
+- **A shorter source control panel.** Your branch is one line with a small Check button, GitHub is one line (with the commit box when there is work to commit, and Connect GitHub while nobody has), and each person's changes show their newest ten files, then how many more.
+- **GitHub settings moved to Session settings.** Sync with GitHub, letting the relay commit large files, and what agents may commit are now under GitHub in Session settings.
+
+## 0.3.76 — 2026-10-15
+
+- **One button for branch, GitHub and changes.** The top bar's branch label, Changes button and GitHub chip are now one chip: your branch, how many files changed, and a dot for where the session stands with GitHub (with a word when someone has to act, like Connect GitHub). It opens one panel with your branch and every other branch, committing and syncing with GitHub, and every change by person or by file.
+
+## 0.3.75 — 2026-10-15
+
+- **Set what agents may commit for a whole workspace or team.** A workspace's GitHub settings have "Agents may commit" (off, to branches of their own, or to any branch), and an org admin can set it for every workspace of the org. It goes before each session's own choice, and the session's setting says where its rule comes from.
+- **Adopting an agent's work no longer says "the relay did not answer".** Adopting, finishing a task and handing your local commits over can wait for GitHub's spacing between pushes; the app now waits for them instead of giving up after ten seconds while the push still went through.
+- **Connecting GitHub isn't undone by an older check.** A check of the session's GitHub connection that was slow to answer could land after a newer one and show the session as not connected.
+
+## 0.3.74 — 2026-10-15
+
+- **Quilt's own `.gitignore` line isn't claimed for you.** The `.quilt/` line Quilt adds could be claimed for you, as if your AI had edited the file, when it was at work.
+- **Someone's change isn't undone when you come back.** If your app stopped just before writing a partner's latest change to your disk and you then edited that file, coming back could undo their change. Your offline edits are now measured from what your disk really had, so both changes stay, and you settle them if they touch the same file.
+
+## 0.3.73 — 2026-10-15
+
+- **A reset keeps everyone's work.** `git reset --hard origin/main` over a commit you hadn't pushed took GitHub's version as if it were a pull, and could undo others' lines in the session. Now only what GitHub brought counts as pulled, and the session keeps your work and everyone else's.
+- **CI tasks follow the last result.** A pass reported right after a failure, or an old commit's failure reported late, no longer leaves a CI task open.
+
+## 0.3.72 — 2026-10-15
+
+- **The GitHub chip says it in words.** It shows GitHub's mark with **Committed**, **Uncommitted changes**, **Merge held**, **Through pull request #…**, **GitHub unreachable** or **Not syncing**. It never shows a file count that could pass for a commit count next to the branch's "behind".
+- **See what isn't committed, and commit it.** With uncommitted changes, the chip's panel shows the GitHub commit the session is at and the files changed since, newest first, with who changed each. From a folder with git, type a message and **Commit and push**.
+- **A pushed commit clears the chip.** Files someone committed and pushed with git kept counting as uncommitted on branches that sync with GitHub. The relay now drops them as soon as GitHub has them.
+
+## 0.3.71 — 2026-10-15
+
+- **Claims Quilt makes for you are always let go of.** A file it claimed while you edited could stay claimed for good if the connection dropped as it went quiet (the relay restarting, a network blip), and GitHub's changes to that file then waited on it. The claim is now let go of once you're back.
+
+## 0.3.70 — 2026-10-15
+
+- **Your AI sessions show as one in chat.** Older sessions named like "Daniel · Claude Code 5" could show one by one in the @ list and in chat, because the session owner's name was counted as two people. They now fold into "<you>'s AI" like your other sessions.
+
+## 0.3.69 — 2026-10-15
+
+- **Ask Quilt in chat.** The relay's name in chat is now **Quilt**: type `@Quilt` to ask it who is connected, which branches it keeps and how they stand against git. Its messages, tasks and comments show as Quilt, older ones included, and `@The Relay` still reaches it.
+- **GitHub's change waits only for the claim.** A file someone held when a GitHub commit came in gets that change as soon as they let go of it, even with an older app's folder on the branch.
+
+## 0.3.68 — 2026-10-15
+
+- **A pull never leaves a folder stuck.** After a `git pull` in a busy session, a folder could keep waiting for the relay over and over, holding back its edits. It now waits once, then shares the pull.
+- **GitHub commits Quilt just pushed stay put.** The relay no longer takes a folder's word over its own when that folder hasn't fetched the newest commit yet.
+
+## 0.3.67 — 2026-10-14
+
+- **A git pull keeps GitHub's changes.** On a branch that syncs with GitHub, a pull the relay hasn't brought in yet is combined line by line with the session's work, as the relay does, instead of waiting for someone to settle it. Keeping the session's version there used to drop GitHub's change.
+- **Sync holds up under stress.** A new chaos run against real GitHub (`scripts/chaos.mjs`) found and fixed three more cases: an older app with a local commit no longer stops GitHub's commits coming in, an unpushed commit is never taken for GitHub's, and a commit Quilt just pushed isn't undone by a folder that hasn't fetched it yet.
+
+## 0.3.66 — 2026-10-14
+
+- **Files from GitHub are marked.** When the relay brings a file in from GitHub, the Files tree shows GitHub's mark with who changed it and when, in place of who edited it; hover for the commit and its message. The mark goes as soon as anyone edits the file in the session. `quilt_sync_status` lists those files with their commits, so every AI sees the same.
+
+## 0.3.65 — 2026-10-14
+
+- **Each GitHub commit comes in once.** On a branch that syncs with GitHub, the relay brings GitHub's commits in and your folder follows them, including after a `git pull`, so no change is shared twice. While someone's app is older than 0.3.65, their folder brings commits in as before and the relay leaves it to them.
+- **A commit through the relay is followed at once.** After the relay pushes the session's work to GitHub, every folder on the branch follows that commit straight away.
+
+## 0.3.64 — 2026-10-14
+
+- **A git pull lands once.** When two people's folders on one branch ran `git pull` for the same commits at the same moment, the session could take the change twice. The same pulled change now lands once, however many folders pull it.
+- **Two different changes are never combined for you.** A file changed in two places (offline, by a git pull, while someone held it, or after switching branches) is now always left for a person to settle, even when the changes are in different lines, since two changes can clash in what they mean. Quilt no longer combines them on its own, so a merge stays until someone settles it. A version that already has both changes (git combined them in your folder) goes in as it is, and live edits made while git is busy for a moment still combine as live editing does.
+- **One person settles a merge.** Whoever starts settling a merge, or has their AI on it, holds the file until it's done; anyone else can only keep that version or ask for it, so nobody settles the same merge twice.
+- **Files to merge are marked in the file tree.** No more cards above the main pane pushing the Everyone view down. Each file to merge has a merge tag in the Files tree (or the name of whoever is merging it), a closed folder shows how many are inside, and a click opens both versions side by side with their buttons. The "to merge" count on the Files header shows only those files; with the sidebar folded, the count is still there.
+
+## 0.3.63 — 2026-10-14
+
+GitHub as part of the session: it stays in step with GitHub, and commits go through the relay when someone asks for one.
+
+- **The session stays in step with GitHub.** Pushes, merges and force-pushes on GitHub come into the session within seconds, or within a minute if GitHub's notice is missed. Lines both sides changed are held for a merge, never overwritten, and everything else comes in.
+- **Commits happen when you ask.** Nothing reaches GitHub by itself. `quilt_git_commit` commits your own changes through the relay; other people's changes in the same files go in only with `with_others`, naming them as co-authors. `quilt_sync_status` says where each branch stands.
+- **Protected branches go through one pull request.** Commits to a protected branch go to a live branch with one pull request. After it merges, the next commit starts a new one, and nothing merged goes twice.
+- **Agents use git through the relay.** An agent's folder clones and pushes through Quilt with its own sign-in, so no GitHub token sits on its machine. The relay checks each push against the owner's rules before it reaches GitHub.
+- **GitHub for workspaces and orgs.** A workspace or an org can connect GitHub for all its sessions (workspace page → GitHub). A workspace can list the repositories its sessions may use, and an org can require GitHub.
+- **Large files can be committed.** On branches that sync with GitHub, the owner can let the relay commit large files, through Git LFS where the repository uses it. Other branches stay end-to-end encrypted.
+- **Your local commits are yours to push.** Quilt pushes them for you only if you turn on Settings → Sessions → Push my local commits for me.
+- **Agents' branches in the branch menu.** Each one shows whose it is, where it stands with GitHub, and its pull request.
+
+## 0.3.62 — 2026-10-14
+
+- **Pull request notes come once.** The Relay says each thing about a pull request once: ready to merge, checks failing, or closed. It no longer repeats the same note after a restart or every time GitHub reports a check. What one look finds goes out as one short message per person.
+- **A pushed change is never applied twice.** When several folders were on the branch, two of them could bring in the same new commits at once and double the change in the session (a version number like `0.3.599`). A folder now waits for the one already bringing the commits in, and follows it.
+
+## 0.3.61 — 2026-10-14
+
+- **Your AI can work on its own.** Settings → Your AI → When work comes to your AI: leave it for your chat (as before), open it in your tool, or let it work on its own. With work on its own, a task given to your AI, or a merge you send it with Have your AI merge it, starts your own AI tool (Claude Code, Cursor, Codex or GitHub Copilot) in the session's folder while none of your AI sessions is open. It asks its questions in Quilt chat, and your reply carries the same chat on. You pick the model, whether it may change files, and a daily token limit; Settings shows today's tokens and each run, with Open chat to carry one on yourself. It's off unless you turn it on.
+- **Every AI follows the same project rules.** Agents read the project's rules and design system with the new `quilt_project_rules` tool, whatever tool they run in: AGENTS.md, Cursor rules that always apply, and DESIGN.md. `quilt setup` makes CLAUDE.md a pointer to AGENTS.md. In a session, ⋯ → One set of AI rules gathers rules written for one tool (CLAUDE.md, GEMINI.md, Cursor rules) into AGENTS.md, after showing you every change.
+
+## 0.3.60 — 2026-10-14
+
+- **Messages use the chat's full width.** The sender's picture and name now sit above each message instead of beside it, so messages are wider and wrap less.
+
+## 0.3.59 — 2026-10-14
+
+- **A roomier chat you can resize.** The chat pane starts wider. Drag its left edge to widen it, up to a limit that leaves room for the middle. Drag it all the way to the right, or use the arrow in its header, to fold it into a thin strip. The strip shows a count of new messages, and a click opens chat again. Your width is remembered.
+- **The Relay's branch list is accurate.** Branches nobody is on now say when a member last used them, not when the relay last saved them, and trim goes by the same time.
+
+## 0.3.58 — 2026-10-14
+
+- **Ask The Relay.** Type `@The Relay` in chat to pick a question: how the session's branches stand against git, who is connected, or which branches it keeps. The session owner can also trim branches nobody has used for a day. The Relay answers you directly, straight from the session. No AI is involved. Agents can ask it the same way.
+- **Shorter pull request notes.** A pull request ready for review now reads "PR #12 "…" is ready to review, checks pass. Move its task to Done to merge it."
+
+## 0.3.57 — 2026-10-14
+
+- **Open in Codex finds the ChatGPT app.** Codex now ships inside the ChatGPT app on a Mac, so Quilt missed it and offered no Open in Codex. Quilt now finds Codex there too and opens the session's folder in it.
+
+## 0.3.56 — 2026-10-14
+
+- **Send to Claude Code keeps its folder.** The Claude app's link could lose the folder once the filled-in prompt was sent, starting a chat in no folder at all. Quilt now makes the chat in the session's folder and opens it, with the merge prompt on the clipboard: paste it in and send.
+
+## 0.3.55 — 2026-10-13
+
+- **A push reaches the session in seconds.** A folder's look at its branch after `git push` was dropped when git still had the folder held, so the relay learned the branch's upstream only at the next minute's poll; it now looks again as soon as the hold ends.
+- **Send to Claude Code fills in the merge.** A merge sent to Claude Code opens a new chat in the session's folder with the merge prompt already typed in: press send. It's still on the clipboard for every other app.
+- **One person settles a merge at a time.** Send to…, Edit by hand, Keep mine and Keep theirs first claim the file, so someone else who tries at the same moment is told who is on it and can ask for it. The claim goes when the merge is settled.
+- **Inviting from a workspace: cards, not a list.** The people and agents you've worked with are small cards, six a page with a search, most recent first; In, Invited, Add and Invite on each.
+
+## 0.3.54 — 2026-10-13
+
+- **Team button.** A workspace page is its sessions and files; People & agents open from the Team button beside Invite, as a grid of cards with a search, Add and each card's ⋮ menu.
+
+## 0.3.53 — 2026-10-13
+
+- **Collapse the sidebar.** The « at the top folds it to a rail of icons (hover for names); » brings it back. Remembered on this computer.
+- **People & agents on a workspace page are cards.** The same small cards as Agents: agents wear a bot badge so who is human shows at a glance; one line says what each is and its access. An admin's ⋮ menu sets access, whether an agent is invited to new sessions, Remove, Not in this workspace or Let back in. Nine a page with a search when there are more.
+- **Nothing is capped anymore.** Settings and Agents fill the page; the switches in a card or dialog fill it too.
+
+## 0.3.52 — 2026-10-13
+
+- **The Agents page is cards too.** The same small cards as Settings, nine a page with a search and a count. Open a card (or its ⋮ → Where it works) for Works in and Invited to new sessions, in a dialog that saves at once.
+
+## 0.3.51 — 2026-10-13
+
+- **Agents in Settings, like a members page.** Small cards (a dot for whether it can join sessions now, its name, what it is, a ⋮ menu with Where it works and Revoke), nine a page with a search box and a count, so the card stays short however many agents you have.
+
+## 0.3.50 — 2026-10-13
+
+- **One webhook per agent.** A hosted agent subscribes once (quilt_webhook_subscribe) and is told of mentions, direct messages and tasks from every session it is in, and, as a workspace agent, when a session starts in its workspaces (session.started), at the same URL with the same secret. Every event says which session and workspace it is from.
+- **Hosted agents in several sessions at once.** quilt_join_session adds a session instead of replacing the one before; every tool takes `session: <id>` (needed when the agent is in more than one, refused when it names one the agent is not in), so an answer can never land in the wrong session. quilt_session_info lists them; quilt_leave_session leaves one.
+- **Settings cards stack.** The heading, a line on what the card is for and its main action sit across the top; the body has the full width. Agents are a table (who, where it works, new sessions, last used), with Invite an agent in the heading.
+
+## 0.3.49 — 2026-10-13
+
+- **Settings in tabs.** You (profile, appearance, sounds), Sessions (defaults for starting and joining), Agents, Workspaces (with workspaces on), Account (sign-in, this computer, the version). The tab you were on is remembered. The same tabs in the pop-up inside a session.
+- **Agents settings.** The Agents tab holds your AI (picking up tasks, sharing and summarizing your chat), your agents with Invite an agent, and Agents and git: what agents may commit in sessions you start (not at all, branches of their own, any branch; a running session's owner still changes it in its commit panel) and your GitHub connection, with Connect GitHub right there.
+- **No more scrolling into nothing.** The Settings page could scroll the whole window down past its content (the toggles' hidden inputs stretched the document); the page scrolls on its own now.
+
+## 0.3.48 — 2026-10-13
+
+Found by running the hosted git tools live and reading the branch list afterwards.
+
+- **A folder mid-switch can't write another branch's upstream into this branch's record.** The relay took a folder's git state while keying it by the branch document its connection was still on; switching branches (as taking a task does) could leave the default branch's record pointing at an agent's branch, so pull requests opened against the wrong base. The relay now ignores a folder's word about a branch its git isn't on.
+- **An agent's branch always merges into the default branch**, even once the relay has a record of the branch itself: pull request base, QA/Done target, status and log all say so.
+- **Merged and deleted branches are left alone.** A branch deleted after its merge is marked gone: no more looks at GitHub every ten minutes, no errors in the branch list; a push to it brings it back. A healed record no longer shows its old warning until the next look.
+- **A push refreshes the folder's upstream at once** (git push -u sets it), so the relay knows a new branch's upstream in seconds, not at the next poll. quilt_sync_branch explains a healed or gone branch in plain words.
+
+## 0.3.47 — 2026-10-13
+
+Git for agents without a folder (hosted, over HTTP): the quilt_git_* tools, on the same path as everyone else.
+
+- **One family of tools.** `quilt_git_commit` (was quilt_commit), `quilt_git_branch` (was quilt_switch_branch; without a name it lists the branches), `quilt_git_pull_requests`, `quilt_git_merge`, and new: `quilt_git_status` (branch, repository, what agents may push, your uncommitted files, your task's pull request), `quilt_git_log` (the branch's newest commits), `quilt_git_diff` (the session's copy against GitHub, per file), `quilt_git_revert` (GitHub's version of a file back into the session). Folder agents keep plain git; none of this is in their tool list.
+- **The same pathway.** Taking a task puts a hosted agent on `quilt/<agent>/<task>` (a copy of the default branch's files). `quilt_git_commit` commits to the branch the agent is on; on a branch of its own the pull request opens by itself, tied to the task. The session's branch is open to agents only under "any". Done merges, as for folders.
+- **A branch the relay has no record of** (an agent's own, made in the session) commits against the default branch's record: its files, the default branch's base.
+
+## 0.3.46 — 2026-10-13
+
+- **A branch's record can't wedge on a commit GitHub never had.** The relay records a folder's commit only when the folder says it is on the upstream; a local commit not pushed yet (or dropped later) is never recorded, the upstream's tip is. If a record is already on such a commit, it heals: a folder that has fetched and doesn't have it says so, and the record follows that folder; with no folder on the branch, the relay's own look at GitHub follows the branch's head. Found live on 2026-10-12, when a test commit made and dropped in an agent's folder left the relay's record of main stuck for hours (folders were unaffected; hosted agents' commits to main would have failed).
+
+## 0.3.45 — 2026-10-12
+
+- **The next task starts from main.** An agent whose folder is still on a finished task's branch (merged, or its task Done) is moved back to the default branch when it takes the next task, and the new branch is cut from the latest of it (a fetch and a fast-forward first). A branch with a task still open on it is kept.
+
+## 0.3.44 — 2026-10-12
+
+The branch → pull request → QA → merge path, done by Quilt rather than remembered by agents.
+
+- **Taking a task puts the agent on a branch.** When an agent moves a task to In progress, Quilt checks out `quilt/<agent>/<task>` in its folder (cut from where the folder is). Nothing for the agent to remember; it works and pushes there. Agents may still work on the session's branch when the owner allows it ("any").
+- **Pushing opens the pull request.** The relay opens the pull request for an agent's branch the moment it is pushed, named after the task, and ties it to the task (a push with no task gets one). Nothing is left hanging after a push.
+- **Done merges.** Moving a task to Done merges its pull request, once checks pass: a person may always (the app, the CLI, any tool); an agent only when the owner lets agents push to any branch, otherwise the task waits in QA and the people who can merge are told. A pull request merged on GitHub by hand moves its task to Done by itself; one closed without merging tells the agent; failing checks tell the agent.
+- **GitHub's pull-request events reach the relay** (through the accounts API), so these happen within seconds, with the relay's ten-minute look as the backstop. Fixed on the way: the relay's push-event endpoint had never reached the sessions (a shadowed variable); folders had been catching up by their own minute poll.
+- **A branch's starting copy is nobody's change.** Files a folder brings to a new branch are on record but never blamed on the agent or counted as its unpublished work; QA judges only what the agent changed for the task.
+- **Hosted agents:** `quilt_commit` with `pull_request: true` and a task ties the pull request to the task, and says so even when the branch already had everything.
+
+## 0.3.43 — 2026-10-12
+
+The feature-branch path, checked end to end: an agent cuts a branch in its folder, pushes it on the first try, and its task moves as the branch does.
+
+- **Credentials follow the repository, not the branch.** An agent that runs `git checkout -b quilt/<agent>/<topic>` and pushes gets its token at once: the folder names the repository its remote points at, so a branch the relay has no record of yet is no obstacle.
+- **QA and Done are measured against the branch the work merges into.** For a feature branch cut in the folder, that is the session's default branch: QA once the branch is pushed, Done once it is merged there. Reminders about uncommitted work cover feature branches too.
+- **Pushes are on record through the relay.** The folder reports what it pushed and the relay keeps the record and tells the chat, so an agent held to part of the project is on record all the same.
+- **Whether agents can commit here comes with everyone's access** (the session's GitHub connection or token, whatever branch a folder is on), and changes the moment GitHub is connected or a token is set.
+- **A push with nobody connected is refused with the reason.** When no member has connected GitHub (and the owner set no token), the hook says so and what to do (connect, or ask a person with `quilt_request_commit`) instead of git failing to sign in.
+- **Housekeeping in agent folders.** A moved Node.js or Quilt leaves no stale credential helper behind: the folder's helper is repaired on start. A folder's own pre-push hook or git identity is never overwritten.
+- **Tested for real:** an agent asks for a commit while agents may not push, the owner turns them on, the request is handed back; the agent cuts a branch, pushes it with `git push -u`, its task is clear for QA, blocked for Done until a person merges the branch, then clear; removing the agent revokes its token at GitHub. The same agent in two sessions with different policies is held to each. A clone the agent made itself gets the helper and hook, keeps its own hook and identity, and paths with spaces work.
+
+## 0.3.42 — 2026-10-12
+
+- **Agents can't force-push.** An agent's folder refuses a push that would rewrite a branch on GitHub (what is there must be an ancestor of what is pushed), before git tries, with what to do instead: fetch, rebase or merge, push without `--force`. Quilt never rewrites history, and now neither can an agent through it.
+- **A new look for the blog.** The blog index shows posts as cards in a grid, each with its image, date and read time. A post opens with its image beside the title, then a table of contents in a sticky sidebar that follows you, highlighting the section you're reading.
+
+## 0.3.41 — 2026-10-12
+
+Agents use git. Their folders sign in to GitHub through Quilt, with a token of their own for the one repository, and push like anyone.
+
+- **An agent's folder pushes with git itself.** No Quilt tool in the way: `git commit` and `git push` work in an agent's folder as they do for a person. git asks Quilt for credentials (a credential helper Quilt puts in the folder when it makes it a checkout); Quilt answers with a short-lived token from the session's GitHub connection, minted for that agent and for that repository only. Nothing long-lived sits on the agent's machine. `quilt git-token` prints the same token for `gh` or GitHub's API (`GH_TOKEN=$(quilt git-token) gh pr create`).
+- **The owner's policy still holds.** A pre-push hook in the folder refuses pushes outside what the owner allows (`quilt_agent_commits`): by default only branches of the agent's own, `quilt/<agent>/<topic>`, with a pull request; with "any", anything; with "off", nothing (git gets a read token). Each agent's token is its own: when the owner turns agents off, or removes an agent, that agent's token is revoked at GitHub at once. For a hard limit on main, protect the branch on GitHub.
+- **Pushes are on record.** Quilt sees what an agent pushed: the chat gets a note ("Duncan pushed 2 commits to acme/widgets quilt/duncan/blog: …"), and the pushed content is on record, so the branch comes back down clean when it is merged. Commits in an agent's folder are credited to the agent.
+- **QA when it's in git, Done when it's merged.** An agent's task may move to QA once its files are on a branch on GitHub (a pull request under review counts), and to Done only once they are on the session's branch; both refusals say what to do. Reminders about uncommitted work say to commit and push.
+- **Old requests go back to the agent.** A commit request an agent made before it could push (or before GitHub was connected) is handed back once it can: closed for people, and the agent is told to push it itself. Nothing of an agent's sits on a person's plate.
+- **Folder tools trimmed.** `quilt_commit`, `quilt_pull_requests` and `quilt_merge` are gone from agents with a folder (and from the CLI): git does that. They stay for hosted agents, which have no folder.
+- **Per session, not per agent.** An agent in several sessions has a folder per session; each folder asks its own session, so an agent gets exactly what each session's owner allows there.
+
+## 0.3.40 — 2026-10-11
+
+Agents own their commits; nothing of theirs lands on your plate.
+
+- **Agents commit their own work, or are reminded to.** An agent can't move a task to QA or Done while the task's files aren't in git on GitHub (when it can commit itself): it's told which files, and to `quilt_commit` first. Work an agent leaves uncommitted gets it a reminder from Quilt about every ten minutes (a message that wakes it and needs no reply). `quilt_request_commit` is refused for agents that can commit themselves.
+- **The commit panel shows only what needs a person.** Gone: "Not committed yet" lists of other people's and agents' files with Commit buttons. The panel has the requests of agents that may not commit (if any), the GitHub connection, and what agents may commit. People commit with git; agents with `quilt_commit`.
+
+## 0.3.39 — 2026-10-11
+
+Agents know what "that" means: every wake carries the talk before it, follow-ups reach the agent they are for, and a session's name skips the backstory.
+
+- **Follow-ups reach the agent.** A message in the room that names nobody, within ten minutes of its sender mentioning an agent, wakes that agent too ("can you retry that?" after "@Duncan deploy the blog"), so nobody has to type the @ again.
+- **The conversation comes with the wake, everywhere.** What an agent is shown with a message now includes what the two of you said in the room to nobody in particular, not only direct messages and @mentions, and a reply always shows the message it answers, even an old one. Claude Code and Cursor hooks show the same conversation as `quilt_inbox`, the webhook and the channel event; before, the hooks showed the message alone.
+- **"That" is never a question back.** Every wake tells the agent that "that", "it", "again" and "retry" mean the latest thing in the conversation shown under it, and to read back with `quilt_conversation` rather than ask a person to repeat themselves.
+- **A session is named after the work, not the backstory.** "I just had gpt add some info and double check your plan" names the session "double check plan", not "had gpt add": an opener about what happened before is skipped.
+
+## 0.3.38 — 2026-10-11
+
+Connecting GitHub finds you: one card, one click, and the session knows the moment it's done.
+
+- **A session on a GitHub repository asks once.** When nobody in the session has connected GitHub for its repository, a card at the top of the session says so, with **Connect GitHub** and **Not now** (a week). The commit chip reads **Connect GitHub** until it's done, and **GitHub** afterwards.
+- **One click lands on the right account.** Connect GitHub opens the install page for the repository's own account or organization, with the account picker skipped. When an organization has its admins approve apps, the page back says so; nothing more to do once they approve.
+- **The session knows right away.** After you finish on GitHub, Quilt notices, checks the repository through the relay and clears the card; the panel then says who it's connected through. "Add repositories" is there when Quilt isn't on the repository yet.
+- **Agents tell you when they're stuck on it.** When an agent tries to commit and the repository isn't connected, the session owner gets one direct message (at most every six hours) with the click that fixes it.
+- **`quilt github`** in the CLI says the same and prints the link, for people without the app open.
+
+## 0.3.37 — 2026-10-11
+
+Agents get a real git folder, pull requests of their own to list and merge, and one person's GitHub covers the whole session.
+
+- **Agents' folders are git checkouts.** When an agent joins a session on a repository, Quilt makes its folder a checkout of that branch at the commit the session is at, with the session's files left as they are: `git log`, `git blame`, `git diff` and branches work in every tool. Fetches are Quilt's (it signs in for the folder, read only); commits go through `quilt_commit`, so no agent's machine ever holds write credentials. Folders joined before this get git on their next start.
+- **One connected member covers everyone.** The relay commits, merges and reads a repository for a session on behalf of the first member whose linked GitHub account may do that there, online or not. Brandon never connects for sessions Daniel connected, and nothing changes for agents.
+- **Pull requests from any tool.** `quilt_pull_requests` (`quilt prs`) lists the open ones with their checks; `quilt_merge` (`quilt merge 42`) merges one, refusing while checks fail or run, and deletes a merged `quilt/…` branch. People may always merge; agents when the owner lets them commit to any branch.
+- **No waiting after a push.** A folder told of a push on GitHub pulls as soon as it is quiet, even if files were still arriving when it looked; a folder that can't fetch is no longer waited for by the others; and a file someone holds no longer holds up a pull when the session already has that version.
+- **Webhooks need their secret.** The API refuses GitHub's events unless its webhook secret is set, so nothing unsigned can nudge the relay.
+
+## 0.3.36 — 2026-10-11
+
+Git-backed sessions stay in step with GitHub, and merged branches come down clean.
+
+- **Pushes on GitHub arrive in seconds.** When anyone pushes or merges on GitHub, Quilt's GitHub app tells the relay, and every folder on that branch pulls at once, instead of at its next minute's check. Where no folder can pull, the relay brings the commits in itself.
+- **Merged branches come down clean.** When an agent commits to a branch of its own and that branch is merged into yours on GitHub (merge, squash or rebase), the session doesn't treat its own work as a conflict. Its copy of those files is that version or newer, so it stays as it is. Only real conflicts are left: someone else changed the same lines on GitHub.
+- **The owner hears about commit requests.** When an agent asks a person for a commit (`quilt_request_commit`, now with an optional description), the session's owner gets a direct message with the files, which wakes their AI. It waits in their inbox until the request is done, not until someone replies.
+- **What git ignores is never committed.** Agents' commits skip files the repository's `.gitignore` ignores, plus secrets files such as `.env`, and say which they left out.
+
+## 0.3.35 — 2026-10-09
+
+Agents ship their own work, and know what they're being asked about.
+
+- **Agents commit their own work.** `quilt_commit` (and `quilt commit` in the CLI) commits an agent's files to GitHub straight from the session's copy. The agent needs no git or credentials on its machine, and nobody else has to be online. It works the same from Codex, Cursor, Claude Code, the CLI or a hosted agent over HTTP. Only the files named go in (by default, the agent's own changes on record), with the agent as the author. Everyone sees the commit in chat.
+- **You decide what agents may commit.** In the commit panel (or with `quilt_agent_commits`), the session owner picks one of three options. **To branches of their own** is the default: each agent commits to `quilt/<agent>/…` and can open a pull request for people to merge. **To any branch** lets them commit to the session's own branch, `main` included. **Not at all** means they ask a person instead. People commit with git as they always have.
+- **Connect GitHub in one click.** In the commit panel, the session owner clicks **Connect GitHub** and picks the repositories on GitHub. There's no token to create or paste, it works for public and private repositories, and it covers every session on those repositories. Quilt commits to a repository only when the owner's own GitHub account may write to it. A token set by hand (`quilt_github_token`) still works. Other hosts (GitLab, Bitbucket and others) come next; until then, a person with git commits for the agents.
+- **Commits never undo anyone's work.** A file that changed on GitHub since the session's copy is refused until it's brought in. A file that also holds someone else's uncommitted changes is refused too, unless the agent commits it with them as co-authors. Quilt never force-pushes or rewrites history.
+- **When agents can't commit, they ask with the files.** `quilt_request_commit` now names the files and the task. A person with git on the branch sees each request in the commit panel with a **Commit and push** button, which commits exactly those files and nothing else that's uncommitted or staged in their folder. The asker gets a note with the commit; it wakes them and needs no reply.
+- **Nothing finished sits uncommitted unnoticed.** In a folder with git, the commit chip shows how many files aren't in git yet, and the panel lists them by who changed them, each group with its own **Commit…** button.
+- **Agents see the conversation they're woken into.** A mention, direct message or task that wakes an agent now comes with the messages before it between the agent and the sender: in `quilt_inbox`, in the webhook's new `context` field and in the Claude Code channel. A fresh session knows what "is that tool live?" refers to.
+- **Agents can read back through a conversation.** `quilt_conversation` (CLI: `quilt messages --with <name>`, `--grep`, `--before`) reads an agent's whole conversation with one person, searches the chat, or pages further back. Quilt keeps the chat past the room's newest 500 messages, both in each folder and on the relay. Agents are told to read back rather than guess when a message refers to something they don't have.
+
+## 0.3.34 — 2026-10-09
+
+Workspaces read like a dashboard, and opening one (or a session) shows it loading.
+
+- **A workspace's page is a dashboard.** Under its name, a line says what is in it: sessions open now, sessions, files, and people and agents. Sessions are rows with room for their full names, with **New session** beside the heading; files sit under them, and the people and agents are in a column alongside (below, on a narrower window).
+- **Loading workspace.** Opening a workspace shows the Quilt mark piecing itself together over "Loading workspace" and its name, then its page fades in, instead of a pause and a snap.
+- **Loading session.** The first time you open a session, the same screen stays up until its chat, files and AI feeds are in, then fades away, so nothing pops in after you arrive.
+- **Pages use the whole window.** The home screen, a workspace's page and Settings no longer stop at a fixed width.
+
+## 0.3.33 — 2026-10-09
+
+- **One AI merges a clash, not all of them.** When commits from elsewhere clash with the session's uncommitted work, Quilt now puts one task on the board ("Bring 4 commits from origin/main into the session: src/a.js, src/b.js clash"), listing each file and why, and hands it to one AI: an agent member first, otherwise the AI session of a member who may change those files. Everyone else's AI is told who is merging it and to leave those files alone, and the branch list shows "being merged by …". Once that folder has pulled and resolved it, the others follow by themselves and the task closes itself. If the one it went to leaves for five minutes, the next member takes it over; a branch with commits of its own is still left to its own folder.
+- **New commits reach hosted agents while everyone's offline.** When only hosted agents are working on a branch and nobody's folder is online on it, the relay itself checks GitHub about every 10 minutes and brings new commits from the branch's upstream into the session, merged with its uncommitted work. The activity log says "the relay brought in 3 commits from origin/main · 2 files", and the branch list and `quilt_status` show "brought in by the relay" and when it last checked. If the commits clash with the session's work, nothing is written: one hosted agent on that branch gets a task listing each file, what changed upstream and how to merge it with `quilt_write_file`, and the commits land by themselves once its merged files are in. When your folder comes back, git simply moves forward to the relay's commit without rewriting your files.
+- **Private repositories need a read-only token.** Public GitHub repositories work as they are. For a private one, the session owner adds a read-only GitHub token once, in **Session settings** (**GitHub read-only token for bringing in commits while everyone's offline**) or with `quilt github-token`. It stays on the relay and is never shown to anyone; without it, the branch list says the relay can't read the repository. Only GitHub for now: other hosts wait for a member's folder, as before.
+- **Agents can pull now, too.** A hosted agent's `quilt_sync_branch` makes the relay check GitHub for its branch at once (at most once a minute), and a folder that isn't a git clone, or can't fetch, asks the relay the same way. The relay also steps in for a branch whose only folders can't bring commits in: not a git clone, held, diverged, a viewer's, or whose fetch fails.
+- **A failed fetch is said, not hidden.** When git can't fetch in a folder ("git can't sign in to github.com from this folder"), the branch list, `quilt_status`, `quilt_branches` and `quilt_sync_branch` say so instead of "up to date", and the relay brings commits in for that branch meanwhile.
+- **Relay merges land as soon as they're written.** Writing a merged file of a relay clash makes the relay look again straight away; a file counts as merged once the lines that clashed were rewritten (a write elsewhere in it no longer does), or when the task's assignee moves it to QA. A clash never goes to a chat link, and `.quiltignore` files in the repository are honoured.
+- **Whoever merges a clash holds its files.** The AI a clash task goes to (in a folder, or a hosted agent) claims the clashing files while it merges, so a partner's edit is refused with the usual claim message; a file someone else holds is asked for in its queue. The files move with the task when it is handed on and are let go of when it closes, and a bring-in never writes a file someone else holds.
+- **More git for hosted agents.** Over HTTP an agent can now ask for a commit and mark it done (`quilt_request_commit`, `quilt_commit_status`, `quilt_commit_request_done`, with the same rules as people), and `quilt_switch_branch` with create loads a branch that is on GitHub but not yet in the session at its latest commit. The owner can set the relay's GitHub token from their AI with `quilt_github_token`; agents are told to ask the owner for it.
+- **The relay never works over a folder that's busy.** A folder in the middle of a pull, a merge or a branch switch, or with commits of its own, keeps the relay out of its branch, and a clash its AI is merging is never handed to someone else while it is online. An AI making no progress on a clash for 15 minutes passes it on; with nobody to pass it to, everyone may pull and resolve again. Members whose Quilt is older still tell their AI to pull, so update everyone's app.
+- **Guides match what each agent can do.** Hosted agents are told how the relay brings commits in and how to merge its clashes; agents with the CLI are told to join from a git clone with fetch credentials that work without a prompt.
+- **A lighter people menu.** The people menu now just shows who is here and what each person and AI is working on. Sharing your AI chat, who can get in, each member's access, the GitHub token and ending the session moved to **Session settings**, at the bottom of the people menu and in the ⋯ menu.
+
+## 0.3.32 — 2026-10-09
+
+Invites that reach people, sessions that move into workspaces, and the workspace library for every agent.
+
+- **Invites for you, on Home.** When someone invites you to a workspace or a session, it waits on your Home (and on your heyquilt.com dashboard) with Accept, Join or Decline. No more digging through email for a link.
+- **Invite people to a workspace.** In a workspace, Invite lists the people you've worked with: one click sends them an invite. Anyone else, type their email and Quilt sends it. They're in once they accept; waiting invites show in the same window, where you can cancel them.
+- **Move a running session into a workspace.** A session's ⋯ menu has Move to a workspace. Everyone with access to the session, people and agents, comes along into the workspace with the same access (when you manage that workspace).
+- **Every agent reaches the workspace library.** Your AI in a session now gets the library tools as you, and an agent in its own folder gets them as itself, even with several agents on one computer. Agents can make folders, and `quilt workspace` (list, files, get, put, write, mkdir, mv, rm) does it all from a shell, on Mac, Windows or Linux.
+
+## 0.3.31 — 2026-10-09
+
+- **Fewer pulls left for you or your AI.** When commits from elsewhere and the session's uncommitted work both only added lines in the same place (two new release-note sections, code added at the end of a file, names added to the same import line), Quilt now keeps both and brings the commits in by itself. Only real edits to the same lines still wait for someone to merge them.
+- **One lane per person's AI in Everyone.** Each person's AI chats share one lane, "Daniel's AI", as in the chat, so old chats like "Daniel · Claude Code 2" no longer get lanes of their own. What they said and the files they hold show in that lane.
+- **No empty space under the last card.** The Everyone view could leave a tall blank stretch under the newest card after the cards got shorter. It now ends at the last card.
+- **AIs answer a message once.** An AI's reply to a direct message carries the id of the message it answers (`re` on `quilt_message`, filled in by itself when left out), and Quilt refuses a second answer to the same message from any of that person's AIs. That works for every AI tool, local or hosted.
+- **"No reply needed" sticks.** Messages an AI settled as needing no reply (`quilt_inbox` `no_reply`) no longer come back to every AI after the app restarts.
+
+## 0.3.30 — 2026-10-09
+
+One page about agents.
+
+- **Everything about agents on one page.** heyquilt.com/docs/agents now covers every way an AI takes part (your own AI tools, an agent on a computer, a hosted agent or app over HTTP, a chat AI), where to invite one, global, workspace and session agents, connecting step by step, every tool an agent gets by job, and how you stay in control. **How agent kinds work** in the app opens its agent kinds section.
+
+## 0.3.29 — 2026-10-09
+
+Each git branch gets its own live copy in the session.
+
+- **Every branch has its own live copy.** People on `main` and people on `feature-x` each work live on their own branch's files, and the two never mix.
+- **Your folder follows `git checkout`.** Check out another branch and your folder moves to that branch's copy. `git checkout -b` takes your work with you onto the new branch. On a branch the session already has, your folder takes that branch's version, and the work on your old branch stays there for whoever is on it.
+- **See who is on which branch.** The branch menu and `quilt_branches` show which branches have a live copy in the session and who is on each.
+- **Hosted agents choose a branch.** An agent connected over HTTP stays on the branch it first worked on, or picks one with `quilt_switch_branch` (`create: true` starts a new one from the files it has).
+- **Unused branches clear themselves out.** A branch's copy nobody has been on is put away after 10 minutes and deleted from the session after 30 days. Coming back later starts it fresh from your folder. Your own changes are kept in `.quilt/conflicts`.
+- **A very large branch doesn't stop the session.** Each branch has its own size limit. A branch over it is marked "full" in the branch menu, stops taking changes and its people are told to start a fresh copy with `git checkout -b`, while everyone else carries on.
+- **Older Quilt apps are asked to update** before they can join a session.
+
+## 0.3.28 — 2026-10-09
+
+A tidier sidebar, a slim top bar on narrow windows, and workspaces built in but switched off.
+
+- **Settings sits at the bottom of the sidebar,** under a line, and **Shut down** lives in Settings only.
+- **Narrow windows get a slim top bar.** Below about 760 pixels wide, the sidebar folds into a drawer behind a menu button, with the logo, where you are and your avatar along the top.
+- **Workspaces are built in, switched off.** Sessions work exactly as before. Workspaces (sessions, people, agents and files gathered in one place) arrive once they're turned on.
+- **For servers:** the accounts API stores workspace files in the Quilt Files project's `workspace-files` bucket with `QUILT_STORAGE_URL` and `QUILT_STORAGE_KEY`, or on its own disk under `QUILT_API_DATA` without them. The relay needs `QUILT_API_URL` for hosted agents' workspace tools. Everything above stays off until the API runs with `QUILT_WORKSPACES=1`. Apply the migrations `20261004000000_workspaces`, `20261005000000_workspace_files`, `20261007000001_workspace_agents` and `20261008000001_agent_invite_global` before deploying this API, even with workspaces off: it reads their columns either way (agent invites, for one).
+
+## 0.3.27 — 2026-10-08
+
+Each person's AI is one name: "Daniel's AI".
+
+- **Chat highlights with lightweight markdown.** Messages can use `**bold**`, `*italic*`, `##` / `###` headings and a `---` / `----` line as a divider, so important bits stand out in longer chats. Mentions and HTML escaping still work the same way; the same `----` rule also renders in task notes.
+- **One name for all your AI chats.** Quilt used to list every Claude Code, Codex or Cursor chat as its own member ("Daniel · Claude Code 23"). Now each person's chats show as one, "Daniel's AI", in the people list, the chat and the message menus. Open the people list to see the chats under it and what each is working on. Your own shows as **Your AI**.
+- **Write to someone's AI.** Mention `@Daniel's AI` or pick it in the **To** menu, and the chat that person used most recently answers, once. That works from any AI tool, and for your own AI from your app. With none of their chats open, the message waits for the next one.
+- **Your AIs talking to each other stay out of the chat.** When one of your chats writes to another of yours, it isn't shown and doesn't count as unread. Only what your AI says to people appears.
+
+## 0.3.26 — 2026-10-08
+
+AI sessions get names you can tell apart.
+
+- **AI sessions are named after what you asked them.** An AI session now takes its name from your first prompt to it (Claude Code, Cursor and Gemini CLI), or from the first file it edits, instead of staying "Daniel · Claude Code 17". When its tool restarts Quilt's connection it keeps its name and its files, and a closed session leaves the list and frees its name. An open chat that's just waiting no longer keeps its claims from going idle. Sessions don't take names from your prompts while you keep your AI chat to yourself.
+
+## 0.3.25 — 2026-10-08
+
+- **See who is typing in chat.** While someone types a reply — a person in the app, or an AI with `quilt_typing` — the chat shows a small bouncing-dots animation and "Dana is typing…". Direct messages' typing shows only to the recipient; sending the message (or clearing the box) takes it back.
+- **AIs keep it brief.** The guide every AI reads now asks for chat messages of a sentence or two, one message rather than several, with no play-by-play, recaps, logs or pasted code. Notes on tasks follow the same rule: comments, `qaNotes` and `verified` say in a few short sentences what changed, why and how it was checked, and the board's tools and briefings say so too.
+- **Everyone's AI work at once.** The middle of the window now opens on **Everyone**: every person in the session gets a lane, with time running down like a feed. Each turn with their AI (what they asked, what it did, which files it changed, its reply) is a card in their lane, beside their chat messages and task notes, so you see who's working on what side by side. Lanes that changed the same file are stitched together, with a ⚡ where two AIs were on it within 15 minutes. Hover a file (on a card or in the file tree) to light up every turn that touched it, click a card to open it in place, or open the whole conversation from it. An AI that's working shows a needle at the bottom of its lane, stitching the file it last changed. Switch chat and tasks on or off, pick **Compact** for one line a card, hide a lane, or read it all as **One column** (a narrow window does that by itself). Each person's own AI chat is still a tab away.
+- **Lots of people, no sideways scrolling.** When there are more lanes than fit, the quieter ones fold into thin strips: each thing that person did is a knot in the same rows as everyone else, so you still see when they were busy and threads still reach them. Hover a knot to see what it was; click it or the strip to open the lane, and the lane used least recently folds to make room. Working AIs, you, and the last two lanes you opened stay open first, and the **pin** on a lane keeps it open for good. Past six strips, the quietest share one column at the end: click **+N** for the list of everyone in it.
+- **Your AI sessions don't answer each other.** When one of your AI sessions writes to you, your other AI sessions no longer take it as a message to them and reply. It's for you.
+- **A blog on the website.** heyquilt.com/blog lists our posts, newest first, and Blog is in the site nav. Each post is a markdown file in `web/content/blog`.
+- **Agents that can run commands use the Quilt CLI, full stop.** The agent invite, the page its link opens, the reply to joining over HTTP and the hosted connection's instructions now all say up front that an agent able to run shell commands anywhere (its own computer, a cloud machine, a sandbox) must install and join with the CLI. HTTP is only for a bot with no computer that can do nothing but make HTTP requests. An agent that joined over HTTP anyway is told to stop and switch, with the exact commands to come back as the same agent.
+
+## 0.3.24 — 2026-10-08
+
+Work committed outside the session now comes into it by itself.
+
+- **Commits from elsewhere come in by themselves.** When someone pushes from a worktree, merges a pull request on GitHub, or lands a branch from another worktree, the session used to miss it until a person in it ran `git pull`. Now each folder checks its branch's upstream about once a minute and brings new commits in on its own: the branch moves forward and the session's uncommitted work is merged into those files, for everyone. Quilt only ever moves a branch forward. It never merges git history, and it writes nothing unless every file merges cleanly.
+- **Moved files keep up.** If the session moved a file (say, tests into new folders) and the new commits change it at its old place, the change lands in the moved copy. New files the commits add to a folder the session emptied are pointed out to your AI.
+- **Clashes go to your AI, not to you.** When the new commits and the session's work change the same lines, or the branch has commits of its own that the upstream lacks, nothing is brought in. Your AI is told which files clash and why, and once one person resolves it with git, everyone else's folder follows.
+- **See every branch.** Click the branch name at the top of a session to see which branch each person's folder is on, which AI sessions and worktrees are working on which branch, how each one compares with its upstream, and who committed last. **Check for new commits** looks right away. The label says when a pull is needed.
+- **For every AI tool.** `quilt_status` lists the branches. `quilt_branches` gives the full picture, and `quilt_sync_branch` brings commits in right after an AI pushes or merges somewhere else. Agents connected over HTTP get `quilt_branches` too.
+
+## 0.3.23 — 2026-10-08
+
+- **An agent invite from a session brings the session with it.** Inviting an AI agent from a session's Invite now puts that session's link in the text you paste, so the agent registers and joins the session in one go instead of waiting for you to send the link separately.
+
+## 0.3.22 — 2026-10-08
+
+- **Edits held back by a claim merge by themselves.** If you come back to a session with changes to a file someone (or their AI) had claimed, your version used to wait under Merges until you settled it, even when the two sets of changes didn't overlap. Now Quilt combines them on its own as soon as they let go of the file, and the merge closes. If your changes do clash with theirs, the merge stays open for you, as before.
+- **Longer session names.** New sessions get a longer random name, so a new session can never land on the name of one that already exists.
+
+## 0.3.21 — 2026-10-08
+
+Coming back to a session now tells you what changed while you were away.
+
+- **While you were away.** When you rejoin a session, a card above your files says who changed which files while you were gone, with how much each one changed and whether it's new or deleted. Click a file to open it. It also says what became of the edits you made while away: which went straight into the session, which were combined with other people's changes, and which clashed and are waiting for you under Merges. When you join a session for the first time and your copy of a file differed from the session's, it says where your copy was kept. The card stays until you click **Got it**, even if you restart the app.
+- **Your AI knows too.** `quilt_status` starts with the same "While you were away" summary, for Claude Code, Cursor, Codex and every other tool, so your AI reads what changed before touching those files.
+- **The task board always fits.** When its columns can't all sit side by side (a narrow window, or the file tree and chat open beside it), the ones you aren't using fold into thin strips with their name and count, so no column is ever hidden off to the side. Click a strip to open that column; the one you used least recently folds to make room. Rest a dragged card on a strip and that column opens so you can place it, or drop it straight on the strip. A folded column's count pulses when a task lands in it, so you see when someone, or their AI, moves work there. Each column has a fold button to keep it folded at any width (say, Done), and the board remembers your choices per session. Until you choose, the work in flight stays open: In progress, then QA. On a phone-narrow board the columns stack, one open and the rest as bars. The board's top no longer overlaps itself when it's narrow.
+- **A clearer archive.** **Archived** on the board now opens a view of its own: a filter that narrows the list as you type (Esc clears it), then **Finished** (tasks that were in Done, with a ✓ when their work was verified) and **Set aside** (archived from To do, In progress or QA, each with its column), newest archived first, laid out as a grid of cards that fills the width (one column when it's narrow). Fold either group and it stays folded. Each card shows who it was for, who made it and when it was archived, and **Restore to QA** (or wherever it was) says where it goes back. Removing one for good now asks first, with **Keep it** ready, instead of deleting on the first click. Tasks remember when they were archived from now on; ones archived before this have no date.
+- **See what changed inside a file.** Every open file has a **Changes** tab next to **File**: each change to it, newest first, with who made it, when, the task it was for, and the lines added and removed in green and red. It keeps up as people edit. Clicking a file in **Changes** at the top opens it on that tab (deleted files too), and so does the "you · 2m" badge on a file just edited in the file tree.
+- **Hover a file to see how it changed.** In the file tree, hovering any file this session changed (or arrowing to it) shows a card beside it: its lines added and removed in green and red, each person's share and when they last touched it, with anything a git pull brought marked apart. It appears after a moment, follows you from row to row, and Esc hides it. Its last line says whether the file's **Changes** tab has the diff. A session keeps only its latest 2,000 changes, so after a big change (like moving many files) older diffs are gone: the **Changes** tab then still lists who made those changes, their lines added and removed, and when, and says their diff is no longer kept, instead of showing nothing.
+- **Search and filter the task board from one button.** **Filter** at the top of the board opens a panel with a search that narrows every column as you type (title, id, who a ticket is for, who made it, its files and its QA and verified notes, every word in any order) and **Show**, to see only unassigned tickets or one person's or AI's. The button says what's on, like **“agents” · Sam · 8 of 19**, with an × to clear it all, so a filtered board never passes for a short one. Column counts become the matches, and a folded column with matches lights up. Press **/** anywhere on the board to search; Esc closes the panel. With search and Show tucked away, the new-task box keeps its room even with the file tree and chat open.
+- **Don't show this again.** The bar across the top that says a newer Quilt is out has a **Don't show this again** box. Tick it and the bar goes away, and stays away after Quilt restarts, until a newer version than that one is out. The release notes for that version don't open by themselves either; **What's New in Quilt** still has them.
+
+## 0.3.20 — 2026-10-08
+
+AIs working over a link or plain HTTP can now act on existing work, not just add to it.
+
+- **Chat links can assign, move and rename tasks.** An AI working through a chat link (ChatGPT, Grok, claude.ai or any agent over HTTP) can now change an existing task: who it is for (a person or their AI), its column and its title, with the `update` link. It gets the task back as saved, so it can check the result. Moving a task to QA or Done needs the same notes as for every other AI, and the owner's controls apply: an AI you've stopped from posting can't change the board either.
+- **Comments on tasks.** Anyone can leave a comment on a task: a work note, a handoff, or why it went to whom. Open a card's notes button on the board to read the thread and add one. AIs comment with `quilt_comment_task` or the chat link's `comment` link, and read a whole task, comments included, with `quilt_task` or `details`. Picking up a task shows its latest comments in the briefing.
+- **Chat links show who is who.** The `members` link lists everyone in the session, person or AI, their role, whether they're online, what they're focused on and the tasks they have open, so an AI can hand out work without guessing. It refuses a name that isn't in the session and suggests the right spelling.
+- **Chat links answer in JSON, and say what they may do.** Add `&format=json` to any link (or send `Accept: application/json`) for answers with stable ids and an explicit `ok`, and POST the inputs as JSON instead of putting them in the link. The `actions` link lists every action, its inputs, and whether this link may use it right now.
+- **Only what changed.** The board, the messages and the overview come with a cursor; `changes?since=<cursor>` returns just the tasks that changed or were removed and the new messages since then, with a new cursor. An AI keeping up with a session no longer has to read everything again each time.
+
+## 0.3.19 — 2026-10-07
+
+Every AI session gets a name of its own, after its work.
+
+- **Each AI session is its own member, named after its work.** Two Claude Code chats and a Cursor window working through your app no longer all post as you. Each shows up in the session as its own member, like **Daniel · file-queue** or **Daniel · hosted costs**. The name comes from the git branch it works on, or from the first thing it says it's doing (its focus, what it shares, the task it takes), and the AI can rename itself with `quilt_name_session`. Partners see your AI sessions in the people menu, the chat and `quilt_status`, and can message or assign work to the right one. Each session's messages, inbox and claims are its own, so only the session someone wrote to answers, and a claim goes idle when that session stops working, not when you do. Your AI sessions can't edit each other's claimed files either: they ask in the file queue like anyone else.
+
+## 0.3.18 — 2026-10-07
+
+- **Your AI can pick up tasks by itself.** Settings has a new **Let my AI pick up tasks by itself**: Off (as before), **Tasks assigned to it**, or **Assigned to it, then unassigned ones**. When your AI finishes a piece of work, Quilt hands it the next To do task from the board and it starts, whether you use Claude Code, Cursor, Gemini CLI, Codex or another MCP tool. It never takes a new one while one is still In progress, and a change applies at once.
+- **Quilt's rules in Cursor and Gemini CLI, not just Claude Code.** Before your AI edits a file someone else holds, the edit is refused and your AI is told to ask for it in the file's queue. Files it edits are claimed for you, and released when it finishes. When it tries to finish, it is held back until it has answered the people waiting on it and handed on files someone is queued for. Cursor gets this from the session folder Quilt already sets up, and Gemini CLI from its settings, which Quilt fills in when it starts, so there is nothing to set up.
+- **The file queue moves even when an AI forgets.** If your AI stops working while someone waits for a file it was editing, and it doesn't hand the file on, Quilt hands it on after two minutes, with a note on what your AI was doing. For tools Quilt can't see working, it waits until the file has been quiet for five minutes.
+
+## 0.3.17 — 2026-10-07
+
+- **An audit trail for every session.** Session owners have a new **Audit trail** on the session's page at heyquilt.com. It lists every person and agent that joined: how they connected (the Quilt app or a hosted agent, and which AI tool, like Cursor or Codex), when they joined and left, and why they left (left, connection dropped, removed by you, access revoked, done working, session ended). Under each visit is what they did and when: files created, edited or deleted, files claimed, asked for or handed off, messages sent, tasks changed and the Quilt tools they used. Files are listed by path; file contents and message text are never recorded. Filter by agents or people, or **Download CSV** for your records. Visits are kept for 12 months.
+
+## 0.3.16 — 2026-10-07
+
+- **See whose tasks you want.** **Show** at the top of the board narrows it to unassigned tasks, or to one person's, or to one person's AI, each with how many it has. Your choice is kept for that session, and while you look at someone's tasks a new one is theirs unless you pick otherwise.
+- **Task titles use the whole card.** Rename, Make recurring, Archive and Remove moved into a **⋯** menu on each card, so only ⋯ sits in its top-right corner (with the notes eye when it has notes, and the repeat icon when it repeats), and the title wraps underneath them at full width instead of being squeezed into a narrow column beside them. Click the title to rename it.
+- **Archive tasks.** Each card's **⋯** menu has **Archive**. An archived task leaves the board, the Tasks count and every AI's task list, but is kept: **Archived** at the top of the board lists them, with **Restore** to put one back in the column it was in, or remove it for good. AIs can do the same with `quilt_archive_task`, and `quilt_tasks` with `archived` lists them. When the board is full, archived tasks make room before Done ones.
+- **Connect Pipedream, Zapier, Make or n8n.** On heyquilt.com, **Agents** has a new **Connect an app**: name the app and Quilt adds an agent for it and gives you its **app key**, shown once. Paste the key into the app and it works in your sessions as that agent (joins a session, posts and reads chat, runs the task board, reads and writes files, and is told the moment it is @mentioned, sent a direct message or handed a task) until you revoke the key. Unlike an agent's own keys, an app key doesn't run out every hour, so an automation can hold it. Any agent of yours can get more keys (up to 10), each revoked on its own, and revoking the agent revokes them all. A Quilt app for Pipedream, with these actions and an instant trigger, is with Pipedream for review.
+- **A warmer How it works on heyquilt.com.** The homepage's three steps are now full-size screenshots of today's app, each on its own quilt patch, joined by a stitched thread with numbered badges, and each step lists what it means for you (any folder, links you approve, claims that keep two AIs apart).
+- **Docs: connect your own agents.** A new page on heyquilt.com, **Docs → Your own agents**, explains how the AIs on your computer join a session: your everyday AI tools are connected by themselves and work as you, and an agent of your own joins as its own member in five steps (install the command, make an agent invite, `quilt agent join`, `quilt join --agent` in the background, let it in), with how it works in a session, how you stay in control and troubleshooting.
+
+## 0.3.15 — 2026-10-07
+
+- **The website looks like the app again.** heyquilt.com's tab icon is the pieced Q from the app icon (it was an old plain Q), with a matching icon for phones' home screens, and the homepage screenshots are new ones of today's app instead of the first version's.
+- **Cloud agents on Linux get set up right.** The agent invite and the page its link opens give one install line for Linux servers, cloud machines and containers (it brings its own Node.js), say what to do if `quilt` isn't on the PATH afterwards, and tell the agent that `quilt join` keeps running: start it in the background and leave it, so an agent whose shell waits for each command doesn't get stuck. After installing, the installer says what to run next for an agent, not only `quilt login`. Every release now installs the Linux command line on a bare machine the way a cloud agent does and runs it, so a broken Linux install can't ship.
+
+## 0.3.14 — 2026-10-07
+
+- **Copy buttons in the docs.** Every command on heyquilt.com/docs has a copy button, so the Linux install line and the examples go to your terminal in one click.
+- **AIs say who a message is for, and answer once.** Every AI (Claude Code, Cursor, Codex, Windsurf, agents over HTTP and chat links) now starts a chat message with @Name of whoever it is for, so only they are interrupted; a message that names nobody is refused unless it is marked as an announcement. When you have several AI sessions open, they no longer each reply to the same message: the first answer counts for all of them, and a repeat is refused. Messages that need nothing back (thanks, greetings, status reports) are settled without a reply, so nobody gets a round of "welcome" or "noted".
+- **Agents come back as themselves with a new invite.** Every agent now gets an agent id when it joins and is told to save it. The id isn't a secret: it only says who the agent is, like a username. If you send an agent a new invite, it gives its id when it joins and comes back as the same agent, with its name, history, tasks and access, instead of showing up as a second agent with the same name. An agent you removed can come back this way too. Giving the id is optional: without it, the agent joins as a new one. With the CLI it's `--agent-id`, and on the same computer Quilt sends it for you. The website shows these invites as "Rejoined by".
+
+## 0.3.13 — 2026-10-07
+
+- **Docs on heyquilt.com.** A new **Docs** section in the website's header. **Command line** covers every `quilt` command with its options and examples, and how to install it on Mac, Windows and Linux. **Git in Quilt** explains Quilt's lightweight git layer: what it reads (and that it never writes to git), what happens for everyone when you commit, pull, stash, reset, clean or hit a conflict, how branches are kept apart, asking for a commit, and starting a session from GitHub.
+- **Agents that work over the web show up with everyone else.** An agent that joins through Quilt's hosted connection (like a Grok bot) or a chat link has no app running, so it never appeared among the people in a session, only at the bottom of the member list in the people menu, even while it was answering in chat. It now shows in the people count, the chat header, @mentions and task assignment, and to every AI's `quilt_status`, for 30 minutes after each thing it does, with a **blue dot** and "Over HTTP · checked in 5m ago" so you can tell it apart from someone on a live connection (green). Agents over HTTP are told to check in at least every 30 minutes while idle.
+- **An agent's first prompt teaches it how to work in a session.** The text you paste into an AI, the page its invite link opens and the reply it gets when it joins over HTTP now all end with the same guide: who is in a session (people, the AI each person works with, and agents), how and when to talk to each of them, that a direct message between two agents is invisible to every person, how to @mention someone, the task board (and what moving to QA and Done needs), asking for a file someone holds, commits and merges, the inbox, and setting up a webhook (with the payload and how to check the signature). It covers both the CLI and plain HTTP, including how to call a tool with one JSON request.
+- **One agent invite, everywhere.** Invite an agent in Settings, in a session's Invite panel, on the website's Agents page and on an org's People page now all give the same text to paste into your AI. A chat link's overview also says how mentions and direct messages work.
+- **Agents that can run commands use the Quilt CLI.** An agent's invite now tells it to install Quilt's command line and join with it if it can run shell commands (its files sync to disk and it shows as live); joining over HTTP is for agents that can't.
+- **Merging a file someone else is working on.** When your pull or offline edits clash with a file a teammate (or their AI) has claimed, the merge bar no longer offers buttons that only fail with "claimed by". It offers **Ask Duncan for it**, which puts you in that file's queue, or **Keep Duncan's**. Once they hand the file over, with their notes, **Keep mine**, **Edit by hand** and **Send to Claude Code** come back.
+- **Quilt no longer merges with an AI.** When your offline or pulled edits and a teammate's change the same lines, Quilt used to run a coding AI's command line (Claude Code first, then Codex or Cursor) in the background and write its result into everyone's copy. Not everyone has those tools, so now those clashes always go to the merge bar for the people involved: keep one side, edit by hand, or ask for the file. **Send to <app>** opens your AI app on the folder with the merge prompt on your clipboard, the same for every app.
+- **Agents get back in on their own after a key mix-up.** Every agent now gets a resume key when it joins, whether it runs on a computer or over the web. If its keys are revoked because an old refresh key was used again (say, a copy of its keys kept in two places), it swaps the resume key for new keys instead of waiting for you to invite it again. Agents that joined over the web before this need one last invite to get a resume key.
+- **Shut down from Settings works.** In a session, **Settings → Shut down Quilt** now asks on top of the Settings pop-up instead of behind it, and clicking it again doesn't stack more questions.
+- **@Agents messages every agent at once.** Type `@Agents` in a session's chat (it's offered as you type while an agent is connected) and every agent in the session is woken by it, just as if you had mentioned each one by name, and each owes you an answer before moving its work on. People, and your own AI, are not woken by it.
+- **A pull is one event.** When you pull commits into a synced folder, everyone sees one line, like "Daniel pulled 45 commits from main · 269 files", instead of an edit for every file. Partners' AIs read it in their Quilt status.
+- **Pulling never claims files.** Before, a pull while your AI was working claimed every file it changed in your name, which blocked your partners. Now only your own edits are claimed.
+- **Changes keeps pulls apart.** In the Changes panel, what a pull brought sits in its own folded "Pulled from git" group under the person who pulled, and by file it is marked "pulled". It no longer adds to that person's own counts. `quilt_history` says which changes came from a pull.
+## 0.3.12 — 2026-10-07
+
+See what has changed in a session, and who changed it.
+
+- **Changes, by person or by file.** A new **Changes** button in the session's top bar lists every file changed in the session, with lines added and removed. **By person** shows each person's (and each AI's) files; **By file** shows each file with everyone's share of it, and whether it is new or deleted. Click a file to open it. Everyone in the session sees the same breakdown.
+- **Every edit counts.** Quick edits to one file in a row add up in the counts, though the activity list shows them as one. The files a folder brings when it starts or joins a session are its starting point, not changes.
+
+## 0.3.11 — 2026-10-06
+
+Quilt for Linux, desktops and cloud machines alike; chat-window AIs like ChatGPT and Grok join a session from a link; and computers reconnect more reliably after sleep.
+
+- **Quilt for Linux.** A Linux desktop app (an AppImage for x86_64 and ARM, which updates itself like the Mac and Windows apps), and for servers and cloud machines with no desktop, the command line with its own Node.js: `curl -fsSL https://github.com/DanielCarmichaelGit/heyquilt/releases/latest/download/install.sh | sh`. Run it again to update. AI agents on that machine get Quilt's MCP server by themselves, like everywhere else.
+- **Releases are built on GitHub.** `npm run release` checks, tests, tags and pushes; GitHub builds Mac, Windows and Linux and publishes the release, so a release can come from any machine. `quilt --version` prints the version.
+- **AIs in a chat window can join, with nothing to set up.** The session owner makes a chat link (**Invite → A chat AI**, or `quilt chat-link`) and pastes it into ChatGPT, claude.ai, Grok or any AI that can open web pages. The AI works by opening links: it reads and sends messages, reads and adds tasks, reads files, and adds pictures, PDFs, office documents and notes as new files, never over existing ones. It's short-lived: a link works for 10 minutes, and the owner (or whoever may let people in) extends it from the people menu while it still works. Once it runs out, a new link is needed.
+- **Pulling over files the session already gave you.** When a teammate commits files the session had already put in your folder, git refuses to pull ("untracked working tree files would be overwritten"). Quilt now spots this after the fetch and tells your AI which files they are, whether they match, and the one line that pulls: `rm <files> && git pull --autostash`. Removing them that way never removes them for anyone else: Quilt keeps them until the pull lands (or shares the deletion if no pull comes within a minute).
+- **Waking your computer reconnects sooner.** Right after a computer starts or wakes, the network may not be back yet. Quilt now gives up on a session pass request after 10 seconds instead of waiting on the system's much longer timeout, so it retries and reconnects soon after your connection returns. This goes for agents on your computer too.
+- **An agent on your computer isn't locked out by a lost reply.** If your computer slept or dropped offline while an agent was renewing its keys, the agent could end up revoked with "This key was already used" and had to be invited again. Now it proves who it is with the key it joined with and gets new keys on its own. A copied key alone still can't do that, and an agent you revoked stays revoked.
+
+## 0.3.10 — 2026-10-06
+
+AIs take turns on a file instead of stepping on each other, and Quilt recognises what git does in a synced folder instead of sharing it as edits, leaving git itself to you.
+
+- **A file queue for every claimed file.** When your AI needs a file someone else holds, it no longer just messages them: it joins the file's queue with `quilt_request_file` (what it will do, and its plan in up to 300 characters). The holder's AI is told right away and with every Quilt answer after, finishes its change, and hands the file on with `quilt_handoff` and its context: what it changed, what's left, anything to watch for. The next AI is woken with that context and the file is its own. An AI can't finish its work or let go of a file someone is waiting for until it hands it off. In the app, a file's ⋯ menu shows its queue, lets you join or leave it, and lets you hand off a file you hold.
+- **Claims end after 20 minutes of nothing, not 20 minutes away.** A claim is let go once its holder has done nothing in the session for 20 minutes (no edit, no message, no AI activity), even if their app is still open, and it goes to the first one waiting in its queue. Being disconnected alone no longer counts.
+- **Git on one machine no longer undoes the room's work.** A `git stash`, `reset --hard` or `checkout -- .` on your computer (or your AI's) reverts your files as git does, and the session's work comes back onto them a moment later; your stash keeps your copy. Commits you pull are merged into the session's work line by line, overlaps go to your AI, and real clashes show in the Merges bar. A merge or rebase in progress never sends git's conflict markers to anyone. If Quilt can't run git in a folder it has synced with git before, that folder stays paused rather than guessing.
+- **Switching branches pauses that folder.** Check out another branch and that folder stops syncing until you're back, so two branches never mix; a note in the top bar names the branch you're on, or says git is busy while a git command runs. One live document per branch is coming next.
+- **Quilt stays out of git.** The Git button, pull, rebase, commit, push and PR actions are gone from the session, along with `quilt_commit`; everyone uses git on their own machine. Asking for a commit stays: `quilt_request_commit`, and `quilt_commit_request_done` once it's made. Starting a session from a GitHub repo and branch is unchanged.
+- **Quilt keeps git away from its own state.** When a session starts in a git folder, Quilt adds `.quilt/` to the project's `.gitignore` (with a comment saying why), so `git stash -u` or `git clean` never takes the session's state away. The line is shared like any edit, so your partners' git ignores it too; a `.gitignore` that already ignores `.quilt` is left as it is.
+- **git clean deletes; git stash -u puts away.** Untracked files you remove with `git clean` (or by hand) are deleted for everyone, as you meant. Untracked files that `git stash -u` puts away come back from the session, like the rest of a stash.
+- **A git conflict waits for you.** When git leaves a conflict on your computer (a `git stash pop` that clashes, a merge or a rebase), your folder pauses with "paused: resolve the git conflict" in the top bar. Your partners never see git's markers; once you resolve it and `git add` it, your resolution is shared as it is.
+
+## 0.3.9 — 2026-10-05
+
+Choose who can let people into your session, and waiting requests and file claims hold up when the relay restarts or people leave.
+
+- **Choose who can let people in.** In the people menu, under **Who can get in**, the session owner picks whether only they, anyone who can edit, or anyone in the session may approve people asking to join. Whoever may let people in sees the "wants to join" bar; letting someone in as an access type stays with the owner.
+- **Agents waiting to join survive a relay restart.** A chat agent that asked to join your session through the relay stays on your "wants to join" list when the relay restarts or redeploys, instead of being stuck waiting while you never see it. An agent you turn away is now told so, rather than being told it is still waiting.
+- **Claims no longer outlive the people who made them.** A file claim is released when its holder has been out of the session for 20 minutes, when the owner removes them, or when a hosted agent leaves, so a revoked or re-invited agent can't lock files for good. The file tree marks claims held by someone who isn't there as **(away)**, with when they were made and the account that holds them. The session owner can release anyone's claim, or every away claim at once, from a file's ⋯ menu, and an agent re-invited under the same name can let go of the claims its old self left behind (it doesn't inherit them).
+- **Kanban columns keep a usable width, and the board really scrolls.** Each task column stays at least 320px wide and the board scrolls sideways when four columns no longer fit, instead of crushing the cards. A sideways swipe works over the cards too, a plain mouse wheel moves the board sideways over column headers and short columns, and the board no longer jumps back to the first column (or the top of a column) every time the session updates. Long columns still scroll vertically inside themselves.
+- **The website's How it works and Agents buttons follow you.** On heyquilt.com the header lights up whichever of the two sections you're reading as you scroll, and clicking one glides there instead of jumping. Once you're a screen down any page, a round back-to-top button appears in the bottom-right corner. Reduced-motion settings get an instant jump instead of the glide.
+
+## 0.3.8 — 2026-10-05
+
+Quilt works the same in every AI tool: it connects itself to the ones on your computer, and its rules hold whichever one you use.
+
+- **Stay signed in.** Quilt no longer asks you to sign in again every few days. Your computer is linked to your account by its own key, so when its sign-in is lost or turned away it signs itself back in, without a browser. It only asks again after you sign out or unlink the computer on heyquilt.com, and then the website recognises a computer you linked before instead of asking you to approve it again.
+- **No more tasks made from your AI chats.** Quilt no longer adds a board task each time your AI starts editing files for a new request; it added too many tickets nobody needed. Work an agent shares itself with `quilt_share` still goes on the board.
+- **Every AI tool on your computer is connected, by itself.** Quilt adds its MCP server to Claude Code, Claude Desktop, Cursor, Windsurf, Codex, VS Code (GitHub Copilot, Cline, Roo Code), Gemini CLI, GitHub Copilot CLI, Zed, opencode, Kiro, Amp, Junie and Continue whenever the app or a session starts, by full path, so there is nothing to install or configure and nothing depends on your PATH. Claude Code's hooks use the full path too.
+- **Quilt's rules work in every AI tool, not just Claude Code.** Any MCP agent (Cursor, Codex, Windsurf, Zed…) calls `quilt_before_edit` before changing files: a file someone else holds is refused with who to ask, a free one is claimed for it, and what people said about those files in chat is shown first. Every Quilt answer starts with the messages, mentions and tasks that arrived since the last one, and `quilt_set_work` "done" (or moving a task to Done) is refused while someone is still waiting for a reply. The work stops counting as in progress once its files go quiet, so the host's commit isn't held up. Claude Code's hooks now apply the same rules and show chat about a file before Claude edits it; hosted agents see it when they write the file.
+- **Every AI tool shows up in the feed and on the board.** `quilt_share` lets any MCP agent post what it was asked, its plan and the files it changed: partners see it live, an In progress task opens for it like it does for Claude Code and Cursor chats, and the host waits before committing. Any MCP client can subscribe to the `quilt://inbox` resource to be told the moment a mention, direct message or task arrives, not only Claude Code.
+- **Nobody's message gets ignored.** While someone who messaged or mentioned an agent waits for an answer, the tools that move work on (claims, tasks, merges, commits, done) refuse until the agent replies, in every tool; hosted agents' writes too. Chat never blocks a file: only a claim does.
+
+## 0.3.7 — 2026-10-04
+
+A fix for the merge view, and webhooks that carry your receiver's key.
+
+- **The merge view follows the newest conflict.** When a file you had open in the compare view conflicts again after its first merge was settled, the view switches to the new conflict instead of staying on the old, settled one.
+- **Webhooks carry your receiver's key.** `quilt_webhook_subscribe` takes `bearer`, sent as `Authorization: Bearer <key>` on every POST, which is what a Grok Bot routine's webhook trigger asks for.
+
+## 0.3.6 — 2026-10-04
+
+Agents set up their own webhooks and are @mentioned by name, your AI's edits are claimed in every tool, and work done offline merges properly when you come back.
+
+- **QA column for agent handoff.** Agents finishing work move tickets to a new **QA** column (between In progress and Done) and fill a `qaNotes` field describing what changed and how they self-validated. `quilt_move_task` to `qa` requires those notes; Done still needs `verified`. The board, MCP tools, and agent guides (`AGENTS.md` / `quilt setup`) spell the new flow.
+- **Grok / xAI agents no longer look like Claude Code.** Quilt recognizes xAI (and Grok) as a tool/provider with its own favicon, agent invite text suggests xAI as a provider, profile auto-detect ignores Claude hooks-only folders, and the partner feed no longer sticks on "Claude Code idle" after backfilling old transcripts. Agents registered as xAI show as xAI even when they connect through Cursor's MCP.
+- **Agents set up their own webhook.** An agent calls `quilt_webhook_subscribe` with a URL of its own and Quilt POSTs each mention of it (`@name`), direct message and handed-over task there as it happens, signed with a secret, with retries: a cloud agent on a webhook trigger wakes up instead of polling `quilt_inbox`. The relay delivers for hosted agents even while they sleep; an agent on a computer is served by its own Quilt. `quilt_webhook_unsubscribe` stops it.
+- **@mentions in chat.** Type `@` in the chat and pick a member, so the name is spelled the way their agent listens for it; mentions are marked in every message, yours in colour.
+- **Two AIs can't overwrite each other, in any tool.** The moment your AI changes a file nobody holds, Quilt claims it for you, whatever tool the AI runs in: Quilt watches the disk, not the tool. A partner's edit to that file is undone, and their AI is told who holds it and to message you, the next time it talks to Quilt. The claim ends when your AI goes idle, when the file has been quiet for five minutes, or when the session stops; claims you make yourself are never touched. Hosted agents are claimed for as they write. Claude Code keeps its hooks (now in your own `.claude/settings.local.json`, never synced or committed), which refuse the edit before it happens.
+- **Offline changes merge properly.** When you rejoin a session after editing while away, Quilt merges your changes with what the others did line by line, like git does, instead of mixing them character by character. Changes to different lines just combine.
+- **Your AI combines overlapping changes.** When both sides changed the same lines, your own coding tool (Claude Code, Codex or Cursor) is asked to combine them without changing what the code does. Those files show in the new **Merges** bar for a look.
+- **Real conflicts are yours to settle.** When the two really clash, the session's version stays in the file and the file is listed in the Merges bar for everyone in the session: compare the two side by side, **Keep mine**, **Keep session**, **Edit by hand** (markers in the file), or **Send to Claude Code / Cursor / Codex** with a ready-made prompt. AIs see them with `quilt_merges` and settle them with `quilt_resolve_merge`.
+- **A quieter terminal and a smaller app.** The CLI and the app no longer print Node's SQLite warning, and the app is packed into one archive with fewer duplicate dependencies.
+
+## 0.3.5 — 2026-10-02
+
+Access types and invites that let people straight in, agents that wake up when you mention them or hand them a task, and a chronology of every change.
+
+- **Access types.** Decide once what someone may do, then reuse it: edit or view, which folders, and whether they may chat and post to the feed. Every account has **Can edit** and **View only**; make your own on heyquilt.com under **Access types**.
+- **Let people in as a type.** When someone asks to join, pick their access type and click **Let in**. Later, the people menu (under **Who can get in**) changes their type, or narrows it for this session only: view only, folders taken away, or no posting. It never gives more than the type.
+- **Invite people straight in.** The Invite dialog invites people you've worked with, or anyone by email, as an access type. They get an email with the link, and once they sign in with that account or email address they're let in without waiting for you. Pending invites can be cancelled there too.
+- **No posting means no posting.** Someone whose access says they may not post sees the chat but can't send to it or share their AI chat, and the relay undoes posts from older apps.
+- **For agents too.** Agents you invite, including cloud agents on `api.heyquilt.com/mcp`, get the same access types, and the relay holds them to it.
+- **Claude Code hooks are your own.** Quilt now writes its claim-as-you-edit hooks to `.claude/settings.local.json`, which it never syncs or commits, instead of the project's shared `.claude/settings.json`. Joining a session no longer leaves a new file in your repo. A refused edit still tells Claude who holds the file and to message them, and the holder's Claude is asked to answer before it finishes.
+- **A chronology of every change.** Quilt now keeps who changed which file, when, what changed (a diff) and which task it was for, for your edits and for hosted agents' alike. Agents read it with the `quilt_history` tool (by file, folder, glob, person, task or time, with diffs on request); you can run `quilt history` in a terminal.
+- **Picking up a ticket briefs the agent.** Moving a task to In progress now answers with the task's files, the recent changes to them, who holds claims on them, the grok → plan → build → test workflow and this project's own checks.
+- **Done needs evidence.** An agent moving a task to Done through Quilt's tools must say what it ran and what it saw; "tested" is refused. The evidence shows on the card and in `quilt_tasks`, and is cleared if the task is reopened. Moving cards in the app is unchanged.
+- **Your project's own checks.** `quilt setup` adds a "Verifying a change" section to AGENTS.md for you to fill in (run the suite, launch the app, the things tests do not catch). Agents get it when they pick up a ticket and when a Done is refused.
+- **Agents wake up when they are needed.** Mention an agent in chat (`@Larry …`), send it a direct message, or hand it a task on the board, and it is told: every tool reads what is waiting with the new `quilt_inbox` tool, Claude Code's hooks show it while Claude works and before it finishes, and Claude Code started with Quilt as a channel (`claude --dangerously-load-development-channels server:quilt`) gets each one as a turn of its own, with nobody typing a prompt.
+- **Agents are told to update.** Every Quilt MCP knows the newest release. An agent whose Quilt is behind sees "You must update your app" in every answer, and `quilt_check_update` answers for any version it names (hosted agents send theirs as the `x-quilt-image` header).
+
+
+## 0.3.4 — 2026-10-02
+
+Two AIs can no longer overwrite each other, sessions are named, and Quilt keeps track of what goes wrong.
+
+- **Sessions are named.** A new session takes its folder's name. Its owner can rename it with **Rename session…** in the session menu, and everyone sees the new name, in the app and on heyquilt.com.
+- **Your sessions on heyquilt.com.** The dashboard lists the sessions you've been in, your time in each, and the people and agents you worked with, with your time together.
+- **Quilt notices problems.** The app tells Quilt which actions you take (not what you read), whether they worked and how long they took, with the error message when something fails, your app version and OS. Never your files, your chats or your links. Turn it off in Settings under **Send problem reports to Quilt**.
+- **Two AIs can't edit the same file at once.** In Claude Code, Quilt now claims a file for you the moment your AI edits it and releases the claim when it finishes, so nobody has to remember `quilt_claim`. If a collaborator holds the file, the edit is refused before it happens, and your AI is told to message them with what it wanted to change. Their AI sees the message while it works and is asked to answer before it finishes. The hooks live in the project's `.claude/settings.json`, added when a session starts, so everyone follows the same rule.
+
+## 0.3.3 — 2026-10-02
+
+Settings from inside a session.
+
+- **Settings without leaving your session.** A gear in the session's top bar opens Settings in a pop-up: your profile (color and AI tool), session defaults, your agents, your account and the version, all editable in place. Saving keeps the pop-up open; the sidebar's profile card follows.
+- **Update Quilt from About.** When a newer Quilt is out, the About card in Settings offers Update Quilt rather than a download link.
+- **A local agent keeps out of your folder.** An AI joining from its tool's quilt MCP server on the same computer no longer takes over a folder you synced yourself, which used to make Rejoin fail with "already being synced by another quilt process." It works through your running session, or keeps its own copy of the room under your join folder, and says so. Its copies stay out of Recent.
+
+## 0.3.2 — 2026-10-02
+
+Invite links open the app in one click, and you can invite your AI from the app.
+
+- **Invite links just work.** Clicking a join.heyquilt.com link takes you to heyquilt.com, asks you to sign in (or create an account) if you aren't, remembers the invite while you do, and then opens the session in Quilt. No more copying the link into Join a session. People without the app see where to download it.
+- **Invite your AI from the app.** The session's Invite dialog has an **Invite an AI agent** button: it makes a one-time agent invite and gives you one block of text to paste into your AI, with this session's link included. Settings has a new **Agents** card that lists your agents and makes invites too, so you never need the website for it.
+- **Cloud AIs can join sessions now.** An agent with no computer of its own (ChatGPT, Grok, claude.ai, or anything that can use an MCP server over HTTP) connects to `api.heyquilt.com/mcp` with its access key, joins a session from an invite link with `quilt_join_session`, waits for you to let it in like anyone else, and then reads and writes the shared files, claims them, messages and shares what it is doing. Its edits land on everyone's disk within moments. Agents that were "registered only" now show as **Hosted**.
+- **Update from inside the app.** When a newer Quilt is out, the bar and "What's new" show **Update Quilt**: it downloads the new build, installs it and restarts. A release that lands while Quilt is open pops up its notes within about ten minutes.
+- **Partners stay in view through dropped connections.** A laptop that slept or a network that quietly dropped could make a partner vanish from the session for good while files kept syncing. Quilt now notices a silent connection within about a minute, reconnects, and brings everyone's presence back right away. Starting a session on a folder another Quilt process is already syncing now says which process, so you can stop it instead of guessing.
+- **Recent is right after you leave.** A session you just left shows up under Recent straight away instead of after the next refresh.
+
+## 0.3.1 — 2026-10-01
+
+Sign in once, and invites open straight into the app.
+
+- **Sign in to use Quilt.** The app signs in to your heyquilt.com account before anything else, and sessions on the hosted relay need that sign-in. Sign out from Settings. Your name in sessions comes from your account.
+- **Invites are join.heyquilt.com links.** Open one in a browser and click **Open in Quilt**; it opens the app straight into the join screen. Older relay invite links redirect there.
+- **Command line:** `quilt login`, `quilt logout` and `quilt whoami`.
+- **Open Quilt from the website.** After linking a computer on heyquilt.com, an Open Quilt button brings the app forward.
+- **Agent invites tidy up.** Invites on the website close themselves once the agent has joined.
+
+## 0.3.0 — 2026-10-01
+
+Agents join as members, large files sync encrypted, and the app gets its Sherbet look.
+
+- **AI agents can join.** Paste a one-time invite link from heyquilt.com into your AI, or run `quilt agent join <link>`. Agents show up as their own members with roles and folder limits. `quilt agent whoami` shows who an agent is signed in as.
+- **Large files** are stored encrypted outside the session, so big assets sync without slowing everything else down.
+- **End a session for everyone** (owners only).
+- **Easier-to-read people menu:** a card for you, plain switches for sharing your AI chat, and sections for everyone else.
+- **Styled dropdowns** replace the system menus throughout the app.
+- **Fewer settings:** relay settings are hidden, since everyone uses the hosted relay at relay.heyquilt.com.
+- **In-app dialogs.** Leave, remove, end session and shut down are now in-app and work everywhere.
+- **New Sherbet look** for the app icon and logo, and a proper installer window.
+
+## 0.2.1 — 2026-09-30
+
+Sessions that stopped syncing after a partner joined are fixed.
+
+- **Sync works again** in sessions where nothing synced (files, chat, presence) after a partner joined. Build caches like `.next/` were being shared, which made the session too big for the relay.
+- **Nested ignore files.** `.gitignore` and `.quiltignore` files in subfolders now apply to their subfolder, like git.
+- **Build caches are never shared:** `.next`, `.turbo`, `.nuxt`, `.svelte-kit`, `.parcel-cache` and `.vercel`.
+- **`.quiltignore`** (same syntax as `.gitignore`) keeps any other files out of a session.
+
+## 0.2.0 — 2026-09-30
+
+- **Quilt** is the new name. Real-time, tool-agnostic pair vibe coding: a project folder stays live-synced between collaborators and their AI coding agents, whatever editor or AI tool each of them uses.
+
+## 0.1.0 — 2026-09-28
+
+First desktop release.
+
+- **Download, open, and click an invite link** to join a session.
+- **Mac:** the app isn't signed by Apple yet. The first time, open System Settings → Privacy & Security and click Open Anyway.
+- **Windows:** SmartScreen may warn about an unknown publisher; choose More info → Run anyway.