Repository navigation
1.1.0 (2026-11-20)
Patchmill 1.1 adds a browser interface. Run patchmill serve and you get a board of your real issues. Each issue has a live page that shows its spec, plan, mockups, and full run history. On that page you can start an interactive Issue run, chat with the agent, approve gates, and answer a blocked worker, without opening a terminal. Several people can share one session, and they can see who else is there and who is typing.
The web page uses the same machinery as run-once --interactive. To make that possible, run-once now drives Pi over RPC instead of print mode. Planning also got stronger. Every spec and plan now gets an adversarial review, architectural specs get domain analysis, and the planner can add diagrams that explain the idea, not only UI mockups.
There are no breaking changes. Configuration and saved state from 1.0 work as they are.
The interactive web interface
patchmill serve starts a small authenticated web server on 127.0.0.1:4280. Open the token link that it prints. The server stores the token in an HttpOnly cookie and removes it from the address. (#349)
- A board of real issues. The board shows your open issues in workflow columns, with their pull requests, document links, current progress, and a Live marker on issues that a run holds. Host data is cached for one minute and shared by all browsers. Local run progress refreshes on every poll. (#355)
- Run an issue from the page. The issue page is the web version of the interactive console. Press Start to begin an Issue run. Then chat with the planning agent, approve the spec and plan, and answer the worker's questions. Stop reply interrupts the agent and keeps the session open. Pause ends the session but keeps the run and the conversation, and Resume picks up where you left off. Each Web session is one Pi process, and the run behaves as in
run-once --interactive. (#380) - Work on it together. Anyone with the token can join and chat under the name they enter. A question from the run shows as a card in every browser. The first answer wins, and the card closes for everyone else. An issue has at most one live session. A terminal console and a Web session never write the same conversation at the same time. (#380)
- See who's here. The page shows avatars for everyone who has the issue open, and a "Ben is typing" line under the thread. Screen readers announce joins and leaves. Nothing is stored. (#391)
- Watch it happen. Progress, messages, and tool calls stream to the page as they happen, over Server-Sent Events. Elapsed time, the current step, and the final cost update in place. Your scroll position, open tool results, focus, and drafts stay where they are. (#370, #394)
- Read the whole story afterwards. Finished and stopped runs show every attempt in order: steps, the agent's messages, Patchmill's prompts (collapsed), expandable tool calls, blockers, links, elapsed time, and final cost. (#365)
- The documents are on the page. The issue page lists the spec, the plan, and the mockups and diagrams they link to, and opens them in place. They come from committed Git objects on the Issue branch, the pushed branch, or the base branch. An unpushed spec or plan shows as
draft. Mockups run in a sandboxed frame, so they can't read the page, read your cookie, or call the API. (#392) - Try it without a repository.
patchmill serve --sampleshows view-only design fixtures. It needs no config or provider account. (#349)
Use --host and --port to change where the server listens, and set PATCHMILL_SERVE_TOKEN to keep the same token across restarts. A non-loopback address is for a trusted network or VPN only, because plain HTTP does not encrypt the token. Web sessions now also work on plain-HTTP hosts, where browsers don't offer crypto.randomUUID(). (#393)
Planning
- An adversarial Planning review. A fresh reviewer now challenges every spec and plan. It checks code blocks and symbols against the codebase, and it asks whether a builder could follow the plan. The gates you turn on decide when the review runs. Ungated runs get one combined review. In an interactive session you can ask for one at any time. In an unattended run, a question that only a human can answer becomes a recorded, conservative assumption instead of a stop. (#387)
- Domain-aware planning and a fresh architecture review. Architectural specs now include domain and codebase-design analysis, and each plan gets a codebase-backed review. The skill pack now includes the domain-modeling and codebase-design skills. The project's terms file is now
GLOSSARY.md. (#347) - Diagrams that explain the idea. New or revised specs and plans can include a "show-me" visualization. This is an inline sketch, or a committed HTML page next to the spec, that explains the concept. It is separate from UI mockups. (#366)
- Sub-issues get their parent's spec. When an issue is a sub-issue, its planner reads the parent's approved spec as context and still writes its own short spec. Patchmill finds the parent with GitHub's sub-issues API, or a leading
Part of #Nline on Forgejo and Gitea. (#368) - Readable planning branch names. Spec and plan branches now include the issue slug, for example
agent/issue-42-login-timeout--spec. Oldagent/issue-N--specbranches still work, so nothing needs migration. (#390)
Console and kernel
- Run state in the status bar. The interactive console shows
#N <title> · <state>in Pi's footer while a run is active. (#369) - run-once now drives Pi over RPC. Phases start
pi --mode rpcinstead ofpi -p. Results, exit codes, logs, and session files are the same as before. A run now waits until backgroundpi-subagentswork is finished before it settles, and it stops that work on shutdown. This is the base for Web sessions. (#373) - Merged issues are cleaned up in every run mode. Before each run, interactive or not, Patchmill removes the worktrees and local branches of issues whose PRs have merged. It keeps anything dirty and never touches nested checkouts. The
cleanupHooksetting is back. It runs from the worktree before anything is removed. (#351)
Dependencies
- Pi runtime packages are now 1.5.2. (#346)